fix: restore documentation validation

Format regenerated API pages consistently and make persisted tab state explicit so current Solid signal types pass CI.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: ryansolid

osmium/src/mdx-components.tsx

@@ -3,6 +3,7 @@ import {
 	type JSX,
 	Match,
 	type ParentProps,
+	type Signal,
 	Switch,
 	children,
 	createMemo,
@@ -90,13 +91,16 @@ const TabGroup = (props: {
 
 	// Groups sharing a sync key select together across the page and tabs,
 	// and the choice persists between visits.
-	const [openTab, setOpenTab] = makePersisted(createSignal(props.tabNames[0]), {
-		name: `tab-group:${props.syncKey}`,
-		sync: messageSync(new BroadcastChannel("tab-group")),
-		storage: cookieStorage.withOptions({
-			expires: new Date(Date.now() + 3e10),
-		}),
-	});
+	const [openTab, setOpenTab] = makePersisted<string, Signal<string>>(
+		createSignal(props.tabNames[0]),
+		{
+			name: `tab-group:${props.syncKey}`,
+			sync: messageSync(new BroadcastChannel("tab-group")),
+			storage: cookieStorage.withOptions({
+				expires: new Date(Date.now() + 3e10),
+			}),
+		}
+	);
 	return tabs(openTab, setOpenTab);
 };
 

src/routes/reference/(1)solid-js/(1)reactivity/create-effect.mdx

@@ -20,15 +20,15 @@ source_path: "packages/signals/src/signals.ts"
 
 Creates a reactive effect with **separate compute and effect phases**.
 
-- `compute(prev)` runs reactively — *put all reactive reads here*. The
+- `compute(prev)` runs reactively — _put all reactive reads here_. The
   returned value is passed to `effect` and is also the new "previous" value
   for the next run.
 - `effect(next, prev?)` runs imperatively (untracked) after the queue
-  flushes. *Put DOM writes / fetch / logging / subscriptions here.* It may
+  flushes. _Put DOM writes / fetch / logging / subscriptions here._ It may
   return a cleanup function which runs before the next effect or on
   disposal.
 
-Reactive reads inside `effect` will *not* re-trigger this effect — that's
+Reactive reads inside `effect` will _not_ re-trigger this effect — that's
 intentional. If you need a single-phase tracked effect, use
 `createTrackedEffect` (with the tradeoffs noted there).
 
@@ -38,7 +38,7 @@ from upstream reactive sources (including async rejections), which your own
 code has no frame to `try/catch`. The `error` handler is the error arm of
 the effect phase: it runs on the same schedule and in the same imperative,
 writable scope as `effect` (setting error state via signals is fine), and
-only for *settled* errors — a transient error that recovers before the
+only for _settled_ errors — a transient error that recovers before the
 effect phase runs `effect` with the recovered value instead, and a held update defers it exactly as it defers `effect`. Without an `error`
 handler a compute-phase error is logged and the effect simply skips that
 run — a non-render effect's reactivity failing does not crash the app.
@@ -49,18 +49,18 @@ The **effect phase is different**: it is your own imperative code, so handle
 failures with `try/catch` where they occur. An uncaught effect-phase throw
 is treated as an unhandled application error — caught by the nearest
 `createErrorBoundary`/`<Errored>`, and permanently halting the reactive
-system if there is none. It is *not* routed to the bundle's `error` handler.
+system if there is none. It is _not_ routed to the bundle's `error` handler.
 
 ```typescript
 createEffect<T>(compute, effectFn | { effect, error }, options?: EffectOptions);
 ```
 
 > Deprecated: `createEffect(compute)` (single argument) is no longer supported.
-Pass a separate effect function as the second argument:
-`createEffect(compute, effect)`. See `MISSING_EFFECT_FN`.
+> Pass a separate effect function as the second argument:
+> `createEffect(compute, effect)`. See `MISSING_EFFECT_FN`.
 
 - For a side effect that reacts to changes, split the work:
-`createEffect(() => signal(), value => doWork(value))`.
+  `createEffect(() => signal(), value => doWork(value))`.
 - For a derived value, use `createMemo(() => signal())`.
 - For a one-shot side effect at construction time, just call the function.
 
@@ -74,11 +74,13 @@ import { createEffect } from "solid-js";
 
 ```ts
 function createEffect<T>(
-  compute: ComputeFunction<undefined | NoInfer<T>, T>,
-  effectFn: EffectFunction<NoInfer<T>, T> | EffectBundle<NoInfer<T>, T>,
-  options?: EffectOptions
+	compute: ComputeFunction<undefined | NoInfer<T>, T>,
+	effectFn: EffectFunction<NoInfer<T>, T> | EffectBundle<NoInfer<T>, T>,
+	options?: EffectOptions
 ): void;
-function createEffect<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>): never;
+function createEffect<T>(
+	compute: ComputeFunction<undefined | NoInfer<T>, T>
+): never;
 ```
 
 ## Parameters
@@ -101,21 +103,21 @@ A function that receives the new value and is used to perform side effects (retu
 const [count, setCount] = createSignal(0);
 
 createEffect(
-  () => count(),                  // compute: tracks `count`
-  value => console.log(value)     // effect: side effect
+	() => count(), // compute: tracks `count`
+	(value) => console.log(value) // effect: side effect
 );
 
 setCount(1); // logs 1 after the next flush
 ```
 
 ```ts
 createEffect(
-  () => userId(),
-  id => {
-    const ctrl = new AbortController();
-    fetch(`/users/${id}`, { signal: ctrl.signal });
-    return () => ctrl.abort(); // cleanup before next run / disposal
-  }
+	() => userId(),
+	(id) => {
+		const ctrl = new AbortController();
+		fetch(`/users/${id}`, { signal: ctrl.signal });
+		return () => ctrl.abort(); // cleanup before next run / disposal
+	}
 );
 ```
 
@@ -125,16 +127,16 @@ createEffect(
 
 ```ts
 type ComputeFunction<Prev, Next extends Prev = Prev> = (
-  v: Prev
+	v: Prev
 ) => PromiseLike<Next> | AsyncIterable<Next> | Next;
 ```
 
 ### `EffectBundle`
 
 ```ts
 type EffectBundle<Prev, Next extends Prev = Prev> = {
-  effect: EffectFunction<Prev, Next>;
-  error: (err: unknown, cleanup: () => void) => void;
+	effect: EffectFunction<Prev, Next>;
+	error: (err: unknown, cleanup: () => void) => void;
 };
 ```
 
@@ -160,8 +162,8 @@ outcomes — an error that recovers before the effect phase runs the
 
 ```ts
 type EffectFunction<Prev, Next extends Prev = Prev> = (
-  v: Next,
-  p?: Prev
+	v: Next,
+	p?: Prev
 ) => (() => void) | void;
 ```
 
@@ -171,11 +173,11 @@ Options for effect primitives that support deferring/scheduling their initial ru
 
 ```ts
 interface EffectOptions extends BaseEffectOptions {
-  defer?: boolean;
-  schedule?: boolean;
-  sync?: boolean;
-  transparent?: boolean;
-};
+	defer?: boolean;
+	schedule?: boolean;
+	sync?: boolean;
+	transparent?: boolean;
+}
 ```
 
 #### `defer`

src/routes/reference/(1)solid-js/(1)reactivity/create-memo.mdx

@@ -34,12 +34,12 @@ import { createMemo } from "solid-js";
 
 ```ts
 function createMemo<T>(
-  compute: ComputeFunction<NoInfer<T>, T>,
-  options: MemoOptions<T> & { loadingValue: T }
+	compute: ComputeFunction<NoInfer<T>, T>,
+	options: MemoOptions<T> & { loadingValue: T }
 ): SourceAccessor<T>;
 function createMemo<T>(
-  compute: ComputeFunction<undefined | NoInfer<T>, T>,
-  options?: MemoOptions<T>
+	compute: ComputeFunction<undefined | NoInfer<T>, T>,
+	options?: MemoOptions<T>
 ): SourceAccessor<T>;
 ```
 
@@ -67,8 +67,8 @@ fullName(); // "Ada Lovelace"
 ```ts
 // Async memo — reads surface as pending inside <Loading>
 const user = createMemo(async () => {
-  const res = await fetch(`/users/${id()}`);
-  return res.json();
+	const res = await fetch(`/users/${id()}`);
+	return res.json();
 });
 ```
 
@@ -88,15 +88,15 @@ Also used in combination with `SignalOptions` for writable memos
 
 ```ts
 interface MemoOptions<T> {
-  id?: string;
-  name?: string;
-  transparent?: boolean;
-  equals?: false | ((prev: T, next: T) => boolean);
-  unobserved?: () => void;
-  lazy?: boolean;
-  sync?: boolean;
-  loadingValue?: T;
-};
+	id?: string;
+	name?: string;
+	transparent?: boolean;
+	equals?: false | ((prev: T, next: T) => boolean);
+	unobserved?: () => void;
+	lazy?: boolean;
+	sync?: boolean;
+	loadingValue?: T;
+}
 ```
 
 #### `id`
@@ -192,11 +192,11 @@ Options for plain signals created with `createSignal(value)` or `createOptimisti
 
 ```ts
 interface SignalOptions<T> {
-  name?: string;
-  equals?: false | ((prev: T, next: T) => boolean);
-  ownedWrite?: boolean;
-  unobserved?: () => void;
-};
+	name?: string;
+	equals?: false | ((prev: T, next: T) => boolean);
+	ownedWrite?: boolean;
+	unobserved?: () => void;
+}
 ```
 
 #### `name`

src/routes/reference/(1)solid-js/(1)reactivity/create-optimistic.mdx

@@ -42,12 +42,12 @@ import { createOptimistic } from "solid-js";
 ```ts
 function createOptimistic<T>(): Signal<T | undefined>;
 function createOptimistic<T>(
-  value: Exclude<T, Function>,
-  options?: SignalOptions<T>
+	value: Exclude<T, Function>,
+	options?: SignalOptions<T>
 ): Signal<T>;
 function createOptimistic<T>(
-  fn: ComputeFunction<T>,
-  options?: SignalOptions<T> & MemoOptions<T>
+	fn: ComputeFunction<T>,
+	options?: SignalOptions<T> & MemoOptions<T>
 ): Signal<T>;
 ```
 
@@ -71,9 +71,9 @@ Optional object with a name for debugging purposes and equals, a comparator func
 const [todos, setTodos] = createOptimistic(initialTodos);
 
 const addTodo = action(function* (text: string) {
-  const tempId = crypto.randomUUID();
-  setTodos(t => [...t, { id: tempId, text, pending: true }]); // optimistic
-  const saved = yield api.createTodo(text);
-  setTodos(t => t.map(x => (x.id === tempId ? saved : x)));   // reconcile
+	const tempId = crypto.randomUUID();
+	setTodos((t) => [...t, { id: tempId, text, pending: true }]); // optimistic
+	const saved = yield api.createTodo(text);
+	setTodos((t) => t.map((x) => (x.id === tempId ? saved : x))); // reconcile
 });
 ```

src/routes/reference/(1)solid-js/(1)reactivity/create-signal.mdx

@@ -40,10 +40,13 @@ import { createSignal } from "solid-js";
 
 ```ts
 function createSignal<T>(): Signal<T | undefined>;
-function createSignal<T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
 function createSignal<T>(
-  fn: ComputeFunction<T>,
-  options?: SignalOptions<T> & MemoOptions<T>
+	value: Exclude<T, Function>,
+	options?: SignalOptions<T>
+): Signal<T>;
+function createSignal<T>(
+	fn: ComputeFunction<T>,
+	options?: SignalOptions<T> & MemoOptions<T>
 ): Signal<T>;
 ```
 
@@ -66,9 +69,9 @@ Optional object with a name for debugging purposes and equals, a comparator func
 ```ts
 const [count, setCount] = createSignal(0);
 
-count();              // 0
-setCount(1);          // explicit value
-setCount(c => c + 1); // updater
+count(); // 0
+setCount(1); // explicit value
+setCount((c) => c + 1); // updater
 ```
 
 ```ts
@@ -94,15 +97,15 @@ Also used in combination with `SignalOptions` for writable memos
 
 ```ts
 interface MemoOptions<T> {
-  id?: string;
-  name?: string;
-  transparent?: boolean;
-  equals?: false | ((prev: T, next: T) => boolean);
-  unobserved?: () => void;
-  lazy?: boolean;
-  sync?: boolean;
-  loadingValue?: T;
-};
+	id?: string;
+	name?: string;
+	transparent?: boolean;
+	equals?: false | ((prev: T, next: T) => boolean);
+	unobserved?: () => void;
+	lazy?: boolean;
+	sync?: boolean;
+	loadingValue?: T;
+}
 ```
 
 #### `id`
@@ -204,11 +207,11 @@ Options for plain signals created with `createSignal(value)` or `createOptimisti
 
 ```ts
 interface SignalOptions<T> {
-  name?: string;
-  equals?: false | ((prev: T, next: T) => boolean);
-  ownedWrite?: boolean;
-  unobserved?: () => void;
-};
+	name?: string;
+	equals?: false | ((prev: T, next: T) => boolean);
+	ownedWrite?: boolean;
+	unobserved?: () => void;
+}
 ```
 
 #### `name`

src/routes/reference/(1)solid-js/(1)reactivity/flush.mdx

@@ -22,7 +22,7 @@ flush scope before draining the queue.
 
 Reactive updates are normally batched onto the microtask queue, so multiple
 writes in a row collapse into a single update pass. Call `flush()` when you
-need to *observe* the result of those writes synchronously — most commonly
+need to _observe_ the result of those writes synchronously — most commonly
 in tests, but also at the boundary of imperative integration code. Pass a
 callback when the writes themselves should bypass microtask scheduling and
 drain synchronously when the callback returns.
@@ -55,8 +55,8 @@ expect(doubled()).toBe(12);
 
 // Nested flushes drain at each level:
 flush(() => {
-  setCount(7);
-  flush(() => setCount(8)); // inner drain — effects fire here
-  // outer continues with up-to-date state
+	setCount(7);
+	flush(() => setCount(8)); // inner drain — effects fire here
+	// outer continues with up-to-date state
 });
 ```

src/routes/reference/(1)solid-js/(1)reactivity/untrack.mdx

@@ -43,10 +43,10 @@ function untrack<T>(fn: () => T, strictReadLabel?: string | false): T;
 
 ```ts
 createEffect(
-  () => trigger(),                 // tracks `trigger` only
-  () => {
-    const snapshot = untrack(() => state); // read once, untracked
-    log(snapshot);
-  }
+	() => trigger(), // tracks `trigger` only
+	() => {
+		const snapshot = untrack(() => state); // read once, untracked
+		log(snapshot);
+	}
 );
 ```