solid-js 2.0.0-beta.11 → 2.0.0-beta.13

package/types/client/flow.d.ts

@@ -2,19 +2,28 @@ import type { Accessor, RevealOrder } from "@solidjs/signals";
 export type { RevealOrder };
 import type { Element as SolidElement } from "../types.js";
 type NonZeroParams<T extends (...args: any[]) => any> = Parameters<T>["length"] extends 0 ? never : T;
+type ErrorAccessor = Accessor<unknown>;
 type ConditionalRenderCallback<T> = (item: Accessor<NonNullable<T>>) => SolidElement;
+type KeyedConditionalRenderCallback<T> = (item: NonNullable<T>) => SolidElement;
 type ConditionalRenderChildren<T, F extends ConditionalRenderCallback<T> = ConditionalRenderCallback<T>> = SolidElement | NonZeroParams<F>;
+type KeyedConditionalRenderChildren<T, F extends KeyedConditionalRenderCallback<T> = KeyedConditionalRenderCallback<T>> = SolidElement | NonZeroParams<F>;
 /**
  * Creates a list of elements from a list.
  *
- * Receives a map function as its child that takes list element and index
- * accessors and returns a JSX element; if the list is empty, an optional
- * `fallback` is rendered instead.
+ * Receives a map function as its child and returns a JSX element for each
+ * list item; if the list is empty, an optional `fallback` is rendered instead.
+ *
+ * The child callback shape follows the keying mode:
+ * - default / `keyed={true}` receives `(item, index)` where `item` is the raw
+ *   row value and `index` is an accessor.
+ * - `keyed={false}` receives `(item, index)` where `item` is an accessor and
+ *   `index` is a stable number.
+ * - `keyed={(item) => key}` receives accessors for both arguments.
  *
  * @example
  * ```tsx
  * <For each={items} fallback={<div>No items</div>}>
- *   {(item, index) => <div data-index={index()}>{item()}</div>}
+ *   {(item, index) => <div data-index={index()}>{item.label}</div>}
  * </For>
  * ```
  *
@@ -23,7 +32,19 @@ type ConditionalRenderChildren<T, F extends ConditionalRenderCallback<T> = Condi
 export declare function For<T extends readonly any[], U extends SolidElement>(props: {
     each: T | undefined | null | false;
     fallback?: SolidElement;
-    keyed?: boolean | ((item: T[number]) => any);
+    keyed?: true;
+    children: (item: T[number], index: Accessor<number>) => U;
+}): SolidElement;
+export declare function For<T extends readonly any[], U extends SolidElement>(props: {
+    each: T | undefined | null | false;
+    fallback?: SolidElement;
+    keyed: false;
+    children: (item: Accessor<T[number]>, index: number) => U;
+}): SolidElement;
+export declare function For<T extends readonly any[], U extends SolidElement>(props: {
+    each: T | undefined | null | false;
+    fallback?: SolidElement;
+    keyed: (item: T[number]) => any;
     children: (item: Accessor<T[number]>, index: Accessor<number>) => U;
 }): SolidElement;
 /**
@@ -51,10 +72,10 @@ export declare function Repeat<T extends SolidElement>(props: {
  * Conditionally renders its children when `when` is truthy, otherwise renders
  * the optional `fallback`.
  *
- * The function-child form receives an accessor for the narrowed value — call
- * it to read. Without `keyed` (default), the child is preserved across
- * truthy values; with `keyed`, the child remounts whenever the value's
- * identity changes.
+ * The function-child form receives a narrowed value. Without `keyed`
+ * (default), it receives an accessor and the child is preserved across truthy
+ * values; with `keyed`, it receives the raw value and remounts whenever the
+ * value's identity changes.
  *
  * @example
  * ```tsx
@@ -65,11 +86,29 @@ export declare function Repeat<T extends SolidElement>(props: {
  *
  * @description https://docs.solidjs.com/reference/components/show
  */
+export declare function Show<T>(props: {
+    when: T | undefined | null | false;
+    keyed: true;
+    fallback?: SolidElement;
+    children: SolidElement;
+}): SolidElement;
+export declare function Show<T, F extends KeyedConditionalRenderCallback<T>>(props: {
+    when: T | undefined | null | false;
+    keyed: true;
+    fallback?: SolidElement;
+    children: NonZeroParams<F>;
+}): SolidElement;
+export declare function Show<T>(props: {
+    when: T | undefined | null | false;
+    keyed?: false;
+    fallback?: SolidElement;
+    children: SolidElement;
+}): SolidElement;
 export declare function Show<T, F extends ConditionalRenderCallback<T>>(props: {
     when: T | undefined | null | false;
-    keyed?: boolean;
+    keyed?: false;
     fallback?: SolidElement;
-    children: ConditionalRenderChildren<T, F>;
+    children: NonZeroParams<F>;
 }): SolidElement;
 /**
  * Switches between content based on mutually exclusive conditions. Renders
@@ -96,15 +135,26 @@ export declare function Switch(props: {
 }): SolidElement;
 export type MatchProps<T, F extends ConditionalRenderCallback<T> = ConditionalRenderCallback<T>> = {
     when: T | undefined | null | false;
-    keyed?: boolean;
+    keyed?: false;
     children: ConditionalRenderChildren<T, F>;
 };
+export type KeyedMatchProps<T, F extends KeyedConditionalRenderCallback<T> = KeyedConditionalRenderCallback<T>> = {
+    when: T | undefined | null | false;
+    keyed: true;
+    children: KeyedConditionalRenderChildren<T, F>;
+};
+export type AnyMatchProps<T> = MatchProps<T> | KeyedMatchProps<T> | {
+    when: T | undefined | null | false;
+    keyed?: boolean;
+    children: SolidElement;
+};
 /**
  * A branch inside a `<Switch>`. The first `<Match>` whose `when` is truthy
  * wins; remaining matches are skipped.
  *
- * Like `<Show>`, `<Match>` supports a function child that receives an
- * accessor for the narrowed value.
+ * Like `<Show>`, `<Match>` supports a function child. Non-keyed children
+ * receive an accessor for the narrowed value; keyed children receive the raw
+ * narrowed value.
  *
  * @example
  * ```tsx
@@ -120,7 +170,19 @@ export type MatchProps<T, F extends ConditionalRenderCallback<T> = ConditionalRe
  *
  * @description https://docs.solidjs.com/reference/components/switch-and-match
  */
+export declare function Match<T>(props: {
+    when: T | undefined | null | false;
+    keyed: true;
+    children: SolidElement;
+}): SolidElement;
+export declare function Match<T, F extends KeyedConditionalRenderCallback<T>>(props: KeyedMatchProps<T, F>): SolidElement;
+export declare function Match<T>(props: {
+    when: T | undefined | null | false;
+    keyed?: false;
+    children: SolidElement;
+}): SolidElement;
 export declare function Match<T, F extends ConditionalRenderCallback<T>>(props: MatchProps<T, F>): SolidElement;
+export declare function Match<T>(props: AnyMatchProps<T>): SolidElement;
 /**
  * Catches uncaught errors inside its subtree and renders fallback content
  * instead. The `fallback` prop can be a JSX element, or a callback that
@@ -132,7 +194,7 @@ export declare function Match<T, F extends ConditionalRenderCallback<T>>(props:
  * @example
  * ```tsx
  * <Errored fallback={(err, reset) => (
- *   <div onClick={reset}>Error: {err.toString()}</div>
+ *   <div onClick={reset}>Error: {err().toString()}</div>
  * )}>
  *   <MyComp />
  * </Errored>
@@ -141,7 +203,7 @@ export declare function Match<T, F extends ConditionalRenderCallback<T>>(props:
  * @description https://docs.solidjs.com/reference/components/error-boundary
  */
 export declare function Errored(props: {
-    fallback: SolidElement | ((err: any, reset: () => void) => SolidElement);
+    fallback: SolidElement | ((err: ErrorAccessor, reset: () => void) => SolidElement);
     children: SolidElement;
 }): SolidElement;
 /**

package/types/client/hydration.d.ts

@@ -1,4 +1,4 @@
-import { createErrorBoundary as coreErrorBoundary, createRenderEffect as coreRenderEffect, createEffect as coreEffect, type ComputeFunction, type MemoOptions, type NoInfer, type ProjectionOptions, type Refreshable, type Signal, type SignalOptions, type SourceAccessor, type Store, type StoreSetter, type Context } from "@solidjs/signals";
+import { createRenderEffect as coreRenderEffect, createEffect as coreEffect, type Accessor, type ComputeFunction, type MemoOptions, type NoInfer, type ProjectionOptions, type Refreshable, type Signal, type SignalOptions, type SourceAccessor, type Store, type StoreSetter, type Context } from "@solidjs/signals";
 import type { Element as SolidElement } from "../types.js";
 type HydrationSsrFields = {
     /**
@@ -201,8 +201,8 @@ export declare const createSignal: {
 /**
  * Lower-level primitive that backs the `<Errored>` flow control.
  * Catches errors thrown inside `fn` and renders `fallback(error,
- * reset)` instead. `reset()` recomputes the failing sources so the
- * boundary can attempt to recover.
+ * reset)` instead. `error` is an accessor for the latest captured error;
+ * `reset()` recomputes the failing sources so the boundary can attempt to recover.
  *
  * App code should use `<Errored fallback={...}>` directly — reach for
  * this only when authoring a custom boundary component.
@@ -216,20 +216,20 @@ export declare const createSignal: {
  * // Custom boundary built on the primitive — adds telemetry around the
  * // canonical `<Errored>` shape.
  * function TracedErrored(props: {
- *   fallback: (e: unknown) => JSX.Element;
+ *   fallback: (e: () => unknown) => JSX.Element;
  *   children: JSX.Element;
  * }): JSX.Element {
  *   return createErrorBoundary(
  *     () => props.children,
  *     (err, reset) => {
- *       reportError(err);
+ *       reportError(err());
  *       return props.fallback(err);
  *     }
  *   ) as unknown as JSX.Element;
  * }
  * ```
  */
-export declare const createErrorBoundary: typeof coreErrorBoundary;
+export declare const createErrorBoundary: <U>(fn: () => any, fallback: (error: Accessor<unknown>, reset: () => void) => U) => () => unknown;
 /**
  * Creates an optimistic signal — a `Signal<T>` whose writes are
  * tentative inside an `action` transition: they show up immediately,

package/types/server/flow.d.ts

@@ -3,16 +3,29 @@ import type { Element as SolidElement } from "../types.js";
 export type { RevealOrder };
 type NonZeroParams<T extends (...args: any[]) => any> = Parameters<T>["length"] extends 0 ? never : T;
 type ConditionalRenderCallback<T> = (item: Accessor<NonNullable<T>>) => SolidElement;
+type KeyedConditionalRenderCallback<T> = (item: NonNullable<T>) => SolidElement;
 type ConditionalRenderChildren<T, F extends ConditionalRenderCallback<T> = ConditionalRenderCallback<T>> = SolidElement | NonZeroParams<F>;
+type KeyedConditionalRenderChildren<T, F extends KeyedConditionalRenderCallback<T> = KeyedConditionalRenderCallback<T>> = SolidElement | NonZeroParams<F>;
 /**
  * Creates a list of elements from a list
- *
  * @description https://docs.solidjs.com/reference/components/for
  */
 export declare function For<T extends readonly any[], U extends SolidElement>(props: {
     each: T | undefined | null | false;
     fallback?: SolidElement;
-    keyed?: boolean | ((item: T[number]) => any);
+    keyed?: true;
+    children: (item: T[number], index: Accessor<number>) => U;
+}): SolidElement;
+export declare function For<T extends readonly any[], U extends SolidElement>(props: {
+    each: T | undefined | null | false;
+    fallback?: SolidElement;
+    keyed: false;
+    children: (item: Accessor<T[number]>, index: number) => U;
+}): SolidElement;
+export declare function For<T extends readonly any[], U extends SolidElement>(props: {
+    each: T | undefined | null | false;
+    fallback?: SolidElement;
+    keyed: (item: T[number]) => any;
     children: (item: Accessor<T[number]>, index: Accessor<number>) => U;
 }): SolidElement;
 /**
@@ -30,11 +43,29 @@ export declare function Repeat<T extends SolidElement>(props: {
  * Conditionally render its children or an optional fallback component
  * @description https://docs.solidjs.com/reference/components/show
  */
+export declare function Show<T>(props: {
+    when: T | undefined | null | false;
+    keyed: true;
+    fallback?: SolidElement;
+    children: SolidElement;
+}): SolidElement;
+export declare function Show<T, F extends KeyedConditionalRenderCallback<T>>(props: {
+    when: T | undefined | null | false;
+    keyed: true;
+    fallback?: SolidElement;
+    children: NonZeroParams<F>;
+}): SolidElement;
+export declare function Show<T>(props: {
+    when: T | undefined | null | false;
+    keyed?: false;
+    fallback?: SolidElement;
+    children: SolidElement;
+}): SolidElement;
 export declare function Show<T, F extends ConditionalRenderCallback<T>>(props: {
     when: T | undefined | null | false;
-    keyed?: boolean;
+    keyed?: false;
     fallback?: SolidElement;
-    children: ConditionalRenderChildren<T, F>;
+    children: NonZeroParams<F>;
 }): SolidElement;
 /**
  * Switches between content based on mutually exclusive conditions
@@ -46,20 +77,42 @@ export declare function Switch(props: {
 }): SolidElement;
 export type MatchProps<T, F extends ConditionalRenderCallback<T> = ConditionalRenderCallback<T>> = {
     when: T | undefined | null | false;
-    keyed?: boolean;
+    keyed?: false;
     children: ConditionalRenderChildren<T, F>;
 };
+export type KeyedMatchProps<T, F extends KeyedConditionalRenderCallback<T> = KeyedConditionalRenderCallback<T>> = {
+    when: T | undefined | null | false;
+    keyed: true;
+    children: KeyedConditionalRenderChildren<T, F>;
+};
+export type AnyMatchProps<T> = MatchProps<T> | KeyedMatchProps<T> | {
+    when: T | undefined | null | false;
+    keyed?: boolean;
+    children: SolidElement;
+};
 /**
  * Selects a content based on condition when inside a `<Switch>` control flow
  * @description https://docs.solidjs.com/reference/components/switch-and-match
  */
+export declare function Match<T>(props: {
+    when: T | undefined | null | false;
+    keyed: true;
+    children: SolidElement;
+}): SolidElement;
+export declare function Match<T, F extends KeyedConditionalRenderCallback<T>>(props: KeyedMatchProps<T, F>): SolidElement;
+export declare function Match<T>(props: {
+    when: T | undefined | null | false;
+    keyed?: false;
+    children: SolidElement;
+}): SolidElement;
 export declare function Match<T, F extends ConditionalRenderCallback<T>>(props: MatchProps<T, F>): SolidElement;
+export declare function Match<T>(props: AnyMatchProps<T>): SolidElement;
 /**
  * Catches uncaught errors inside components and renders a fallback content
  * @description https://docs.solidjs.com/reference/components/error-boundary
  */
 export declare function Errored(props: {
-    fallback: SolidElement | ((err: any, reset: () => void) => SolidElement);
+    fallback: SolidElement | ((err: () => any, reset: () => void) => SolidElement);
     children: SolidElement;
 }): SolidElement;
 /**

package/types/server/signals.d.ts

@@ -2,11 +2,11 @@ import { $REFRESH } from "@solidjs/signals";
 export { $REFRESH };
 export { NotReadyError, NoOwnerError, ContextNotFoundError, isEqual, isWrappable, SUPPORTS_PROXY, enableExternalSource, enforceLoadingBoundary } from "@solidjs/signals";
 export { flatten } from "@solidjs/signals";
-export { snapshot, merge, omit, storePath, $PROXY, $TRACK } from "@solidjs/signals";
+export { snapshot, omit, storePath, $PROXY, $TRACK } from "@solidjs/signals";
 import type { Accessor as SignalAccessor, Refreshable } from "@solidjs/signals";
 export type SourceAccessor<T> = Refreshable<SignalAccessor<T>>;
 export type { Accessor, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, ExternalSource, ExternalSourceConfig, ExternalSourceFactory, MemoOptions, NoInfer, SignalOptions, Setter, Signal, Owner, Refreshable, Maybe, Store, StoreSetter, StoreNode, NotWrappable, SolidStore, Merge, Omit, Context, ContextRecord, IQueue, StorePathRange, ArrayFilterFn, CustomPartial, Part, PathSetter } from "@solidjs/signals";
-import type { Accessor, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, MemoOptions, SignalOptions, Signal, Owner, Store, StoreSetter, Context } from "@solidjs/signals";
+import type { Accessor, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, MemoOptions, SignalOptions, Signal, Merge, Owner, Store, StoreSetter, Context } from "@solidjs/signals";
 import { sharedConfig, NoHydrateContext } from "./shared.js";
 type Disposable = () => void;
 export declare function getNextChildId(owner: Owner): string;
@@ -90,8 +90,17 @@ export declare const createOptimisticStore: typeof createStore;
 export declare function createProjection<T extends object>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, initialValue: Partial<T>, options?: ServerSsrOptions): Store<T>;
 export declare function reconcile<T extends U, U extends object>(value: T): (state: U) => T;
 export declare function deep<T extends object>(store: Store<T>): Store<T>;
-export declare function mapArray<T, U>(list: Accessor<readonly T[] | undefined | null | false>, mapFn: (v: Accessor<T>, i: Accessor<number>) => U, options?: {
-    keyed?: boolean | ((item: T) => any);
+export declare function merge<T extends unknown[]>(...sources: T): Merge<T>;
+export declare function mapArray<T, U>(list: Accessor<readonly T[] | undefined | null | false>, mapFn: (v: T, i: Accessor<number>) => U, options?: {
+    keyed?: true;
+    fallback?: Accessor<any>;
+}): () => U[];
+export declare function mapArray<T, U>(list: Accessor<readonly T[] | undefined | null | false>, mapFn: (v: Accessor<T>, i: number) => U, options: {
+    keyed: false;
+    fallback?: Accessor<any>;
+}): () => U[];
+export declare function mapArray<T, U>(list: Accessor<readonly T[] | undefined | null | false>, mapFn: (v: Accessor<T>, i: Accessor<number>) => U, options: {
+    keyed: (item: T) => any;
     fallback?: Accessor<any>;
 }): () => U[];
 export declare function repeat<T>(count: Accessor<number>, mapFn: (i: number) => T, options?: {
@@ -102,7 +111,7 @@ declare const ErrorContext: Context<((err: any) => void) | null>;
 export { ErrorContext };
 export declare function runWithBoundaryErrorContext<T>(owner: Owner, render: () => T, onError: (err: any, parentHandler: ((err: any) => void) | null) => void, context?: NonNullable<typeof sharedConfig.context>, boundaryId?: string): T;
 export { NoHydrateContext };
-export declare function createErrorBoundary<U>(fn: () => any, fallback: (error: unknown, reset: () => void) => U): () => unknown;
+export declare function createErrorBoundary<U>(fn: () => any, fallback: (error: Accessor<unknown>, reset: () => void) => U): () => unknown;
 export declare function createLoadingBoundary(fn: () => any, fallback: () => any, options?: {
     on?: () => any;
 }): () => unknown;
@@ -114,7 +123,7 @@ export declare function createRevealOrder<T>(fn: () => T, _options?: {
 export declare function untrack<T>(fn: () => T): T;
 export declare function flush(): void;
 export declare function resolve<T>(fn: () => T): Promise<T>;
-export declare function isPending(fn: () => any, fallback?: boolean): boolean;
+export declare function isPending(fn: () => any, loading?: boolean): boolean;
 export declare function latest<T>(fn: () => T): T;
 export declare function isRefreshing(): boolean;
 export declare function refresh<T>(_target: Refreshable<T>): void;

package/types-cjs/client/flow.d.cts

@@ -2,19 +2,28 @@ import type { Accessor, RevealOrder } from "@solidjs/signals";
 export type { RevealOrder };
 import type { Element as SolidElement } from "../types.cjs";
 type NonZeroParams<T extends (...args: any[]) => any> = Parameters<T>["length"] extends 0 ? never : T;
+type ErrorAccessor = Accessor<unknown>;
 type ConditionalRenderCallback<T> = (item: Accessor<NonNullable<T>>) => SolidElement;
+type KeyedConditionalRenderCallback<T> = (item: NonNullable<T>) => SolidElement;
 type ConditionalRenderChildren<T, F extends ConditionalRenderCallback<T> = ConditionalRenderCallback<T>> = SolidElement | NonZeroParams<F>;
+type KeyedConditionalRenderChildren<T, F extends KeyedConditionalRenderCallback<T> = KeyedConditionalRenderCallback<T>> = SolidElement | NonZeroParams<F>;
 /**
  * Creates a list of elements from a list.
  *
- * Receives a map function as its child that takes list element and index
- * accessors and returns a JSX element; if the list is empty, an optional
- * `fallback` is rendered instead.
+ * Receives a map function as its child and returns a JSX element for each
+ * list item; if the list is empty, an optional `fallback` is rendered instead.
+ *
+ * The child callback shape follows the keying mode:
+ * - default / `keyed={true}` receives `(item, index)` where `item` is the raw
+ *   row value and `index` is an accessor.
+ * - `keyed={false}` receives `(item, index)` where `item` is an accessor and
+ *   `index` is a stable number.
+ * - `keyed={(item) => key}` receives accessors for both arguments.
  *
  * @example
  * ```tsx
  * <For each={items} fallback={<div>No items</div>}>
- *   {(item, index) => <div data-index={index()}>{item()}</div>}
+ *   {(item, index) => <div data-index={index()}>{item.label}</div>}
  * </For>
  * ```
  *
@@ -23,7 +32,19 @@ type ConditionalRenderChildren<T, F extends ConditionalRenderCallback<T> = Condi
 export declare function For<T extends readonly any[], U extends SolidElement>(props: {
     each: T | undefined | null | false;
     fallback?: SolidElement;
-    keyed?: boolean | ((item: T[number]) => any);
+    keyed?: true;
+    children: (item: T[number], index: Accessor<number>) => U;
+}): SolidElement;
+export declare function For<T extends readonly any[], U extends SolidElement>(props: {
+    each: T | undefined | null | false;
+    fallback?: SolidElement;
+    keyed: false;
+    children: (item: Accessor<T[number]>, index: number) => U;
+}): SolidElement;
+export declare function For<T extends readonly any[], U extends SolidElement>(props: {
+    each: T | undefined | null | false;
+    fallback?: SolidElement;
+    keyed: (item: T[number]) => any;
     children: (item: Accessor<T[number]>, index: Accessor<number>) => U;
 }): SolidElement;
 /**
@@ -51,10 +72,10 @@ export declare function Repeat<T extends SolidElement>(props: {
  * Conditionally renders its children when `when` is truthy, otherwise renders
  * the optional `fallback`.
  *
- * The function-child form receives an accessor for the narrowed value — call
- * it to read. Without `keyed` (default), the child is preserved across
- * truthy values; with `keyed`, the child remounts whenever the value's
- * identity changes.
+ * The function-child form receives a narrowed value. Without `keyed`
+ * (default), it receives an accessor and the child is preserved across truthy
+ * values; with `keyed`, it receives the raw value and remounts whenever the
+ * value's identity changes.
  *
  * @example
  * ```tsx
@@ -65,11 +86,29 @@ export declare function Repeat<T extends SolidElement>(props: {
  *
  * @description https://docs.solidjs.com/reference/components/show
  */
+export declare function Show<T>(props: {
+    when: T | undefined | null | false;
+    keyed: true;
+    fallback?: SolidElement;
+    children: SolidElement;
+}): SolidElement;
+export declare function Show<T, F extends KeyedConditionalRenderCallback<T>>(props: {
+    when: T | undefined | null | false;
+    keyed: true;
+    fallback?: SolidElement;
+    children: NonZeroParams<F>;
+}): SolidElement;
+export declare function Show<T>(props: {
+    when: T | undefined | null | false;
+    keyed?: false;
+    fallback?: SolidElement;
+    children: SolidElement;
+}): SolidElement;
 export declare function Show<T, F extends ConditionalRenderCallback<T>>(props: {
     when: T | undefined | null | false;
-    keyed?: boolean;
+    keyed?: false;
     fallback?: SolidElement;
-    children: ConditionalRenderChildren<T, F>;
+    children: NonZeroParams<F>;
 }): SolidElement;
 /**
  * Switches between content based on mutually exclusive conditions. Renders
@@ -96,15 +135,26 @@ export declare function Switch(props: {
 }): SolidElement;
 export type MatchProps<T, F extends ConditionalRenderCallback<T> = ConditionalRenderCallback<T>> = {
     when: T | undefined | null | false;
-    keyed?: boolean;
+    keyed?: false;
     children: ConditionalRenderChildren<T, F>;
 };
+export type KeyedMatchProps<T, F extends KeyedConditionalRenderCallback<T> = KeyedConditionalRenderCallback<T>> = {
+    when: T | undefined | null | false;
+    keyed: true;
+    children: KeyedConditionalRenderChildren<T, F>;
+};
+export type AnyMatchProps<T> = MatchProps<T> | KeyedMatchProps<T> | {
+    when: T | undefined | null | false;
+    keyed?: boolean;
+    children: SolidElement;
+};
 /**
  * A branch inside a `<Switch>`. The first `<Match>` whose `when` is truthy
  * wins; remaining matches are skipped.
  *
- * Like `<Show>`, `<Match>` supports a function child that receives an
- * accessor for the narrowed value.
+ * Like `<Show>`, `<Match>` supports a function child. Non-keyed children
+ * receive an accessor for the narrowed value; keyed children receive the raw
+ * narrowed value.
  *
  * @example
  * ```tsx
@@ -120,7 +170,19 @@ export type MatchProps<T, F extends ConditionalRenderCallback<T> = ConditionalRe
  *
  * @description https://docs.solidjs.com/reference/components/switch-and-match
  */
+export declare function Match<T>(props: {
+    when: T | undefined | null | false;
+    keyed: true;
+    children: SolidElement;
+}): SolidElement;
+export declare function Match<T, F extends KeyedConditionalRenderCallback<T>>(props: KeyedMatchProps<T, F>): SolidElement;
+export declare function Match<T>(props: {
+    when: T | undefined | null | false;
+    keyed?: false;
+    children: SolidElement;
+}): SolidElement;
 export declare function Match<T, F extends ConditionalRenderCallback<T>>(props: MatchProps<T, F>): SolidElement;
+export declare function Match<T>(props: AnyMatchProps<T>): SolidElement;
 /**
  * Catches uncaught errors inside its subtree and renders fallback content
  * instead. The `fallback` prop can be a JSX element, or a callback that
@@ -132,7 +194,7 @@ export declare function Match<T, F extends ConditionalRenderCallback<T>>(props:
  * @example
  * ```tsx
  * <Errored fallback={(err, reset) => (
- *   <div onClick={reset}>Error: {err.toString()}</div>
+ *   <div onClick={reset}>Error: {err().toString()}</div>
  * )}>
  *   <MyComp />
  * </Errored>
@@ -141,7 +203,7 @@ export declare function Match<T, F extends ConditionalRenderCallback<T>>(props:
  * @description https://docs.solidjs.com/reference/components/error-boundary
  */
 export declare function Errored(props: {
-    fallback: SolidElement | ((err: any, reset: () => void) => SolidElement);
+    fallback: SolidElement | ((err: ErrorAccessor, reset: () => void) => SolidElement);
     children: SolidElement;
 }): SolidElement;
 /**

package/types-cjs/client/hydration.d.cts

@@ -1,4 +1,4 @@
-import { createErrorBoundary as coreErrorBoundary, createRenderEffect as coreRenderEffect, createEffect as coreEffect, type ComputeFunction, type MemoOptions, type NoInfer, type ProjectionOptions, type Refreshable, type Signal, type SignalOptions, type SourceAccessor, type Store, type StoreSetter, type Context } from "@solidjs/signals";
+import { createRenderEffect as coreRenderEffect, createEffect as coreEffect, type Accessor, type ComputeFunction, type MemoOptions, type NoInfer, type ProjectionOptions, type Refreshable, type Signal, type SignalOptions, type SourceAccessor, type Store, type StoreSetter, type Context } from "@solidjs/signals";
 import type { Element as SolidElement } from "../types.cjs";
 type HydrationSsrFields = {
     /**
@@ -201,8 +201,8 @@ export declare const createSignal: {
 /**
  * Lower-level primitive that backs the `<Errored>` flow control.
  * Catches errors thrown inside `fn` and renders `fallback(error,
- * reset)` instead. `reset()` recomputes the failing sources so the
- * boundary can attempt to recover.
+ * reset)` instead. `error` is an accessor for the latest captured error;
+ * `reset()` recomputes the failing sources so the boundary can attempt to recover.
  *
  * App code should use `<Errored fallback={...}>` directly — reach for
  * this only when authoring a custom boundary component.
@@ -216,20 +216,20 @@ export declare const createSignal: {
  * // Custom boundary built on the primitive — adds telemetry around the
  * // canonical `<Errored>` shape.
  * function TracedErrored(props: {
- *   fallback: (e: unknown) => JSX.Element;
+ *   fallback: (e: () => unknown) => JSX.Element;
  *   children: JSX.Element;
  * }): JSX.Element {
  *   return createErrorBoundary(
  *     () => props.children,
  *     (err, reset) => {
- *       reportError(err);
+ *       reportError(err());
  *       return props.fallback(err);
  *     }
  *   ) as unknown as JSX.Element;
  * }
  * ```
  */
-export declare const createErrorBoundary: typeof coreErrorBoundary;
+export declare const createErrorBoundary: <U>(fn: () => any, fallback: (error: Accessor<unknown>, reset: () => void) => U) => () => unknown;
 /**
  * Creates an optimistic signal — a `Signal<T>` whose writes are
  * tentative inside an `action` transition: they show up immediately,