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

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

@@ -87,6 +87,11 @@ export declare const CONFIG_STAGED: number;
  * parking flush they see the committed value and hold nothing, and are
  * re-derived at the landing. Set at the park seam on every staged node. */
 export declare const CONFIG_HELD: number;
+/** A member of the uncommitted frame a held pass built (ruling A): set at
+ * the park seam on every computed under a staged node (`holdFrame`). Never
+ * shown, it has no screen: its reads are its transaction's, whichever flush
+ * runs it (`bornInto`, #4010). Cleared by its commit. */
+export declare const CONFIG_HELD_FRAME: number;
 /** A15's reveal corollary (#3305): a commit published this flight's inputs
  * beneath it — the node was pending, nothing staged, when it committed — so
  * its committed value is torn against the visible frame. A render effect

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

@@ -1,3 +1,4 @@
+import type { Transaction } from "./scheduler.js";
 import type { Computed, NodeExtension, NodeOptions, Owner, Signal } from "./types.js";
 export declare const PRIMITIVE_IN_FORBIDDEN_SCOPE_MESSAGE = "[PRIMITIVE_IN_FORBIDDEN_SCOPE] Cannot create reactive primitives inside createTrackedEffect or owner-backed onSettled";
 export declare const PRIMITIVE_IN_EFFECT_CALLBACK_MESSAGE: string;
@@ -32,6 +33,24 @@ export declare function computed<T>(fn: (prev: T) => T | PromiseLike<T> | AsyncI
 export declare function ext(el: {
     _x: NodeExtension | null;
 }): NodeExtension;
+/** A tracked read of a held node (the reader derives from its transaction's
+ * world): the reading pass is marked as having read it (born-held decision
+ * in `recompute`), and the flush joins the node's transaction — unless the
+ * reader is a render effect. A render effect is the frame, not a derivation
+ * (rule 3): in that transaction's own flush, or born into it (uninitialized,
+ * A29), it reads the staged value and holds nothing of its own; otherwise it
+ * reads the committed value instead (`frameRead`). A node born into the
+ * future has no committed value: every reader joins it. A first pass is
+ * something not ready under a loading boundary that has not shown content:
+ * the boundary collects it and shows its fallback, and the pass is the
+ * boundary's, not the tick's (A29's boundary exemption, #3540). */
+export declare function joinPass(c: Computed<any>, el: Signal<any> | Computed<any>): void;
+/** A node born into transaction `t`: held by it and never committed (A29,
+ * ruling A) — uninitialized (born held), or a member of the frame one of its
+ * held passes built (CONFIG_HELD_FRAME). Its branch exists only in `t`: it
+ * has no screen to read, so it reads `t`'s values, whichever flush runs it,
+ * and keeps staging (#4010). */
+export declare function bornInto(c: Computed<any>, t: Transaction): unknown;
 /**
  * Build an Effect node with all effect-specific fields baked into a single object literal,
  * so V8 sees the full hidden class shape at construction time. Effects always run in lazy
@@ -209,8 +228,9 @@ export declare function serve(el: Signal<any> | Computed<any>, c: Computed<any>
  * write never shows through the lane. A verdict lane's work likewise: the
  * lane holds verdicts, not the frame's other stagings (#3851) — except a
  * verdict reader, which answered for itself (the lane seam, lanes.ts). Not
- * a read of a node born staged: it has no committed value to re-derive on,
- * and a re-run would read the same staging and re-queue every round. */
+ * a read of a node born staged at all: it has no committed value to
+ * re-derive on, and a re-run would read the same staging and re-queue every
+ * round (#3969: nor does it make a later lane read a re-derive, `enterLane`). */
 export declare function stagedRead(c: Computed<any>, el?: Signal<any> | Computed<any>): void;
 /** A10 for a staged node: a verdict reader (the pass entered a window) that
  * also reads a frame's proposal plainly sees the screen — `[latest(q), q()]`
@@ -219,13 +239,23 @@ export declare function stagedRead(c: Computed<any>, el?: Signal<any> | Computed
  * #3322 — one run, on the committed world), or with the hold. Before any
  * transaction the answer is the seam's and the reader watches it
  * (verdict.ts). A node born into the future has no screen: its staging is
- * its only value (A29). */
+ * its only value (A29). Nor has a reader born into the flush's transaction
+ * (`bornInto`, #4010): its branch exists only there. */
 export declare function stagedScreen(c: Computed<any>): boolean;
 export declare function ownedScopeWriteMessage(owner: Owner): string;
 /** A28 (4) — written inside a recompute that runs OUTSIDE a flush (a
  * creation-time compute): promoted at that pass's end, visible to the rest of
  * the block. Cold: only contextual writes reach here. */
 export declare function notePromotedWrite(el: Signal<any> | Computed<any>): void;
+/** Cold half of setSignal's snapshot arm (see there), shared with a store
+ * container's structural notify: first write during capture to a plain
+ * signal without a live snapshot records the pre-write value. Only plain
+ * user signals qualify. Computeds reach setSignal from an
+ * async landing (asyncWrite), and a value arriving from async during the pass
+ * REVEALS — the creation-time arm skips pending computeds for the same
+ * reason. Firewall leaves belong to a projection whose compute is the tree's
+ * own work, captured (or deliberately not) at creation. */
+export declare function captureWriteSnapshot<T>(el: Signal<T> | Computed<T>, current: T): void;
 export declare function setSignal<T>(el: Signal<T> | Computed<T>, v: T | ((prev: T) => T)): T;
 /**
  * User-facing setter for the memo form of `createSignal(fn)`. A write applies

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

@@ -48,6 +48,16 @@ export declare function verdictLane(t: Transaction): Transaction;
  * propagation (async.ts `propagateStatus`), the node gone pending. */
 export declare function laneStage(el: Computed<any>, l: Transaction, create: boolean, errored: boolean | Computed<any>): boolean;
 export declare function supersede(n: Signal<any> | Computed<any>, value: unknown, changed: boolean): void;
+/** Truth readers (`until`, `refresh`; CONFIG_AUTHORITATIVE) — pay-for-use:
+ * the first one installs these on GlobalQueue (signals.ts `watch`).
+ *
+ * A truth reader's read of a lane node: the lane's value when it is the
+ * truth (#3943), else the truth staged beneath a guess, else the committed
+ * value. */
+export declare function truthRead(el: Signal<any> | Computed<any>): unknown;
+/** A guess confirmed: its lane's truth readers re-read — of the lane's
+ * derivations too, which may be the truth now (#3943). */
+export declare function truthConfirmed(l: Transaction): void;
 /** Lanes. A lane's node is read by its reader's kind: an authoritative
  * reader (`until`) sees the truth — staged beneath a guess, else committed
  * — and is no lane's; an untracked read sees the lane's latest value (A17:

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

@@ -202,12 +202,18 @@ export declare class GlobalQueue implements IQueue {
      * link's refreshed from the inner store, whose commits it never learned
      * while the guess served the reads (store/store.ts, §7b). */
     static _slotCovered: ((n: Signal<any>) => unknown) | undefined;
-    /** `affects()` on a store (store/affects.ts ↔ affects.ts): the nodes a
-     * declaration marks; a carrier's scope released with its last mark; a
-     * bare registration (birth inheritance); a witnessed mark on an untracked
-     * probe (verdict.ts). */
-    static _storeMarks: ((t: any, key: PropertyKey | undefined) => Signal<any>[]) | undefined;
-    static _releaseMarkScope: ((carrier: Signal<any> | Computed<any>) => void) | undefined;
+    /** The store's row judgment for a guessed slot (optimistic.ts): the truth
+     * is the guess's echo when reconcile would write nothing into it. */
+    static _echoes: ((guess: unknown, truth: unknown) => boolean) | undefined;
+    /** Truth readers (lanes.ts `truthRead`/`truthConfirmed`), installed by the
+     * first `until`/`refresh` (signals.ts `watch`). */
+    static _truth: ((el: any) => unknown) | undefined;
+    static _confirmed: ((l: Transaction) => void) | undefined;
+    /** `affects()` on a store (store/affects.ts): a store's node for a key
+     * (store/store.ts `getNode`); a bare registration (birth inheritance); a
+     * witnessed mark on an untracked probe (verdict.ts). */
+    static _storeNode: ((t: any, key: PropertyKey) => Signal<any>) | undefined;
+    static _storeWrappable: ((v: unknown) => boolean) | undefined;
     static _mark: ((node: Signal<any> | Computed<any>) => void) | undefined;
     static _witnessMark: (() => void) | undefined;
     /** An older question's truth was held beneath a guess (lanes.ts

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

@@ -86,12 +86,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. */

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/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

@@ -8,7 +8,6 @@ export { $PROXY, $RECORD, $TARGET, $TRACK, isWrappable, markRaw } from "./types.
 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";

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;
@@ -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/package.json

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