solid-js 2.0.0-beta.10 → 2.0.0-beta.12

package/types/client/flow.d.ts

@@ -3,18 +3,26 @@ 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 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 +31,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 +71,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 +85,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 +134,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 +169,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

package/types/client/hydration.d.ts

@@ -1,4 +1,4 @@
-import { createErrorBoundary as coreErrorBoundary, createRenderEffect as coreRenderEffect, createEffect as coreEffect, type Accessor, type ComputeFunction, type MemoOptions, type NoInfer, type ProjectionOptions, type Refreshable, type Signal, type SignalOptions, type Store, type StoreSetter, type Context } from "@solidjs/signals";
+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 type { Element as SolidElement } from "../types.js";
 type HydrationSsrFields = {
     /**
@@ -34,11 +34,12 @@ declare module "@solidjs/signals" {
     }
     interface EffectOptions extends HydrationSsrFields {
     }
+    interface ProjectionOptions extends HydrationSsrFields {
+    }
 }
 /**
  * Options for `createProjection`, `createStore(fn, ...)`, and
- * `createOptimisticStore(fn, ...)` — `ProjectionOptions` plus a
- * hydration-aware `ssrSource` field.
+ * `createOptimisticStore(fn, ...)`.
  *
  * `ssrSource` controls what initial value the client uses and whether
  * the projection's compute re-runs:
@@ -52,9 +53,6 @@ declare module "@solidjs/signals" {
  *
  * See {@link HydrationSsrFields} for the fuller explanation.
  */
-export type HydrationProjectionOptions = ProjectionOptions & {
-    ssrSource?: "server" | "hybrid" | "client";
-};
 type HydrationClientMemoOptions<T> = Omit<MemoOptions<T>, "ssrSource"> & {
     ssrSource: "client";
 };
@@ -157,8 +155,8 @@ export declare function enableHydration(): void;
  * @description https://docs.solidjs.com/reference/basic-reactivity/create-memo
  */
 export declare const createMemo: {
-    <T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, options: HydrationClientMemoOptions<T>): Accessor<T | undefined>;
-    <T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, options?: HydrationMemoOptions<T>): Accessor<T>;
+    <T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, options: HydrationClientMemoOptions<T>): SourceAccessor<T | undefined>;
+    <T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, options?: HydrationMemoOptions<T>): SourceAccessor<T>;
 };
 /**
  * Creates a simple reactive state with a getter and setter.
@@ -302,11 +300,11 @@ export declare const createOptimistic: {
  * );
  * ```
  *
- * **Hydration:** {@link HydrationProjectionOptions} adds `ssrSource`
+ * **Hydration:** `ProjectionOptions` accepts an `ssrSource` field
  * (`"server"` | `"hybrid"` | `"client"`) for the same client-vs-server
  * tradeoffs as the other primitives. See {@link HydrationSsrFields}.
  */
-export declare const createProjection: <T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, initialValue: T, options?: HydrationProjectionOptions) => Refreshable<Store<T>>;
+export declare const createProjection: <T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, initialValue: T, options?: ProjectionOptions) => Refreshable<Store<T>>;
 type NoFn<T> = T extends Function ? never : T;
 /**
  * Creates a deeply-reactive store backed by a Proxy. Reads track each
@@ -362,15 +360,15 @@ type NoFn<T> = T extends Function ? never : T;
  * );
  * ```
  *
- * **Hydration:** the derived form accepts
- * {@link HydrationProjectionOptions}, which adds an `ssrSource` field
+ * **Hydration:** the derived form accepts `ProjectionOptions`, including
+ * an `ssrSource` field
  * (`"server"` | `"hybrid"` | `"client"`). See {@link HydrationSsrFields}.
  *
  * @returns `[store: Store<T>, setStore: StoreSetter<T>]`
  */
 export declare const createStore: {
     <T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>): [get: Store<T>, set: StoreSetter<T>];
-    <T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store: NoFn<T> | Store<NoFn<T>>, options?: HydrationProjectionOptions): [get: Refreshable<Store<T>>, set: StoreSetter<T>];
+    <T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store: NoFn<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Refreshable<Store<T>>, set: StoreSetter<T>];
 };
 /**
  * The store equivalent of `createOptimistic`. Writes inside an
@@ -412,15 +410,15 @@ export declare const createStore: {
  * });
  * ```
  *
- * **Hydration:** the derived form accepts
- * {@link HydrationProjectionOptions}, which adds an `ssrSource` field
+ * **Hydration:** the derived form accepts `ProjectionOptions`, including
+ * an `ssrSource` field
  * (`"server"` | `"hybrid"` | `"client"`). See {@link HydrationSsrFields}.
  *
  * @returns `[store: Store<T>, setStore: StoreSetter<T>]`
  */
 export declare const createOptimisticStore: {
     <T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>): [get: Store<T>, set: StoreSetter<T>];
-    <T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store: NoFn<T> | Store<NoFn<T>>, options?: HydrationProjectionOptions): [get: Refreshable<Store<T>>, set: StoreSetter<T>];
+    <T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store: NoFn<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Refreshable<Store<T>>, set: StoreSetter<T>];
 };
 /**
  * Creates a reactive computation that runs during the render phase as

package/types/index.d.ts

@@ -1,5 +1,5 @@
 export { $PROXY, $REFRESH, $TRACK, action, createOwner, createReaction, createRevealOrder, createRoot, createTrackedEffect, deep, flatten, flush, getNextChildId, getObserver, getOwner, isDisposed, isEqual, isRefreshing, isPending, isWrappable, mapArray, merge, omit, onCleanup, onSettled, latest, reconcile, refresh, repeat, resolve, NotReadyError, runWithOwner, enableExternalSource, enforceLoadingBoundary, snapshot, storePath, untrack } from "@solidjs/signals";
-export type { Accessor, ComputeFunction, EffectFunction, EffectOptions, ExternalSource, ExternalSourceConfig, ExternalSourceFactory, Merge, NoInfer, NotWrappable, Omit, Owner, Refreshable, Signal, SignalOptions, Setter, Store, SolidStore, StoreNode, StoreSetter, StorePathRange, ArrayFilterFn, CustomPartial, Part, PathSetter } from "@solidjs/signals";
+export type { Accessor, ComputeFunction, EffectBundle, EffectFunction, EffectOptions, ExternalSource, ExternalSourceConfig, ExternalSourceFactory, Merge, MemoOptions, NoInfer, NotWrappable, Omit, Owner, ProjectionOptions, Refreshable, Signal, SignalOptions, SourceAccessor, Setter, Store, StoreOptions, SolidStore, StoreNode, StoreSetter, StorePathRange, ArrayFilterFn, CustomPartial, Part, PathSetter } from "@solidjs/signals";
 export { $DEVCOMP, children, createContext, useContext } from "./client/core.js";
 export type { ChildrenReturn, Context, ContextProviderComponent, ResolvedChildren, ResolvedElement } from "./client/core.js";
 export * from "./client/component.js";
@@ -8,8 +8,6 @@ export type { ArrayElement, Element } from "./types.js";
 export { sharedConfig, enableHydration, createErrorBoundary, createLoadingBoundary, createMemo, createSignal, createStore, createProjection, createOptimistic, createOptimisticStore, createRenderEffect, createEffect, NoHydration, Hydration, NoHydrateContext } from "./client/hydration.js";
 /** @internal */
 export declare function ssrHandleError(): void;
-/** @internal */
-export declare function ssrRunInScope(): void;
 import { type Dev } from "@solidjs/signals";
 export declare const DEV: Dev | undefined;
 declare global {

package/types/server/core.d.ts

@@ -40,10 +40,3 @@ export type ChildrenReturn = Accessor<ResolvedChildren> & {
  * @returns a accessor of the same children, but resolved
  */
 export declare function children(fn: Accessor<SolidElement>): ChildrenReturn;
-/**
- * Pass-through for SSR dynamic expressions.
- * On the client, insert() render effects are transparent (0 owner slots),
- * so the server doesn't need to create owners for these either.
- */
-export declare function ssrRunInScope(fn: () => any): () => any;
-export declare function ssrRunInScope(array: (() => any)[]): (() => any)[];

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,14 +77,36 @@ 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

package/types/server/index.d.ts

@@ -1,6 +1,6 @@
 export { $PROXY, $REFRESH, $TRACK, action, createEffect, createMemo, createOptimistic, createOptimisticStore, createErrorBoundary, createOwner, createProjection, createReaction, createRenderEffect, createRevealOrder, createRoot, createSignal, createStore, createTrackedEffect, deep, flatten, flush, getNextChildId, getObserver, getOwner, isDisposed, isEqual, isRefreshing, isPending, isWrappable, mapArray, merge, omit, onCleanup, onSettled, latest, reconcile, refresh, repeat, resolve, NotReadyError, runWithOwner, snapshot, storePath, createDeepProxy, enableExternalSource, enforceLoadingBoundary, untrack } from "./signals.js";
 export type { Accessor, ComputeFunction, EffectFunction, EffectOptions, ExternalSource, ExternalSourceConfig, ExternalSourceFactory, Merge, NoInfer, NotWrappable, Omit, Owner, Refreshable, Signal, SignalOptions, Setter, Store, SolidStore, StoreNode, StoreSetter, StorePathRange, ArrayFilterFn, CustomPartial, Part, PathSetter, PatchOp } from "./signals.js";
-export { $DEVCOMP, children, createContext, useContext, ssrRunInScope } from "./core.js";
+export { $DEVCOMP, children, createContext, useContext } from "./core.js";
 export type { ChildrenReturn, Context, ContextProviderComponent, ResolvedChildren, ResolvedElement } from "./core.js";
 export * from "./component.js";
 export * from "./flow.js";

package/types/server/shared.d.ts

@@ -1,8 +1,12 @@
-import type { Context } from "@solidjs/signals";
+import type { Context } from "./signals.js";
 export type SSRTemplateObject = {
     t: string[];
     h: Function[];
     p: Promise<any>[];
+} | {
+    t: string;
+    h?: undefined;
+    p?: undefined;
 };
 export type HydrationContext = {
     id: string;

package/types/server/signals.d.ts

@@ -1,9 +1,45 @@
-export { createRoot, createOwner, runWithOwner, getOwner, isDisposed, onCleanup, getNextChildId, createContext, setContext, getContext, NotReadyError, NoOwnerError, ContextNotFoundError, isEqual, isWrappable, SUPPORTS_PROXY, enableExternalSource, enforceLoadingBoundary } from "@solidjs/signals";
+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, $REFRESH, $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;
+export declare function createOwner(options?: {
+    id?: string;
+    transparent?: boolean;
+}): Owner;
+export declare function runWithOwner<T>(owner: Owner | null, fn: () => T): T;
+export declare function getOwner(): Owner | null;
+export declare function isDisposed(owner: Owner): boolean;
+export declare function onCleanup(fn: Disposable): Disposable;
+export declare function createContext<T>(defaultValue?: T, description?: string): Context<T>;
+export declare function getContext<T>(context: Context<T>, owner?: Owner | null): T;
+export declare function setContext<T>(context: Context<T>, value?: T, owner?: Owner | null): void;
+/**
+ * Tears down `owner` (optionally) and all of its descendants. Walks the
+ * forward-only `_firstChild` -> `_nextSibling` chain, recursively disposing
+ * each child with `self=true`, then runs the owner's own `_disposal` queue
+ * and resets `_firstChild` / `_childCount`.
+ *
+ * `self=false` keeps `owner` itself alive (its `_disposed` flag stays clear,
+ * future `runWithOwner(owner, ...)` keeps working) but tears down its
+ * subtree. This is what `createErrorBoundary` and `createLoadingBoundary`
+ * use on retry — wipe the children, keep the boundary owner around for the
+ * re-run.
+ *
+ * @internal
+ */
+export declare function disposeOwner(owner: Owner, self?: boolean): void;
+export declare function createRoot<T>(init: ((dispose: () => void) => T) | (() => T), options?: {
+    id?: string;
+    transparent?: boolean;
+}): T;
 interface ServerComputation<T = any> {
     owner: Owner;
     value: T;
@@ -34,8 +70,8 @@ export declare function createSignal<T>(): Signal<T | undefined>;
 export declare function createSignal<T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
 export declare function createSignal<T>(fn: ComputeFunction<undefined | NoInfer<T>, T>, options: ServerClientSignalOptions<T>): Signal<T | undefined>;
 export declare function createSignal<T>(fn: ComputeFunction<undefined | NoInfer<T>, T>, options?: ServerSignalOptions<T>): Signal<T>;
-export declare function createMemo<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, options: ServerClientMemoOptions<T>): Accessor<T | undefined>;
-export declare function createMemo<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, options?: ServerMemoOptions<T>): Accessor<T>;
+export declare function createMemo<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, options: ServerClientMemoOptions<T>): SourceAccessor<T | undefined>;
+export declare function createMemo<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, options?: ServerMemoOptions<T>): SourceAccessor<T>;
 export type PatchOp = [path: PropertyKey[]] | [path: PropertyKey[], value: any] | [path: PropertyKey[], value: any, insert: 1];
 export declare function createDeepProxy<T extends object>(target: T, patches: PatchOp[], basePath?: PropertyKey[]): T;
 export declare function createEffect<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, effect: EffectFunction<NoInfer<T>, T> | EffectBundle<NoInfer<T>, T>, options?: EffectOptions): void;
@@ -54,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?: {
@@ -81,7 +126,7 @@ export declare function resolve<T>(fn: () => T): Promise<T>;
 export declare function isPending(fn: () => any, fallback?: boolean): boolean;
 export declare function latest<T>(fn: () => T): T;
 export declare function isRefreshing(): boolean;
-export declare function refresh<T>(fn: () => T): T;
+export declare function refresh<T>(_target: Refreshable<T>): void;
 export declare function action<T extends (...args: any[]) => any>(fn: T): T;
 export declare function onSettled(callback: () => void | (() => void)): void;
 type NoInfer<T extends any> = [T][T extends any ? 0 : never];

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

@@ -3,18 +3,26 @@ 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 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 +31,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 +71,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 +85,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 +134,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 +169,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