@solidjs/signals 2.0.0-rc.19 → 2.0.0-rc.20

package/dist/prod/store/types.js

@@ -70,4 +70,14 @@ function setWriteOverride(e) {
     writeOverride = e;
 }
 
-export { $PROXY, $RECORD, $TARGET, $TRACK, isRawValue, isWrappable, markRaw, markRawIngest, markRawOne, ownEnumerableKeys, rawValuesUsed, setWriteOverride, writeOverride };
+/** The list driver's view of a shallow store (map.ts): the backing a read of
+ * every slot serves this reader, or `undefined` when the list is no shallow
+ * store or a slot read could differ from it. Installed by store.ts's top
+ * level, so a `<For>` in an app without stores carries none of it; it lives
+ * beside `$TRACK` so map.ts reaches no other store module. */ let shallowView = null;
+
+function installShallowView(e) {
+    shallowView = e;
+}
+
+export { $PROXY, $RECORD, $TARGET, $TRACK, installShallowView, isRawValue, isWrappable, markRaw, markRawIngest, markRawOne, ownEnumerableKeys, rawValuesUsed, setWriteOverride, shallowView, writeOverride };

package/dist/types/affects.d.ts

@@ -3,8 +3,9 @@ import { type Store } from "./store/types.js";
 /**
  * Declares that in-flight work will change the targeted data: the source —
  * and everything derived from it — reads as pending (`isPending` → `true`)
- * from the declaration until the surrounding transaction settles. A mark is
- * a promise of change, not an absence of value: the marked values stay
+ * from the declaration until the surrounding transaction settles — or, if
+ * the source's own fetch is still in flight then (a declared reload's
+ * `refresh()`), until that fetch lands. A mark is a promise of change, not an absence of value: the marked values stay
  * readable, no reader suspends on one, and it holds nothing — the
  * transaction's completion never waits on a mark. Pendingness is additive:
  * a mark can turn pending on for data the graph cannot see changing yet

package/dist/types/boundaries.d.ts

@@ -10,8 +10,9 @@ interface Boundary {
     /** Null during the output's first pass (its post-check decides then). */
     _output: Computed<any> | null;
     /** Frame readers under it carrying its status: caught, or (loading,
-     * showing content) forwarded — the `on` re-arm collects those. */
-    _readers: Set<Computed<any>>;
+     * showing content) forwarded — the `on` re-arm collects those. Each maps
+     * to what it waits on: itself, or (error) the source that threw. */
+    _readers: Map<Computed<any>, Computed<any>>;
     /** Loading: has shown content. Fresh again after an `on` re-arm found
      * something pending. */
     _initialized: boolean;
@@ -62,6 +63,17 @@ export declare let revealHooks: RevealHooks | null;
 export declare function setRevealHooks(h: RevealHooks): void;
 export type { Boundary };
 export declare function redraw(b: Boundary): void;
+/** Drop the readers that settled or died. Settled: a loading reader no
+ * longer pending; an error's source neither errored nor in flight. A reader
+ * that landed but is held (its value staged in a transaction) is not: the
+ * content reveals at the commit, with its run. The tree is: the output reads
+ * it and enters the transaction itself (its committed value shows until the
+ * landing). The statuses that keep a reader: pending — and its error, for an
+ * error boundary (`_type` is the status it catches) — on the reader or its
+ * source. A reader pending again after the source that threw answered (it
+ * re-asks through a memo that carried the error) has no new answer yet: the
+ * error stays the display (D-39: a pending is not a value; async-gen 91501
+ * #1831). */
 export declare function prune(b: Boundary, pass: boolean): number;
 /** Reveal order: a slot is ready when its content can show — it has shown
  * content, or nothing under it is unready (the tree neither pending nor

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

@@ -1,6 +1,7 @@
 import { NotReadyError } from "./error.js";
 import type { Computed, Link } from "./types.js";
 export declare function addPendingSource(el: Computed<any>, source: Computed<any>): boolean;
+export declare function removePendingSource(el: Computed<any>, source: Computed<any>): boolean;
 /**
  * A loading-window node hit an unready source (sync throw in recompute, or a
  * NotReadyError-rejected flight): register for the source's settle — the
@@ -39,7 +40,7 @@ export declare function releaseFlightTeardown(el: Computed<any>): void;
 export declare function onSupersede(fn: () => void): void;
 export declare function handleAsync<T>(el: Computed<T>, result: T | PromiseLike<T> | AsyncIterable<T>, setter?: (value: T) => void, onError?: (error: unknown, pending: boolean) => void): T;
 export declare function clearStatus(el: Computed<any>, clearUninitialized?: boolean): void;
-export declare function notifyStatus(el: Computed<any>, status: number, error: any): void;
+export declare function notifyStatus(el: Computed<any>, status: number, error?: any): void;
 /** The dependents' half of `notifyStatus`: `el`'s status reaches each
  * subscriber as a propagated mark (or a re-derive). On its own for a store
  * family's leaves, which are not the derive's dependents — the family

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

@@ -68,6 +68,11 @@ export declare const REACTIVE_SCREEN_READ: number;
  * later read of the same pass routed it into a verdict lane — that was not
  * the probe's answer (lanes.ts). Per pass. */
 export declare const REACTIVE_PROBE_UNANSWERED: number;
+/** The pass opened a verdict window of its own (`isPending`/`latest`) — not
+ * only read a verdict memo (F-6, core.ts `read`). An async memo whose pass
+ * did not is D-25's hold work while its flight is up (verdict.ts
+ * `holdWork`). Per pass (1 << 20 is lanes.ts's LEFT_SHOWN). */
+export declare const REACTIVE_WINDOW: number;
 export declare const CONFIG_OWNED_WRITE: number;
 export declare const CONFIG_NO_SNAPSHOT: number;
 export declare const CONFIG_TRANSPARENT: number;
@@ -201,6 +206,9 @@ export declare const CONFIG_KEY_BAG: number;
  * joins nothing, so two mounts under one boundary made in separate flushes
  * keep their holds apart (D-4, S-5 rows 1′–3′, #4283). */
 export declare const CONFIG_FRAME: number;
+/** The node's last answering pass registered a flight: an async memo. Kept
+ * by the verdict engine alone (verdict.ts `holdWork`), which reads it. */
+export declare const CONFIG_ASYNC: number;
 export declare const STATUS_NONE = 0;
 export declare const STATUS_PENDING: number;
 export declare const STATUS_ERROR: number;

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

@@ -0,0 +1,54 @@
+/**
+ * Dev: duplicate-copy detection.
+ *
+ * Two copies of Solid on a page are only a bug when they meet: one copy's
+ * code runs inside the other's computation or component and finds no owner
+ * or listener of its own (each copy keeps them in its own module state), so
+ * it neither reacts nor sees the other's providers. That is the shape of
+ * every duplicate report on record: a library's precompiled JSX on copy B
+ * reading the app's props or signals from copy A, a runtime that bundled its
+ * own solid-js. Copies that never meet (a devtools panel rendering into its
+ * own root, an isolated widget) are fine at any version, so nothing is
+ * checked when a copy loads.
+ *
+ * Every copy from 2.0 on shares one global record, `Solid$$copies`. It is a
+ * contract between all future versions of Solid, so its shape never changes:
+ *
+ * - `copies`: each copy adds 1 when it loads.
+ * - `running`: while `copies > 1`, each copy names itself here (an object
+ *   with a `rooted` boolean, compared by identity) around its computations
+ *   and components, and restores the previous value after.
+ *
+ * A copy that sees `copies < 2` skips the slot entirely, so a page with one
+ * copy pays one property read per check. v1 keeps its own load-time `Solid$$`
+ * check, which this never sets, so neither side warns about the other.
+ */
+interface SolidCopy {
+    /** This copy has created a root of its own (it renders by itself). */
+    rooted: boolean;
+}
+interface SolidCopies {
+    copies: number;
+    running: SolidCopy | undefined;
+}
+declare global {
+    var Solid$$copies: SolidCopies | undefined;
+}
+export declare function markCopyRooted(): void;
+/**
+ * Marks this copy as the one running; returns the slot's previous value. A
+ * nested run of the same copy (most runs inside a flush) only reads the slot.
+ */
+export declare function enterCopy(): SolidCopy | undefined;
+export declare function exitCopy(prev: SolidCopy | undefined): void;
+/** @internal Runs `fn` with this copy marked as the one running. */
+export declare function runAsSolidCopy<T>(fn: () => T): T;
+/** @internal An ownerless component or context read: warns if another copy is running. */
+export declare function checkForeignOwnerless(): void;
+/**
+ * An untracked read: warns if another copy's computation is running, unless
+ * both copies render through roots of their own (an app calling into an
+ * isolated copy's API, which reads its own state untracked by design).
+ */
+export declare function checkForeignRead(): void;
+export {};

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

@@ -67,6 +67,14 @@ export declare function joinPassAt(c: Computed<any>, t: Transaction): void;
  * 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;
+/** The computed whose pass a creation under `owner` belongs to (a root's is
+ * its nearest computed ancestor's), or null outside every pass. */
+export declare function creatorPass(owner: Owner | null): Computed<any> | null;
+/** What `born` and the passes still running around `p` read — its
+ * creator's, theirs — of the future or a staging (REACTIVE_JOINED |
+ * REACTIVE_STAGED_READ): a pass created by one that did has no screen; its
+ * branch exists only in that world (#4341). */
+export declare function creatorReads(p: Computed<any> | null, born: number): number;
 /**
  * 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
@@ -258,6 +266,13 @@ export declare function resyncUnflushedCompanions(): void;
  * reached its height (or the reader is a fresh-pull waiter), and sit the
  * reader above it. */
 export declare function pullComputed(owner: Computed<any>, c: Computed<any>): void;
+/**
+ * Dev only: a read's diagnostics — the devtools read hook, the foreign-read
+ * check and the post-await untracked-read check. Every caller guards with
+ * `__DEV__`: `read` here, and a store leaf's read that is served without
+ * `read` (`nodeValue`'s first landing), so no read goes unseen in dev.
+ */
+export declare function devRead(el: Signal<any> | Computed<any>): void;
 export declare function read<T>(el: Signal<T> | Computed<T>): T;
 /**
  * Rule 1, the one slow implementation (DESIGN-CONSOLIDATION move 3b, step

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

@@ -16,7 +16,7 @@ export interface DevHooks {
  * `warn`/`error` as failures unless they opt in to `info`.
  */
 export type DiagnosticSeverity = "info" | "warn" | "error";
-export type DiagnosticCode = "STRICT_READ_UNTRACKED" | "PENDING_ASYNC_UNTRACKED_READ" | "PENDING_ASYNC_FORBIDDEN_SCOPE" | "REACTIVE_WRITE_IN_OWNED_SCOPE" | "ASYNC_STORE_SETTER" | "STORE_WRITE_OUTSIDE_SETTER" | "ACTION_CALLED_IN_OWNED_SCOPE" | "RUN_WITH_DISPOSED_OWNER" | "NO_OWNER_CLEANUP" | "CLEANUP_IN_FORBIDDEN_SCOPE" | "SETTLED_CLEANUP_UNOWNED" | "ON_FLUSH_IN_OWNED_SCOPE" | "SETTLE_WALK_UNINITIALIZED_SOURCE" | "FLUSH_IN_EFFECT_CALLBACK" | "PRIMITIVE_IN_FORBIDDEN_SCOPE" | "PRIMITIVE_IN_EFFECT_CALLBACK" | "NO_OWNER_EFFECT" | "NO_OWNER_BOUNDARY" | "ASYNC_OUTSIDE_LOADING_BOUNDARY" | "LOADING_ON_OUTSIDE_HOLD" | "INVALID_REFRESH_TARGET" | "INVALID_AFFECTS_TARGET" | "MISSING_EFFECT_FN" | "SYNC_NODE_RECEIVED_ASYNC" | "UNTRACKED_READ_AFTER_AWAIT" | "REACTIVITY_HALTED" | "INVARIANT_VIOLATION" | "HUGE_FAN_OUT" | "HUGE_FAN_IN" | "GRAPH_GROWTH" | "HOT_SCOPE_RERUNS" | "HOT_SCOPE_TIME" | "WIDE_SCOPE_DEPS" | "UNSTABLE_MEMO_OUTPUT" | "WASTED_RECOMPUTE" | "ASYNC_WATERFALL" | "HOT_SCOPE_FANOUT" | "SILENT_HOLD" | "LONG_HOLD" | "UNTRACKED_ASYNC_HANDLER" | "ABANDONED_FLIGHTS" | "FALLBACK_FLASH" | "STACKED_HOLDS" | "OPTIMISTIC_REVERTED" | "EFFECT_WRITES_OWN_SOURCE" | "EFFECT_RELAY_TEAR" | "IMMUTABLE_UPDATE_IN_STORE" | "UNSTABLE_LIST_IDENTITY" | "SSR_RENDER_ERROR_CONTAINED" | "SSR_SUBTREE_ABANDONED" | "SSR_STREAM_ABANDONED" | "SSR_CLIENT_CONTENT_MASKED" | "LATE_HEADER_WRITE" | "SERVER_ERROR_SANITIZED" | "SSR_BOUNDARY_WATERFALL" | "SSR_UNDECLARED_LIVE_SOURCE" | "SSR_LIVE_HOLE_LATCHED" | "SERVER_WRITE" | "REVEAL_IN_RENDER_TO_STRING" | "LAZY_ASSET_UNMAPPED" | "PRELOAD_DESCRIPTOR_INVALID" | "HEAD_TAG_INVALID" | "UNRECOGNIZED_INSERT_VALUE" | "UNSCOPED_HOLE_ALLOCATED_IDS" | "LOWERCASE_EVENT_ATTRIBUTE" | "UNCOMMITTED_INPUT_OVERWRITTEN" | "FRAME_MARKER_CORRUPTED" | "DYNAMIC_ASYNC_COMPONENT" | "ASYNC_MEMO_ELEMENT";
+export type DiagnosticCode = "STRICT_READ_UNTRACKED" | "PENDING_ASYNC_UNTRACKED_READ" | "PENDING_ASYNC_FORBIDDEN_SCOPE" | "REACTIVE_WRITE_IN_OWNED_SCOPE" | "ASYNC_STORE_SETTER" | "STORE_WRITE_OUTSIDE_SETTER" | "ACTION_CALLED_IN_OWNED_SCOPE" | "RUN_WITH_DISPOSED_OWNER" | "NO_OWNER_CLEANUP" | "CLEANUP_IN_FORBIDDEN_SCOPE" | "SETTLED_CLEANUP_UNOWNED" | "ON_FLUSH_IN_OWNED_SCOPE" | "SETTLE_WALK_UNINITIALIZED_SOURCE" | "FLUSH_IN_EFFECT_CALLBACK" | "PRIMITIVE_IN_FORBIDDEN_SCOPE" | "PRIMITIVE_IN_EFFECT_CALLBACK" | "NO_OWNER_EFFECT" | "NO_OWNER_BOUNDARY" | "ASYNC_OUTSIDE_LOADING_BOUNDARY" | "LOADING_ON_OUTSIDE_HOLD" | "LOADING_ON_ACCESSOR" | "INVALID_REFRESH_TARGET" | "INVALID_AFFECTS_TARGET" | "MISSING_EFFECT_FN" | "SYNC_NODE_RECEIVED_ASYNC" | "UNTRACKED_READ_AFTER_AWAIT" | "REACTIVITY_HALTED" | "INVARIANT_VIOLATION" | "HUGE_FAN_OUT" | "HUGE_FAN_IN" | "GRAPH_GROWTH" | "HOT_SCOPE_RERUNS" | "HOT_SCOPE_TIME" | "WIDE_SCOPE_DEPS" | "UNSTABLE_MEMO_OUTPUT" | "WASTED_RECOMPUTE" | "ASYNC_WATERFALL" | "HOT_SCOPE_FANOUT" | "SILENT_HOLD" | "LONG_HOLD" | "UNTRACKED_ASYNC_HANDLER" | "ABANDONED_FLIGHTS" | "FALLBACK_FLASH" | "STACKED_HOLDS" | "OPTIMISTIC_REVERTED" | "EFFECT_WRITES_OWN_SOURCE" | "EFFECT_RELAY_TEAR" | "IMMUTABLE_UPDATE_IN_STORE" | "UNSTABLE_LIST_IDENTITY" | "SSR_RENDER_ERROR_CONTAINED" | "SSR_SUBTREE_ABANDONED" | "SSR_STREAM_ABANDONED" | "SSR_CLIENT_CONTENT_MASKED" | "LATE_HEADER_WRITE" | "SERVER_ERROR_SANITIZED" | "SSR_BOUNDARY_WATERFALL" | "SSR_UNDECLARED_LIVE_SOURCE" | "SSR_LIVE_HOLE_LATCHED" | "SERVER_WRITE" | "REVEAL_IN_RENDER_TO_STRING" | "LAZY_ASSET_UNMAPPED" | "PRELOAD_DESCRIPTOR_INVALID" | "HEAD_TAG_INVALID" | "UNRECOGNIZED_INSERT_VALUE" | "UNSCOPED_HOLE_ALLOCATED_IDS" | "LOWERCASE_EVENT_ATTRIBUTE" | "UNCOMMITTED_INPUT_OVERWRITTEN" | "FRAME_MARKER_CORRUPTED" | "DYNAMIC_ASYNC_COMPONENT" | "ASYNC_MEMO_ELEMENT";
 export type DiagnosticKind = "strict-read" | "async" | "write" | "lifecycle" | "owner" | "error" | "perf" | "graph"
 /** Perceived responsiveness: the runtime behaved correctly but the user saw no feedback. */
  | "responsiveness"

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

@@ -3,7 +3,8 @@ import { type Transaction } from "./scheduler.js";
 import type { Computed, Signal } from "./types.js";
 export { laneValueOf };
 /** What the screen shows for a lane's node: the lane's value once the lane
- * has revealed, the committed truth before. */
+ * has revealed, the committed truth before — NOT_PENDING when there is none
+ * (uninitialized, as `laneValueOf`): its read throws NotReady. */
 export declare function display(el: Signal<any> | Computed<any>): unknown;
 /** What the writer sees of a node: an unflushed guess to it, else the
  * lane's value or the committed one — what an optimistic updater composes
@@ -11,6 +12,12 @@ export declare function display(el: Signal<any> | Computed<any>): unknown;
 export declare function guessedValueOf<T>(n: Signal<T> | Computed<T>): T;
 /** The unflushed guess to `n`, else NOT_PENDING. */
 export declare function pendingGuessOf(n: Signal<any> | Computed<any>): unknown;
+/** Lane `l` takes `n`'s guess (another action's), kept to come back if `l`
+ * reverts. Its readers saw the guess: they re-derive at the lane's reveal
+ * (and, a flight's, hold the lane while they would show it). `d`: a guess
+ * `l` takes without writing it (a store target's other slots) — the node
+ * shows its truth in `l`'s world until the guess comes back. */
+export declare function take(n: Signal<any>, l: Transaction, d?: boolean): void;
 export declare function optimisticWrite<T>(n: Signal<T> | Computed<T>, v: T | ((prev: T) => T)): T;
 /** The running pass read lane `l`'s work as a derivation: it is `l`'s — or,
  * already another lane's, the frame it computes derives from both guesses

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

@@ -6,11 +6,22 @@ export declare let laneStageHook: ((el: Computed<any>, l: Transaction, create: b
 export declare let laneOutcomeHook: ((el: Computed<any>, value: unknown, errored: boolean) => boolean) | null;
 export declare let laneWriteHook: (<T>(el: Signal<T> | Computed<T>, v: T) => T) | null;
 export declare let applyGuessesHook: ((parent: Transaction | null) => void) | null;
-export declare let laneSeamsHook: ((leaks: Computed<any>[] | null) => void) | null;
+export declare let laneSeamsHook: ((t: Transaction | null) => void) | null;
 export declare let laneCorrectionsHook: (() => boolean) | null;
 export declare let endLanesHook: ((u: Transaction) => void) | null;
 export declare let lanesBlockedHook: ((t: Transaction) => boolean) | null;
-export declare function installLaneHooks(read: NonNullable<typeof laneReadHook>, stage: NonNullable<typeof laneStageHook>, outcome: NonNullable<typeof laneOutcomeHook>, write: NonNullable<typeof laneWriteHook>, applyGuesses: NonNullable<typeof applyGuessesHook>, seams: NonNullable<typeof laneSeamsHook>, corrections: NonNullable<typeof laneCorrectionsHook>, end: NonNullable<typeof endLanesHook>, blocked: NonNullable<typeof lanesBlockedHook>): void;
+/** R5 (lanes.ts `laneSeams` parks a frame flight): the landing's re-derive
+ * of a reader adopts the flight instead (true: adopted, nothing to queue). */
+export declare let laneAdoptHook: ((r: Computed<any>) => boolean) | null;
+/** core.ts `frameRead` served lane work or a verdict reader a held node's
+ * committed value (lanes.ts `laneServed`). */
+export declare let laneServedHook: ((c: Computed<any>, el: Signal<any> | Computed<any>) => void) | null;
+/** A guess was written (lanes.ts `optimisticWrite`): the arms only a guess
+ * reaches (CONFIG_GUESS) — a build without `createOptimistic` or
+ * `createOptimisticStore` never sets it, and its bundler folds them. */
+export declare let guessing: boolean;
+export declare function armGuessing(): void;
+export declare function installLaneHooks(read: NonNullable<typeof laneReadHook>, stage: NonNullable<typeof laneStageHook>, outcome: NonNullable<typeof laneOutcomeHook>, write: NonNullable<typeof laneWriteHook>, applyGuesses: NonNullable<typeof applyGuessesHook>, seams: NonNullable<typeof laneSeamsHook>, corrections: NonNullable<typeof laneCorrectionsHook>, end: NonNullable<typeof endLanesHook>, blocked: NonNullable<typeof lanesBlockedHook>, adopt: NonNullable<typeof laneAdoptHook>, served: NonNullable<typeof laneServedHook>): void;
 export declare let catchHook: ((node: Computed<any>, flags: number, error: unknown) => unknown) | null;
 export declare let freshHook: ((node: Computed<any>, held?: unknown) => unknown) | null;
 export declare let hiddenHook: ((r: Computed<any>) => unknown) | null;
@@ -33,7 +44,10 @@ export declare let releaseAmbientMarksHook: ((parked: Transaction | null) => voi
 export declare function installMarkHooks(release: NonNullable<typeof releaseMarksHook>, releaseAmbient: NonNullable<typeof releaseAmbientMarksHook>): void;
 /** Verdicts (verdict.ts). */
 export declare let observeFlightHook: ((c: Computed<any>, el: Computed<any>) => boolean) | null;
-export declare function installVerdictHooks(observeFlight: NonNullable<typeof observeFlightHook>): void;
+/** D-25's hold work (verdict.ts `holdWork`): on `source` going pending,
+ * whether verdict reader `n` waits on it instead of re-deriving. */
+export declare let holdWorkHook: ((n: Computed<any>, source: Computed<any>) => unknown) | null;
+export declare function installVerdictHooks(observeFlight: NonNullable<typeof observeFlightHook>, holdWork: NonNullable<typeof holdWorkHook>): void;
 /** External-source bridge (wired by enableExternalSource(); undefined while
  * no config is active — including after _resetExternalSourceConfig()). */
 export declare let wireExternalSourceHook: ((self: Computed<any>) => void) | undefined;
@@ -106,6 +120,11 @@ export declare function setPassLane(l: Transaction | null): void;
  * schedules the seam that consumes it: membership is the tick's — the same
  * synchronous frame — and the next tick's writes are not this one's. */
 export declare let flushTransaction: Transaction | null;
+/** The flush's transaction while only a `latest()` read of a staging opened
+ * it (verdict.ts `provisionalVerdict`): it holds nothing, and a verdict
+ * reader's plain read of a staging in it is the frame's read (D-22). */
+export declare let latestOpened: Transaction | null;
+export declare function openedByLatest(): void;
 /** The transaction the passes running OUTSIDE a flush this tick derive from
  * (a mainline mount, a mainline re-pass): the passes' own (A29, creation-
  * time form — "the entry is the pass's alone"): their results are staged
@@ -258,6 +277,11 @@ export declare class GlobalQueue implements IQueue {
     static _runEffect: (el: Computed<unknown>) => void;
     /** A slot node's truth is in flight (its family's derive — store/store.ts). */
     static _slotFlight: ((n: Signal<any>) => boolean) | undefined;
+    /** A write to a slot node's guess (lanes.ts `laneWrite`): true when the
+     * store made the slot its derive's lane's derivation (optimistic.ts);
+     * `back`: the slot's node now, for a guess that comes back (lanes.ts
+     * `endLanes`). */
+    static _slotTake: ((n: Signal<any>, back?: boolean) => any) | undefined;
     /** The value a slot node's guess covered: its committed value — a chained
      * link's refreshed from the inner store, whose commits it never learned
      * while the guess served the reads (store/store.ts, §7b). */
@@ -353,7 +377,15 @@ export declare function insertSubs(node: Signal<any> | Computed<any>): void;
  * inert for its pass (`recompute` seats a lane only from its own `_x`), it
  * is a live write if the effect becomes a zombie later this flush — an
  * on-screen reader whose removal an adopted write stages follows the lane
- * (the lane-membership ruling, 2026-10-05; `_update`). */
+ * (the lane-membership ruling, 2026-10-05; `_update`).
+ *
+ * A render effect re-run by a verdict memo's change (`createMemo(() =>
+ * latest(x))`, CONFIG_VERDICT) is the verdict reader the same read inline
+ * makes it, for that pass (F-6; D-26 `[s(), L()]`, #4284): a frame reader
+ * of its other reads — a staging's screen, a flight's committed value. One
+ * an earlier propagation this flush seated in another lane leaves that
+ * seat: its pass starts from the frame's, as the inline effect's does, and
+ * `laneRead` re-derives it on the screen if that lane holds (`entered`). */
 export declare function laneDirty(node: Signal<any> | Computed<any>, l: Transaction): void;
 /** One lane, or two of one link group (#3335): one reveal unit. */
 export declare function sameLane(a: Transaction, b: Transaction): boolean;

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

@@ -2,7 +2,9 @@ import type { Transaction } from "./scheduler.js";
 import type { Computed, Signal } from "./types.js";
 /** A lane node's current value: its guess, or the latest it derived — the
  * staging a shown lane holds for its next reveal, else its slot; the
- * committed value while it has none (its first lane pass in flight). */
+ * committed value while it has none (its first lane pass in flight) —
+ * NOT_PENDING for a node with no committed value either (born in the lane,
+ * uninitialized: its reads throw NotReady, A7; #4363). */
 export declare function laneValueOf(el: Signal<any> | Computed<any>): unknown;
 /** Truth readers (`until`, `refresh`; CONFIG_AUTHORITATIVE) — pay-for-use:
  * the first one installs these on GlobalQueue (signals.ts `watch`).

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

@@ -120,6 +120,12 @@ export interface NodeExtension {
      * 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;
+    /** R5: the frame pass's flight of a `latest()`/`isPending()` reader the
+     * seam re-derived in the verdict lane (lanes.ts `laneSeams`) — the
+     * frame's answer to the question it asked, which the transaction's
+     * landing adopts instead of asking it again (lanes.ts `adoptParked`, F-9). Cleared
+     * by any later pass. */
+    _parked?: PromiseLike<any>;
 }
 export interface RawSignal<T> {
     _subs: Link | null;

package/dist/types/index.d.ts

@@ -7,6 +7,8 @@ export { $REFRESH, action, ContextNotFoundError, NoOwnerError, NotReadyError, Ti
 export { setConsoleFooter } from "./core/index.js";
 /** @internal The flush round counter (scheduler.ts): hydration's served pass tells its own round from a later one. */
 export { clock } from "./core/index.js";
+/** @internal Dev duplicate-copy check: solid-js marks components and context reads. */
+export { runAsSolidCopy, checkForeignOwnerless } from "./core/copies.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";

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

@@ -5,8 +5,9 @@
  * 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 { Transaction } from "../core/scheduler.js";
 import type { Signal } from "../core/types.js";
-import type { StoreTarget } from "./target.js";
+import type { StoreFamily, 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`
@@ -33,6 +34,19 @@ export interface OptHooks {
     /** 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;
+    /** The derive's draft wrote `pb` on `t`: the new object at a guessed
+     * row's slot (by key in a keyed list) is adopted by that row's target. */
+    pair(t: StoreTarget, pb: Record<PropertyKey, any>): void;
+    /** The derive of `fam` went in flight (#4336): a new question asked over
+     * the family's guesses is judged by its reads (`stands`) and at the seam
+     * (`park`). */
+    ask(fam: StoreFamily): void;
+    /** The flush parks with `t`: a guess a frame still reads, over a family
+     * asked a new question this flush, holds `t` with its action (D-34). */
+    park(t: Transaction): void;
+    /** A read of `t` while its family's derive is in flight: the family's
+     * guesses stand in for the flight (no suspension). */
+    stands(t: StoreTarget): boolean;
 }
 export declare let optHooks: OptHooks | null;
 export declare function installOptHooks(hooks: OptHooks): void;

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

@@ -87,7 +87,8 @@ export declare function notifyKeyValue(node: Signal<any>, key: PropertyKey, ov:
  * unrelated `a.value` stayed stale until the action settled). A real
  * change still writes, and on a held node still proposes. A live chained
  * `old` (a store proxy, §7b) reflects the inner store, not what the node
- * was last told — written unconditionally, as before.
+ * was last told — written unconditionally, as before; its container too
+ * (#4361).
  *
  * The container is told of an arrangement change when it has structural
  * subscribers OR carries an arrangement guess (S4): for a guessed

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

@@ -25,6 +25,11 @@ export interface StoreFamily {
     /** Targets carrying a lane value on one of their nodes (reads compose the
      * view over the truth — optimistic.ts); dropped lazily once none is. */
     overlaid?: Set<StoreTarget>;
+    /** The derive asked a new question over the family's guesses, stamped
+     * with that flush's clock (#4336, optimistic.ts `ask`): `clock + 1` from
+     * mainline over a live guess, `~clock` otherwise (a lane's work over no
+     * guess of its own, or no live guess left). */
+    asked?: number;
     /** Normalized row-key fn (`options.key`, "id" default, null = unkeyed). */
     key?: ((item: any) => any) | null;
     map: WeakMap<object, StoreTarget>;

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

@@ -96,3 +96,10 @@ export declare function isWrappable<T>(obj: T | NotWrappable): obj is T;
 export declare function ownEnumerableKeys(o: object): (string | symbol)[];
 export declare let writeOverride: boolean;
 export declare function setWriteOverride(value: boolean): void;
+/** The list driver's view of a shallow store (map.ts): the backing a read of
+ * every slot serves this reader, or `undefined` when the list is no shallow
+ * store or a slot read could differ from it. Installed by store.ts's top
+ * level, so a `<For>` in an app without stores carries none of it; it lives
+ * beside `$TRACK` so map.ts reaches no other store module. */
+export declare let shallowView: ((t: any) => any[] | undefined) | null;
+export declare function installShallowView(view: (t: any) => any[] | undefined): void;

package/package.json

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