@solidjs/signals 2.0.0-rc.14 → 2.0.0-rc.16

package/dist/types/core/types.d.ts

@@ -20,6 +20,13 @@ export interface Link {
 export interface NodeOptions<T> {
     id?: string;
     name?: string;
+    /**
+     * Source location (`file:line:col`, root-relative) written by the
+     * compiler's `sourceNames` `locations` kind; dev and observe builds keep it
+     * for console reports and diagnostic events, production ignores it. Not
+     * meant to be written by hand.
+     */
+    loc?: string;
     transparent?: boolean;
     equals?: ((prev: T, next: T) => boolean) | false;
     ownedWrite?: boolean;
@@ -86,12 +93,6 @@ export interface NodeExtension {
     /** L2 — the transaction holding this node while CONFIG_HELD is set
      * (`holdNode`); resolved through merges by `txOf`. */
     _transaction: Transaction | null;
-    /** L2 — the transaction a first pass that went pending was born into (it
-     * read a held node, or a verdict lane's mount read a staging of the
-     * flush — the born-held arm's conditions): its first answer lands into it
-     * while it is live; the hold never waits for the node's first load (the
-     * direction rule, #3800). Consumed at the landing. */
-    _bornIn: Transaction | null;
     /** The node's current flight re-asks the same question (a `refresh()`,
      * A19 exc. 2 / A24): verdict-quiet — `isPending` reads false for it —
      * through its landing until the commit. */
@@ -114,6 +115,11 @@ export interface NodeExtension {
      * changes — `isPending` reads true for it and its derivations while any
      * is live. A count, never a hold. */
     _marks: number;
+    /** D-41: the error a node showed when a re-ask made it pending — still
+     * the display (D-39) until a new answer commits: an untracked read throws
+     * it, `isPending` reads a staged answer as a change over it, and a
+     * recovery equal to the last good value is still a new answer. */
+    _shownError: unknown;
 }
 export interface RawSignal<T> {
     _subs: Link | null;
@@ -147,6 +153,8 @@ export type Signal<T> = RawSignal<T>;
 export interface Owner {
     id?: string;
     _config: number;
+    /** Lifecycle flags (REACTIVE_*); roots carry only REACTIVE_DISPOSED. */
+    _flags: number;
     _snapshotScope?: boolean;
     /** Effect-returned cleanup; managed across reruns, invoked at true disposal */
     _cleanup?: () => void;
@@ -165,6 +173,13 @@ export interface Owner {
      * (`<App>`). A slot in the observe/dev literals; absent from prod.
      */
     _name?: string;
+    /**
+     * Observe-tier source location (`file:line:col`): the `loc` option, or
+     * the JSX site the rendering layer writes on a component root. A slot
+     * beside `_name`; absent from prod. Reserved from property mangling, like
+     * `_name`, because solid-js writes it and the core's diagnostics read it.
+     */
+    _loc?: string;
 }
 export interface Computed<T> extends RawSignal<T>, Owner {
     _deps: Link | null;

package/dist/types/core/verdict.d.ts

@@ -2,4 +2,36 @@
  * restores the dispatch it found — none inside a memo's pass a window
  * pulled (`verdictValue`). */
 export declare function latest<T>(fn: () => T): T;
+/**
+ * Reports whether what `fn` reads is still waiting on an update. Read the
+ * values in question inside `fn`: the probe answers `true` while any of
+ * them depends on a change that is in flight — a write or an async source
+ * that has started producing a new value whose result has not landed yet —
+ * and `false` once the latest value is the one on screen. The answer is
+ * tracked like any read, so a memo or effect that calls `isPending` re-runs
+ * when it flips.
+ *
+ * A read that has no value yet is loading, not pending: inside `fn` it
+ * follows the surrounding `Loading` path like any other read, and the probe
+ * reports only updates to a value that already exists. A bare `refresh()`
+ * does not flip `isPending`; pair it with `affects()` to make the re-ask
+ * visible.
+ *
+ * @param fn expression to probe; read the values in question inside it
+ *
+ * @returns `true` while a read inside `fn` depends on a change that has not committed yet
+ *
+ * @example
+ * ```ts
+ * const [query, setQuery] = createSignal("");
+ * const results = createMemo(() => searchProducts(query()));
+ * const stale = createMemo(() => isPending(results));
+ *
+ * setQuery("shoes");
+ * // stale() is true until the new results land, while results() keeps
+ * // serving the previous list — dim it instead of showing a spinner.
+ * ```
+ *
+ * @description https://v2.solidjs.com/reference/solid-js/reactivity/is-pending
+ */
 export declare function isPending(fn: () => any): boolean;

package/dist/types/deferred.d.ts

@@ -0,0 +1,28 @@
+import { type MemoOptions, type SourceAccessor } from "./signals.js";
+/**
+ * Creates an async memo that may lag, but never leads. Before its first
+ * answer it is an ordinary async memo: readers suspend to the nearest
+ * `<Loading>`. After it, a refetch holds nothing: readers keep the last
+ * committed value until the new one lands, and the rest of the screen moves
+ * on without it. `isPending` reports the refetch, on the node and on what
+ * derives from it. Use it for independent widgets (dashboards, feeds,
+ * search results) where the previous answer with a "refreshing" indicator is
+ * better than waiting with everything else.
+ *
+ * - It never shows a value ahead of a held change: a refetch that read a
+ *   held value lands with that hold.
+ * - A rejected refetch errors like any memo; the stale value never masks it.
+ * - `refresh(d)` is a quiet re-ask, and `await refresh(d)` and `until`
+ *   wait for the landing rather than the stale value.
+ * - Combine with `loadingValue` for a node that never suspends at all.
+ *
+ * @example
+ * ```tsx
+ * const rows = createDeferred(() => fetchRows(store.period));
+ *
+ * <section class={{ stale: isPending(() => rows()) }}>
+ *   <For each={rows()}>{row => <Row row={row} />}</For>
+ * </section>
+ * ```
+ */
+export declare function createDeferred<T>(fn: (prev?: T) => T | PromiseLike<T> | AsyncIterable<T>, options?: MemoOptions<T>): SourceAccessor<T>;

package/dist/types/index.d.ts

@@ -5,6 +5,11 @@ export { $REFRESH, action, ContextNotFoundError, NoOwnerError, NotReadyError, Ti
  * outside dev builds.
  */
 export { setConsoleFooter } from "./core/index.js";
+/** @internal The pre-write hook (`setWriteHook` in core/core.ts); the server-components client's deferred hydration. */
+/** @internal Plain-signal identities and the dev read watch (dependency edges; the server-components client). */
+export { setWriteHook, setSignalIdentities, setReadWatch, signalName } from "./core/index.js";
+/** @internal Store dependency edges: the name a store proxy's writes go by (the server-components client). */
+export { storeName } from "./store/edges.js";
 import { type Dev, type Observe } from "./core/index.js";
 /**
  * Observe tier (diagnostics channel, attribution hook slot + interaction
@@ -20,6 +25,7 @@ export type { Truthy, UntilOptions, Accessor, SourceAccessor, Setter, Signal, Co
 export { mapArray, repeat, type Maybe } from "./map.js";
 export * from "./store/index.js";
 export { affects } from "./affects.js";
+export { createDeferred } from "./deferred.js";
 export { flatten } from "./flatten.js";
 export { createLoadingBoundary, createErrorBoundary } from "./boundaries.js";
 export { createRevealOrder, type RevealOrder } from "./reveal.js";

package/dist/types/map.d.ts

@@ -30,7 +30,7 @@ export type Maybe<T> = T | void | null | undefined | false;
  * );
  * ```
  *
- * @description https://docs.solidjs.com/reference/reactive-utilities/map-array
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/jsx-component-primitives/map-array
  */
 export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Item, index: Accessor<number>) => MappedItem, options?: {
     keyed?: true;
@@ -62,7 +62,7 @@ export declare function __smallMoveHits(): number;
  * const view = repeat(count, i => `Item ${i}`, { fallback: () => "empty" });
  * ```
  *
- * @description https://docs.solidjs.com/reference/reactive-utilities/repeat
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/jsx-component-primitives/repeat
  */
 export declare function repeat(count: Accessor<number>, map: (index: number) => any, options?: {
     from?: Accessor<number | undefined>;

package/dist/types/signals.d.ts

@@ -92,6 +92,13 @@ export type EffectBundle<Prev, Next extends Prev = Prev> = {
 interface BaseEffectOptions {
     /** Debug name (dev mode only) */
     name?: string;
+    /**
+     * Source location (`file:line:col`, root-relative) written by the
+     * compiler's `sourceNames` `locations` kind beside `name`; dev and observe
+     * builds keep it for console reports and diagnostic events, production
+     * ignores it. Not meant to be written by hand.
+     */
+    loc?: string;
 }
 /** Options for effect primitives that support deferring/scheduling their initial run (`createEffect`, `createRenderEffect`, `createReaction`). */
 export interface EffectOptions extends BaseEffectOptions {
@@ -144,6 +151,13 @@ export interface EffectOptions extends BaseEffectOptions {
 export interface SignalOptions<T> {
     /** Debug name (dev mode only) */
     name?: string;
+    /**
+     * Source location (`file:line:col`, root-relative) written by the
+     * compiler's `sourceNames` `locations` kind beside `name`; dev and observe
+     * builds keep it for console reports and diagnostic events, production
+     * ignores it. Not meant to be written by hand.
+     */
+    loc?: string;
     /**
      * Custom equality function, or `false` to always notify subscribers.
      * Defaults to reference equality (`isEqual`). Pass a comparator (e.g.
@@ -166,6 +180,13 @@ export interface MemoOptions<T> {
     id?: string;
     /** Debug name (dev mode only) */
     name?: string;
+    /**
+     * Source location (`file:line:col`, root-relative) written by the
+     * compiler's `sourceNames` `locations` kind beside `name`; dev and observe
+     * builds keep it for console reports and diagnostic events, production
+     * ignores it. Not meant to be written by hand.
+     */
+    loc?: string;
     /**
      * Advanced (integration tier). When true, the memo is invisible to the
      * hydration id scheme: it inherits its parent's id instead of consuming a
@@ -275,7 +296,7 @@ export type NoInfer<T extends any> = [T][T extends any ? 0 : never];
  * setUser({ ...user(), name: "Alice" });
  * ```
  *
- * @description https://docs.solidjs.com/reference/basic-reactivity/create-signal
+ * @description https://v2.solidjs.com/reference/solid-js/reactivity/create-signal
  */
 export declare function createSignal<T>(): Signal<T | undefined>;
 export declare function createSignal<T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
@@ -296,7 +317,7 @@ export declare function createSignal<T>(fn: ComputeFunction<T>, options?: Signal
  * const [state, setState] = createOptimistic<T>(fn, options?: SignalOptions<T> & MemoOptions<T>);
  * ```
  *
- * @description https://docs.solidjs.com/reference/basic-reactivity/create-optimistic-signal
+ * @description https://v2.solidjs.com/reference/solid-js/reactivity/create-optimistic
  */
 export declare function createOptimistic<T>(): Signal<T | undefined>;
 export declare function createOptimistic<T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
@@ -329,7 +350,7 @@ export declare function createOptimistic<T>(fn: ComputeFunction<T>, options?: Si
  * });
  * ```
  *
- * @description https://docs.solidjs.com/reference/basic-reactivity/create-memo
+ * @description https://v2.solidjs.com/reference/solid-js/reactivity/create-memo
  */
 export declare function createMemo<T>(compute: ComputeFunction<NoInfer<T>, T>, options: MemoOptions<T> & {
     loadingValue: T;
@@ -401,7 +422,7 @@ export declare function createMemo<T>(compute: ComputeFunction<undefined | NoInf
  * );
  * ```
  *
- * @description https://docs.solidjs.com/reference/basic-reactivity/create-effect
+ * @description https://v2.solidjs.com/reference/solid-js/reactivity/create-effect
  */
 export declare function createEffect<const T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, effectFn: EffectFunction<NoInfer<T>, T> | EffectBundle<NoInfer<T>, T>, options?: EffectOptions): void;
 /**
@@ -431,7 +452,7 @@ export declare function createEffect<const T>(compute: ComputeFunction<undefined
  * }
  * ```
  *
- * @description https://docs.solidjs.com/reference/secondary-primitives/create-render-effect
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/specialized-reactivity/create-render-effect
  */
 export declare function createRenderEffect<const T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, effectFn: EffectFunction<NoInfer<T>, T>, options?: EffectOptions): void;
 /**
@@ -477,7 +498,7 @@ export declare function createRenderEffect<const T>(compute: ComputeFunction<und
  * });
  * ```
  *
- * @description https://docs.solidjs.com/reference/secondary-primitives/create-tracked-effect
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/specialized-reactivity/create-tracked-effect
  */
 export declare function createTrackedEffect(compute: () => void | (() => void), options?: BaseEffectOptions): void;
 /**
@@ -504,7 +525,7 @@ export declare function createTrackedEffect(compute: () => void | (() => void),
  * setCount(1); // logs once, reaction re-armed for next change
  * ```
  *
- * @description https://docs.solidjs.com/reference/secondary-primitives/create-reaction
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/specialized-reactivity/create-reaction
  */
 export declare function createReaction(effectFn: EffectFunction<undefined> | EffectBundle<undefined>, options?: EffectOptions): (tracking: () => void) => void;
 /**

package/dist/types/store/affects.d.ts

@@ -1 +1,12 @@
+import type { Computed, Signal } from "../core/types.js";
+import { type StoreTarget } from "./target.js";
+type Marked = Signal<any> | Computed<any>;
+/** The nodes an `affects(store[, key])` declaration marks (affects.ts
+ * registers each). */
+export declare function storeMarks(t: StoreTarget, key: PropertyKey | undefined): Marked[];
+/** `affects()` calls it before a store-targeted declaration (idempotent). */
+export declare function installStoreAffects(): void;
+/** The carrier's last mark released (affects.ts): its scope dies, and the
+ * nodes that inherited the mark release theirs. */
+export declare function releaseMarkScope(carrier: Marked): void;
 export {};

package/dist/types/store/edges.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @internal The name of the store `x` belongs to — `x` a store proxy (a
+ * setter's entry) or one of its property nodes (the setter notifying it) —
+ * or undefined when it has none or it cannot be placed: a projection or
+ * optimistic family, a store chained over another store's proxy, a root
+ * named twice, or a proxy reached through a store other than the one it
+ * was named as the root of.
+ */
+export declare function storeName(x: object | undefined): string | undefined;

package/dist/types/store/hooks.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Store — the engine's optional-machinery slots, in a module of their own so
+ * an installer reaches them without importing store.ts (whose top level
+ * installs the engine): the store half of `affects()` installs through here
+ * from `affects()`, and an app without stores carries none of the engine.
+ * A slot no installer reaches stays `null`, and a bundler folds its sites.
+ */
+import type { Signal } from "../core/types.js";
+import type { StoreTarget } from "./target.js";
+/** The optimistic machinery (optimistic.ts, S4), installed when it loads
+ * — a plain store pays nothing for it (#2883): the plain paths reach it
+ * only through a family with `opt` set, which only `createOptimisticStore`
+ * sets. */
+export interface OptHooks {
+    /** A user setter's draft on an optimistic family: a clone of the
+     * writer's view (a staging already on the target is set aside). */
+    draft(t: StoreTarget): Record<PropertyKey, any>;
+    /** The setter's exit: the draft becomes guesses; returns the staging the
+     * draft set aside (`null`: none). */
+    writes(t: StoreTarget, pb: Record<PropertyKey, any>): Record<PropertyKey, any> | null;
+    /** `src` with the lanes' values over it (`writer`: the next write's base
+     * — the unflushed guesses too). */
+    view(t: StoreTarget, src: Record<PropertyKey, any>, writer?: boolean): Record<PropertyKey, any>;
+    /** An untracked `key in store`: the presence guess, or `undefined`. */
+    has(t: StoreTarget, key: PropertyKey): boolean | undefined;
+    /** A guessed key's descriptor (`null`: removed; `undefined`: no guess). */
+    descriptor(t: StoreTarget, key: PropertyKey): PropertyDescriptor | null | undefined;
+    /** The flush's commit: targets no lane holds leave `overlaid`. */
+    sweep(): void;
+    /** The container comparator's lane arm: an arrangement guess against a
+     * landing (or another arrangement), by row identity. */
+    arrangement(t: StoreTarget, a: any, b: any): boolean;
+    /** A user's `reconcile` on an optimistic family: the keyed diff written
+     * into the draft. */
+    reconcile(draft: any, incoming: any, keyFn: ((item: any) => any) | null): void;
+}
+export declare let optHooks: OptHooks | null;
+export declare function installOptHooks(hooks: OptHooks): void;
+/** The store half of `affects()` (store/affects.ts), installed by the first
+ * store-targeted declaration: a node born on a covered record inherits the
+ * live mark; an untracked verdict probe through a record with no node is
+ * witnessed. */
+export interface AffectsHooks {
+    _born(t: StoreTarget, node: Signal<any>, key: PropertyKey): void;
+    _witness(t: StoreTarget, key: PropertyKey | undefined): void;
+}
+export declare let affectsHooks: AffectsHooks | null;
+export declare function installAffectsHooks(hooks: AffectsHooks): void;

package/dist/types/store/index.d.ts

@@ -3,15 +3,14 @@
  * (`createStore(fn, seed)`), projections, optimistic stores and reconcile
  * return on later steps (plan sec. 31.5).
  */
-export type { NoFn, NotWrappable, ProjectionOptions, ProjectionStoreReturn, SolidStore, Store, StoreOptions, StoreReturn, StoreSetter } from "./types.js";
+export type { NoArray, NoFn, NotWrappable, ProjectionOptions, ProjectionStoreReturn, SolidStore, Store, StoreOptions, StoreReturn, StoreSetter } from "./types.js";
 export { $PROXY, $RECORD, $TARGET, $TRACK, isWrappable, markRaw } from "./types.js";
 export { storeIsShallow, storeHasFamily, storeHasOptimisticFamily } from "./store.js";
 export { storePath } from "./storePath.js";
 export type { StorePathRange, PathSetter, Part, CustomPartial, ArrayFilterFn } from "./storePath.js";
-import "./affects.js";
 import { createOptimisticStore } from "./optimistic.js";
 import { createProjection } from "./projection.js";
-import type { NoFn, ProjectionOptions, ProjectionStoreReturn, Store, StoreOptions, StoreReturn } from "./types.js";
+import type { NoArray, NoFn, ProjectionOptions, ProjectionStoreReturn, Store, StoreOptions, StoreReturn } from "./types.js";
 export { createOptimisticStore, createProjection };
 /** The store's internal record behind a proxy (`store[$TARGET]`). Kept
  * under `next`'s public name; its shape is the L2 target's (plan plan sec. 31–32:
@@ -24,9 +23,16 @@ export type { SourceKind } from "./utils.js";
  * Create a reactive store: a proxy over plain data with fine-grained
  * subscriptions per read path, written through its setter's draft — or, in
  * the derived form, a projection with a setter.
+ *
+ * The derived form comes in two shapes. Seedless, `createStore(fn)`: `fn`
+ * takes no draft and every answer is a complete `T` (plain-object roots only;
+ * pass `undefined` for the seed to reach the options). Seeded,
+ * `createStore(fn, seed)`: the seed is a complete `T` the derive drafts
+ * against — `[]` for an array.
  */
 export declare function createStore<T extends object = {}>(initialValue: NoFn<T>, options?: StoreOptions): StoreReturn<T>;
-export declare function createStore<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): ProjectionStoreReturn<T>;
+export declare function createStore<T extends object = {}>(fn: (() => T | Promise<T> | AsyncIterable<T>) & NoArray<T>, seed?: null, options?: Omit<ProjectionOptions, "seedLoadingValue">): ProjectionStoreReturn<T>;
+export declare function createStore<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: NoFn<T> | Store<NoFn<T>>, options?: ProjectionOptions): ProjectionStoreReturn<T>;
 /**
  * A setter transform that reconciles `value` into the store by key
  * (`"id"` by default; `null` positional), preserving store identity for

package/dist/types/store/optimistic.d.ts

@@ -1,6 +1,6 @@
 import type { Refreshable } from "../core/index.js";
 import { type StoreTarget } from "./target.js";
-import { type NoFn, type ProjectionOptions, type Store, type StoreOptions, type StoreSetter } from "./types.js";
+import { type NoArray, type NoFn, type ProjectionOptions, type Store, type StoreOptions, type StoreSetter } from "./types.js";
 export declare function notifyOptimisticWrites(t: StoreTarget, pb: Record<PropertyKey, any>): Record<PropertyKey, any> | null;
 export declare function sweepOverlaid(): void;
 /** An untracked `key in store` on an optimistic family: the presence guess
@@ -20,4 +20,5 @@ export declare function optimisticView(t: StoreTarget, src: Record<PropertyKey,
  * guess is what lands). */
 export declare function latestView(t: StoreTarget, src: Record<PropertyKey, any>): Record<PropertyKey, any>;
 export declare function createOptimisticStore<T extends object = {}>(initialValue: NoFn<T> | Store<NoFn<T>>, options?: StoreOptions): [get: Store<T>, set: StoreSetter<T>];
-export declare function createOptimisticStore<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Refreshable<Store<T>>, set: StoreSetter<T>];
+export declare function createOptimisticStore<T extends object = {}>(fn: (() => T | Promise<T> | AsyncIterable<T>) & NoArray<T>, seed?: null, options?: Omit<ProjectionOptions, "seedLoadingValue">): [get: Refreshable<Store<T>>, set: StoreSetter<T>];
+export declare function createOptimisticStore<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: NoFn<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Refreshable<Store<T>>, set: StoreSetter<T>];

package/dist/types/store/projection.d.ts

@@ -1,6 +1,6 @@
 import type { Computed } from "../core/types.js";
 import type { Refreshable } from "../core/index.js";
-import { type NoFn, type ProjectionOptions, type Store } from "./types.js";
+import { type NoArray, type NoFn, type ProjectionOptions, type Store } from "./types.js";
 /** The derive's pass: run `fn` against a draft of the store; commit its
  * result (sync, or each async landing) through the reconcile channel.
  * Draft validity is per run (R37): live from here until the NEXT run starts
@@ -13,6 +13,7 @@ export declare function runProjectionComputed<T extends object>(wrappedStore: St
  * firewall). `fn` may be async or an async iterator; the seed is a draft,
  * never an observable value, until the first landing (A25).
  */
-export declare function createProjection<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): Refreshable<Store<T>>;
+export declare function createProjection<T extends object = {}>(fn: (() => T | Promise<T> | AsyncIterable<T>) & NoArray<T>, seed?: null, options?: Omit<ProjectionOptions, "seedLoadingValue">): Refreshable<Store<T>>;
+export declare function createProjection<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: NoFn<T> | Store<NoFn<T>>, options?: ProjectionOptions): Refreshable<Store<T>>;
 /** `createStore(fn, seed, options)`: a projection with a user setter. */
-export declare function createStoreDerived<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [Refreshable<Store<T>>, (f: (draft: T) => T | void) => void];
+export declare function createStoreDerived<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: T | null | undefined, options?: ProjectionOptions): [Refreshable<Store<T>>, (f: (draft: T) => T | void) => void];

package/dist/types/store/store.d.ts

@@ -1,43 +1,5 @@
 import type { Signal } from "../core/types.js";
 import { type StoreFamily, type StoreTarget } from "./target.js";
-/** The optimistic machinery (optimistic.ts, S4), installed when it loads
- * — a plain store pays nothing for it (#2883): the plain paths reach it
- * only through a family with `opt` set, which only `createOptimisticStore`
- * sets. */
-export interface OptHooks {
-    /** A user setter's draft on an optimistic family: a clone of the
-     * writer's view (a staging already on the target is set aside). */
-    draft(t: StoreTarget): Record<PropertyKey, any>;
-    /** The setter's exit: the draft becomes guesses; returns the staging the
-     * draft set aside (`null`: none). */
-    writes(t: StoreTarget, pb: Record<PropertyKey, any>): Record<PropertyKey, any> | null;
-    /** `src` with the lanes' values over it (`writer`: the next write's base
-     * — the unflushed guesses too). */
-    view(t: StoreTarget, src: Record<PropertyKey, any>, writer?: boolean): Record<PropertyKey, any>;
-    /** An untracked `key in store`: the presence guess, or `undefined`. */
-    has(t: StoreTarget, key: PropertyKey): boolean | undefined;
-    /** A guessed key's descriptor (`null`: removed; `undefined`: no guess). */
-    descriptor(t: StoreTarget, key: PropertyKey): PropertyDescriptor | null | undefined;
-    /** The flush's commit: targets no lane holds leave `overlaid`. */
-    sweep(): void;
-    /** The container comparator's lane arm: an arrangement guess against a
-     * landing (or another arrangement), by row identity. */
-    arrangement(t: StoreTarget, a: any, b: any): boolean;
-    /** A user's `reconcile` on an optimistic family: the keyed diff written
-     * into the draft. */
-    reconcile(draft: any, incoming: any, keyFn: ((item: any) => any) | null): void;
-}
-export declare let optHooks: OptHooks | null;
-export declare function installOptHooks(hooks: OptHooks): void;
-/** The store half of `affects()` (store/affects.ts), installed with the
- * stores: a node born on a covered record inherits the live mark; an
- * untracked verdict probe through a record with no node is witnessed. */
-export interface AffectsHooks {
-    born(t: StoreTarget, node: Signal<any>, key: PropertyKey): void;
-    witness(t: StoreTarget, key: PropertyKey | undefined): void;
-}
-export declare let affectsHooks: AffectsHooks | null;
-export declare function installAffectsHooks(hooks: AffectsHooks): void;
 import { type StoreOptions } from "./types.js";
 export { $PROXY, $TARGET, $TRACK, markRaw } from "./types.js";
 export type SetStoreFunction<T> = (fn: (draft: T) => T | void) => void;
@@ -84,7 +46,7 @@ export declare function getHasNode(target: StoreTarget, key: PropertyKey): Signa
  * committed backing. */
 export declare function getContainerNode(target: StoreTarget): Signal<any>;
 export declare function bumpDeep(t: StoreTarget): void;
-export declare function nameStore(proxy: any, name: string | undefined): void;
+export declare function nameStore(proxy: any, name: string | undefined, loc?: string): void;
 /** Shallow clone into store ownership. Plain data (grade 2) spreads; anything
  * else copies descriptors (accessors kept, everything made configurable). */
 export declare function cloneRaw(source: Record<PropertyKey, any>, t: StoreTarget): Record<PropertyKey, any>;
@@ -145,6 +107,9 @@ export declare function notifyFold(t: StoreTarget, old: Record<PropertyKey, any>
  * "adoption is eager by contract" — and the node keeps the frame committed
  * readers under a hold still see), `t.v` otherwise. */
 export declare function committed(t: StoreTarget): Record<PropertyKey, any>;
+/** The same row at a slot, as the adoption pairs rows (reconcile.ts): two
+ * objects whose keys agree — positionally for an unkeyed family. */
+export declare function sameRow(pv: any, nv: any, keyFn: ((item: any) => any) | null): boolean;
 /** A chained backing's child (§7b): a raw the inner family owns, or holds
  * at this key, is served as the inner store's wrapper — never a fresh
  * raw-keyed one — so the chained targets are the same objects across

package/dist/types/store/target.d.ts

@@ -42,6 +42,11 @@ export interface StoreFamily {
      * (`settleFamily`). A sync commit with no wake behind it walks nothing. */
     woke?: boolean;
 }
+/** One setter's written keys; `u` is the batch's earlier setters' (the
+ * fold's union), present only once a second setter writes the target. */
+export interface WrittenKeys extends Set<PropertyKey> {
+    u?: WrittenKeys;
+}
 export interface StoreTarget {
     /** Committed backing: source object (shared) or owned clone. */
     v: Record<PropertyKey, any>;
@@ -59,19 +64,22 @@ export interface StoreTarget {
     /** Lazy CONTAINER node: membership/iteration/`$TRACK`/`length`
      * subscriptions (§6) and the backing's staging home (plan sec. 31.3). */
     k: Signal<any> | null;
-    /** Keys written through the traps since the last fold commit. Bounds the
-     * setter notify/hold-check to O(written) instead of O(subscribed nodes) —
-     * a record with thousands of per-key subscriptions (selection maps) would
-     * otherwise pay a full node scan on every write. null = no trap writes
-     * this batch (bulk paths fall back to the full scan); WK_ALL = bound
-     * unusable (array length write). LOAD-BEARING SHAPE RULE: array proxy
-     * targets carry their fields as named properties on a real array, and V8
+    /** Keys written through the traps by the current setter, with the earlier
+     * setters' of the batch chained behind (`u`) until the fold commit. Bounds
+     * the setter notify/hold-check to O(written) instead of O(subscribed
+     * nodes) — a record with thousands of per-key subscriptions (selection
+     * maps) would otherwise pay a full node scan on every write — and to THIS
+     * setter's keys (D-8: a key an earlier setter of the batch wrote is told
+     * once, #3743). null = no trap writes this batch (bulk paths fall back to
+     * the full scan); WK_ALL = bound unusable (array length write).
+     * LOAD-BEARING SHAPE RULE: array proxy targets carry their fields as named
+     * properties on a real array, and V8
      * normalizes an array to dictionary properties as the named count grows
      * (empirically at counts ≡ 0 mod 3 from 18 up on V8 13.x) — every trap
      * field read then becomes a hash lookup (~15% uibench, tree suites
      * worst). Future write-side state MUST ride an extension object, not new
      * named fields. */
-    wk: Set<PropertyKey> | null;
+    wk: WrittenKeys | null;
     /** Lazy deep-witness node: `deep()` subscribes ONE node per record instead
      * of one per path; write paths bump it only when it exists. Separate from
      * `k` so $TRACK/mapArray never rerun on leaf value changes (R9). */

package/dist/types/store/types.d.ts

@@ -34,6 +34,13 @@ export interface StoreOptions {
      * projection node carries the name itself.
      */
     name?: string;
+    /**
+     * Source location (`file:line:col`, root-relative) written by the
+     * compiler's `sourceNames` `locations` kind; dev and observe builds keep it
+     * for console reports and diagnostic events, production ignores it. Not
+     * meant to be written by hand.
+     */
+    loc?: string;
     /** Single-layer store: root keys reactive, values raw records replaced by reference */
     shallow?: boolean;
 }
@@ -60,7 +67,14 @@ export interface ProjectionOptions extends StoreOptions {
      */
     seedLoadingValue?: boolean;
 }
+/** @internal */
 export type NoFn<T> = T extends Function ? never : T;
+/**
+ * Rejects array roots on the seedless derived form: a store's root shape is
+ * fixed when it is created, and `[]` is already a complete seed for an array.
+ * @internal
+ */
+export type NoArray<T> = Extract<T, readonly unknown[]> extends never ? unknown : never;
 /** Brand keys the proxy answers directly (never user data). */
 export declare const $TRACK: unique symbol, $TARGET: unique symbol, $PROXY: unique symbol, $RECORD: unique symbol;
 export declare namespace SolidStore {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/signals",
-  "version": "2.0.0-rc.14",
+  "version": "2.0.0-rc.16",
   "description": "Solid's reactive primitives: signals, memos, effects, stores, and async-aware computations.",
   "author": "Ryan Carniato",
   "license": "MIT",