ci: apply automated fixes

Author: autofix-ci[bot]

scripts/extract-solid-ref.mjs

@@ -56,7 +56,10 @@ const CANONICAL_ROUTES = {
 	refresh: ["lifecycle-actions/refresh.mdx", "Lifecycle & Actions"],
 
 	children: ["components-context/children.mdx", "Components & Context"],
-	createContext: ["components-context/create-context.mdx", "Components & Context"],
+	createContext: [
+		"components-context/create-context.mdx",
+		"Components & Context",
+	],
 	createUniqueId: [
 		"components-context/create-unique-id.mdx",
 		"Components & Context",

src/routes/v2/reference/advanced/interop-async/enable-external-source.mdx

@@ -49,13 +49,13 @@ optional wrapper for `untrack` — disables external tracking too.
 // change. `untrack` mirrors Solid's `untrack()` into the external library
 // so that reads inside `untrack(...)` don't get tracked twice.
 enableExternalSource({
-  factory: (compute, trigger) => {
-    const sub = externalLib.subscribe(trigger);
-    return {
-      track: prev => externalLib.run(() => compute(prev)),
-      dispose: () => sub.unsubscribe()
-    };
-  },
-  untrack: fn => externalLib.untracked(fn)
+	factory: (compute, trigger) => {
+		const sub = externalLib.subscribe(trigger);
+		return {
+			track: (prev) => externalLib.run(() => compute(prev)),
+			dispose: () => sub.unsubscribe(),
+		};
+	},
+	untrack: (fn) => externalLib.untracked(fn),
 });
 ```

src/routes/v2/reference/advanced/interop-async/flatten.mdx

@@ -29,8 +29,8 @@ import { flatten } from "solid-js";
 
 ```ts
 function flatten(
-  children: any,
-  options?: { skipNonRendered?: boolean; doNotUnwrap?: boolean }
+	children: any,
+	options?: { skipNonRendered?: boolean; doNotUnwrap?: boolean }
 ): any;
 ```
 
@@ -51,6 +51,6 @@ value or array of values to flatten
 // Custom renderer walking a children tree manually. Most authors should
 // use `children()` from solid-js, which memoizes the resolved value.
 function renderChildren(value: unknown): unknown {
-  return flatten(value, { skipNonRendered: true });
+	return flatten(value, { skipNonRendered: true });
 }
 ```

src/routes/v2/reference/advanced/interop-async/not-ready-error.mdx

@@ -32,10 +32,10 @@ import { NotReadyError } from "solid-js";
 
 ```ts
 class NotReadyError extends Error {
-  constructor(public source: any) {
-    super();
-  }
-};
+	constructor(public source: any) {
+		super();
+	}
+}
 ```
 
 ## Examples
@@ -44,9 +44,9 @@ class NotReadyError extends Error {
 // Advanced: distinguish "not ready yet" from a real error in custom
 // boundary plumbing. App code should rely on `<Loading>` / `<Errored>`.
 try {
-  const value = readReactiveSource();
+	const value = readReactiveSource();
 } catch (err) {
-  if (err instanceof NotReadyError) throw err; // re-throw to suspend
-  reportError(err);
+	if (err instanceof NotReadyError) throw err; // re-throw to suspend
+	reportError(err);
 }
 ```

src/routes/v2/reference/advanced/interop-async/resolve.mdx

@@ -16,7 +16,7 @@ Awaits a reactive expression and returns its first fully-settled value as a
 waited on; once the expression returns synchronously without `NotReadyError`
 the promise resolves with that value.
 
-Must be called *outside* a tracking scope — it doesn't subscribe, it just
+Must be called _outside_ a tracking scope — it doesn't subscribe, it just
 resolves the current value once.
 
 ## Import
@@ -40,7 +40,7 @@ a reactive expression to resolve
 ## Examples
 
 ```ts
-const user = createMemo(() => fetch(`/users/${id()}`).then(r => r.json()));
+const user = createMemo(() => fetch(`/users/${id()}`).then((r) => r.json()));
 
 // outside any reactive scope
 const initial = await resolve(() => user());

src/routes/v2/reference/advanced/jsx-component-primitives/create-error-boundary.mdx

@@ -29,22 +29,25 @@ import { createErrorBoundary } from "solid-js";
 
 ```ts
 function createErrorBoundary<U>(
-  fn: () => any,
-  fallback: (error: unknown, reset: () => void) => U
+	fn: () => any,
+	fallback: (error: unknown, reset: () => void) => U
 );
 ```
 
 ## Examples
 
 ```tsx
 // Custom boundary that wraps the primitive and adds telemetry.
-function TracedErrored(props: { fallback: (e: unknown) => JSX.Element; children: JSX.Element }) {
-  return createErrorBoundary(
-    () => props.children,
-    (err, reset) => {
-      reportError(err);
-      return props.fallback(err);
-    }
-  ) as unknown as JSX.Element;
+function TracedErrored(props: {
+	fallback: (e: unknown) => JSX.Element;
+	children: JSX.Element;
+}) {
+	return createErrorBoundary(
+		() => props.children,
+		(err, reset) => {
+			reportError(err);
+			return props.fallback(err);
+		}
+	) as unknown as JSX.Element;
 }
 ```

src/routes/v2/reference/advanced/jsx-component-primitives/create-loading-boundary.mdx

@@ -26,9 +26,9 @@ import { createLoadingBoundary } from "solid-js";
 
 ```ts
 function createLoadingBoundary(
-  fn: () => any,
-  fallback: () => any,
-  options?: { on?: () => any }
+	fn: () => any,
+	fallback: () => any,
+	options?: { on?: () => any }
 ): () => unknown;
 ```
 
@@ -37,10 +37,13 @@ function createLoadingBoundary(
 ```tsx
 // Custom boundary component built on the primitive. App code uses
 // `<Loading fallback={…}>` directly.
-function MyLoading(props: { fallback: JSX.Element; children: JSX.Element }): JSX.Element {
-  return createLoadingBoundary(
-    () => props.children,
-    () => props.fallback
-  ) as unknown as JSX.Element;
+function MyLoading(props: {
+	fallback: JSX.Element;
+	children: JSX.Element;
+}): JSX.Element {
+	return createLoadingBoundary(
+		() => props.children,
+		() => props.fallback
+	) as unknown as JSX.Element;
 }
 ```

src/routes/v2/reference/advanced/jsx-component-primitives/create-reveal-order.mdx

@@ -14,6 +14,7 @@ source_path: "packages/solid-signals/src/boundaries.ts"
 Coordinate the reveal timing of sibling loading boundaries.
 
 Accepts reactive accessors:
+
 - `order`: `"sequential"` (default) | `"together"` | `"natural"`.
   - `"sequential"` — classic frontier reveal: siblings reveal in registration order
     as each resolves; later siblings stay hidden until earlier ones complete.
@@ -34,6 +35,7 @@ releases that slot. Once released, the inner controller runs its own order local
 over anything still pending. There is no opt-out from an outer hold.
 
 "Minimally ready" is what an order considers its first visible content:
+
 - `sequential` — frontier-0 is minimally ready (leaf: on resolve; nested: via its
   own minimal signal).
 - `together` — every direct slot is minimally ready.
@@ -50,8 +52,8 @@ import { createRevealOrder } from "solid-js";
 
 ```ts
 function createRevealOrder<T>(
-  fn: () => T,
-  options?: { order?: OrderAccessor; collapsed?: BoolAccessor }
+	fn: () => T,
+	options?: { order?: OrderAccessor; collapsed?: BoolAccessor }
 ): T;
 ```
 
@@ -61,8 +63,8 @@ function createRevealOrder<T>(
 // Primitive form of `<Reveal>` — coordinate sibling loading boundaries
 // programmatically. App code uses the JSX `<Reveal>` component instead.
 // Both options are accessors so they can react to state changes.
-createRevealOrder(
-  () => renderSiblings(),
-  { order: () => mode(), collapsed: () => true }
-);
+createRevealOrder(() => renderSiblings(), {
+	order: () => mode(),
+	collapsed: () => true,
+});
 ```

src/routes/v2/reference/advanced/jsx-component-primitives/map-array.mdx

@@ -35,18 +35,20 @@ import { mapArray } from "solid-js";
 
 ```ts
 function mapArray<Item, MappedItem>(
-  list: Accessor<Maybe<readonly Item[]>>,
-  map: (value: Accessor<Item>, index: Accessor<number>) => MappedItem,
-  options?: { keyed?: boolean | ((item: Item) => any); fallback?: Accessor<any>; name?: string }
+	list: Accessor<Maybe<readonly Item[]>>,
+	map: (value: Accessor<Item>, index: Accessor<number>) => MappedItem,
+	options?: {
+		keyed?: boolean | ((item: Item) => any);
+		fallback?: Accessor<any>;
+		name?: string;
+	}
 ): Accessor<MappedItem[]>;
 ```
 
 ## Examples
 
 ```ts
-const view = mapArray(
-  items,
-  (item, index) => `${index()}: ${item().label}`,
-  { fallback: () => "no items" }
-);
+const view = mapArray(items, (item, index) => `${index()}: ${item().label}`, {
+	fallback: () => "no items",
+});
 ```

src/routes/v2/reference/advanced/jsx-component-primitives/repeat.mdx

@@ -28,18 +28,18 @@ import { repeat } from "solid-js";
 
 ```ts
 function repeat(
-  count: Accessor<number>,
-  map: (index: number) => any,
-  options?: {
-    from?: Accessor<number | undefined>;
-    fallback?: Accessor<any>;
-    name?: string;
-  }
+	count: Accessor<number>,
+	map: (index: number) => any,
+	options?: {
+		from?: Accessor<number | undefined>;
+		fallback?: Accessor<any>;
+		name?: string;
+	}
 ): Accessor<any[]>;
 ```
 
 ## Examples
 
 ```ts
-const view = repeat(count, i => `Item ${i}`, { fallback: () => "empty" });
+const view = repeat(count, (i) => `Item ${i}`, { fallback: () => "empty" });
 ```