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

package/dist/types/affects-marks.d.ts

@@ -0,0 +1,14 @@
+import type { Computed, Signal } from "./core/types.js";
+export type Marked = Signal<any> | Computed<any>;
+/** The verdict readers downstream of `node` — through derivations, stopping
+ * at effects — re-derive: the mark's one notification (a probe's answer
+ * changed with no value notifying anyone). Truth readers (`until`, the
+ * `refresh` waiter) too, which a lagging flight parked (deferred.ts) — but
+ * not through a derived store, whose leaves change only once its derive
+ * re-runs: they re-derive at that write. */
+export declare function repoll(node: Marked, seen?: Set<Computed<any>>, readers?: number): void;
+/** One mark on `node`. The declarer repolls once its bookkeeping is done. */
+export declare function mark(node: Marked): void;
+/** Drops one mark from `node`: true when it was the last — the node's
+ * verdict readers have re-derived. */
+export declare function unmark(node: Marked): boolean;

package/dist/types/boundaries.d.ts

@@ -27,7 +27,7 @@ interface Boundary {
      * whatever holds the frame; no LOADING_ON_OUTSIDE_HOLD report. */
     _ahead?: boolean;
     /** The output's last pass chose the fallback: readers under it are off
-     * screen (`hidden`). */
+     * screen (`hiddenBy`). */
     _fallback: boolean;
     /** User effects whose run came due behind the fallback: re-queued at the
      * reveal (`heldRun`). */
@@ -40,6 +40,10 @@ interface Boundary {
     _collapsed: boolean;
     _error: Signal<unknown> | null;
     _show: (b: Boundary) => unknown;
+    /** The fallback's own computed, in its own scope like `Show`'s function
+     * child: instantiated once per show and kept across the output's
+     * re-derives while it shows (#3991). */
+    _fb: Computed<unknown> | null;
 }
 /** Context key: the reveal controller a Loading boundary created here is a
  * slot of (reveal.ts); a boundary clears it for its content — only direct

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

@@ -11,7 +11,17 @@ export declare function addPendingSource(el: Computed<any>, source: Computed<any
 export declare function parkLoadingWindow(el: Computed<any>, e: NotReadyError): void;
 export declare function setPendingError(el: Computed<any>, source?: Computed<any>, error?: any): void;
 export declare function forEachDependent(el: Computed<any>, fn: (node: Computed<any>, link: Link) => void): void;
+export declare function releaseIfSettledUnobserved(node: Computed<any>): void;
 export declare function releaseSettledDependents(el: Computed<any>): void;
+/** D-41: an error a pass of a held node found is an answer of
+ * that frame — it ends the wait like a value and shows when a value would.
+ * Staged like one: `_pendingValue` carries it (CONFIG_STAGED_ERROR), readers
+ * in the hold derive from it (`serve` throws it), and the commit publishes
+ * it through the ordinary error path (`commitPendingNode` → `notifyStatus`),
+ * dependents included. Not for a lane pass, nor a node with no shown value
+ * (born held — its error has no frame to wait behind): those publish now,
+ * as before. Returns whether the error was staged. */
+export declare function stageError(el: Computed<any>, error: any, inPass?: boolean): boolean;
 export declare function settleErroredDependents(el: Computed<any>, error: any): void;
 export declare function settlePendingSource(el: Computed<any>, source?: Computed<any>): void;
 export declare function isThenable<T>(value: T | PromiseLike<T>): value is PromiseLike<T>;

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

@@ -502,9 +502,13 @@ export interface AttributionOptions {
     /**
      * Graph-growth warning: emit GRAPH_GROWTH when the live owner count at the
      * settle of the same route has climbed on `visits` consecutive visits
-     * (default 3) to `ratio` or more of the first (default 1.25) — a root or a
+     * (default 3) to `ratio` or more of the first (default 1.25), and so has
+     * the part of it that outlived each of those navigations — a root or a
      * subscription each visit leaves behind, the leak class a heap snapshot
-     * finds. The count is a walk at settle, never per node. `false` disables.
+     * finds, not content a visit owns and leaving disposes. The count is a walk
+     * when a navigation opens and at its settle, never per node. Navigations
+     * that stay on a route pattern continue its visit and are not compared.
+     * `false` disables.
      */
     graphGrowth?: {
         visits: number;

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
@@ -111,6 +116,9 @@ export declare const CONFIG_SLOT_NODE: number;
  * leaf twin of REACTIVE_MANUAL_WRITE). Set by the user setter, cleared by
  * the derive's own write to the key. */
 export declare const CONFIG_MANUAL_WRITE: number;
+/** D-41: the staged value in `_pendingValue` is an error — an
+ * answer of the held frame, published at its landing like a value. */
+export declare const CONFIG_STAGED_ERROR: number;
 /** Lanes — the node carries a written guess (`optimisticWrite`): its own
  * source recomputing it, or a plain write landing on it, is the truth
  * (`supersede`). A lane's derived staging is not. */
@@ -119,7 +127,9 @@ export declare const CONFIG_GUESS: number;
  * pending is a question for its next pass — the verdict changed — so the
  * propagation re-derives it instead of marking it pending (as a kept-tail
  * link does, A30). Set at the window, never cleared: a reader that stopped
- * asking re-derives once and goes pending through its own read. */
+ * asking re-derives once and goes pending through its own read. The same
+ * bit as REACTIVE_PROBED: a pass's probe (or a read of a verdict memo,
+ * core.ts `read`) carries into the config at its end without a shift. */
 export declare const CONFIG_VERDICT: number;
 /** A dependency's status is a question for this node's pass, not a fact
  * about its current one: the propagation re-derives it instead of marking
@@ -128,6 +138,10 @@ export declare const CONFIG_VERDICT: number;
  * promise over an expression (`resolve`/`until`, signals.ts: the pass reads
  * the error and rejects, or re-asks a pending source). */
 export declare const CONFIG_REDERIVE: number;
+/** An answered `createDeferred` node (deferred.ts): held because a
+ * downstream hold staged its landing, its re-pass is a lagging question,
+ * not an answer, and joins no transaction (D-40). */
+export declare const CONFIG_LAGS: number;
 /** The reader wants the truth, not the lane's guess (`until`, signals.ts):
  * a read of displayed optimism serves the base the guess covers, makes the
  * pass no lane's, and the truth landing wakes it even when it confirms the
@@ -175,6 +189,9 @@ export declare const STATUS_NONE = 0;
 export declare const STATUS_PENDING: number;
 export declare const STATUS_ERROR: number;
 export declare const STATUS_UNINITIALIZED: number;
+/** `catchHook`'s answer when the catcher is a boundary re-armed by
+ * `on` (truthy, as any catch): what it collects is its own, not the hold's. */
+export declare const CAUGHT_REARMED = 2;
 export declare const EFFECT_PURE = 0;
 export declare const EFFECT_RENDER = 1;
 export declare const EFFECT_USER = 2;

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
@@ -64,7 +83,8 @@ export declare function isEqual<T>(a: T, b: T): boolean;
  * object, no NodeExtension, no post-construction expandos. `ownedWrite` is
  * baked in: the setter carries the owned-scope guard; node-level writes are
  * the store's notification machinery. The observe literal adds the label
- * slot (the store relabels it `store.<key>` when the engine is installed). */
+ * and location slots (the store relabels `store.<key>` and stamps the
+ * store's `loc` when the engine is installed). */
 export declare function slotSignal<T>(v: T, equals: (a: T, b: T) => boolean, host: object, key: PropertyKey, acc: boolean): Signal<T>;
 /**
  * When set to a component name string, any reactive read that is not inside a nested tracking
@@ -91,7 +111,11 @@ export declare function enterCallback(): void;
 export declare function exitCallback(): void;
 /**
  * Dev-only: > 0 while owner teardown runs cleanups (`_disposal` entries and
- * effect-returned cleanups — owner.ts), for the same reason. Kept apart from
+ * effect-returned cleanups — owner.ts), for the same reason. The owned-scope
+ * write guard (setSignal, markRefresh, the store setter) stands down here
+ * too: a cleanup is teardown, not part of whichever computation is disposing
+ * its owner (a list pass removing a row, a branch switching away), so its
+ * writes are imperative like an effect callback's (#4165). Kept apart from
  * `callbackDepth` because its sites cannot use try/finally (the frame would
  * survive into prod): a throwing cleanup leaves it raised, and dev.ts resets
  * it on the next microtask, which teardown — synchronous — never spans.
@@ -108,6 +132,16 @@ export declare function setStrictRead(v: string | false): string | false;
  * Use `untrack` inside a memo or effect when you need to read a signal once
  * without making the surrounding computation depend on its future changes.
  *
+ * `untrack` stops dependency tracking, not async settlement. Reading an
+ * uninitialized async source still suspends the owning computation; it runs
+ * again when that source first resolves. Afterward, the untracked read is a
+ * snapshot and does not subscribe the computation to later changes.
+ *
+ * If the first read must return immediately, give the async source a
+ * `loadingValue` before reading it with `untrack`. `isPending` and `latest`
+ * inspect updates to an existing value; neither supplies a missing initial
+ * value.
+ *
  * Pass a `strictReadLabel` string to enable a dev-mode warning: any reactive
  * read inside `fn` that isn't inside a nested tracking scope will log a
  * warning naming the label.
@@ -121,6 +155,9 @@ export declare function setStrictRead(v: string | false): string | false;
  *     log(snapshot);
  *   }
  * );
+ *
+ * const color = createMemo<string>(() => fetchColor(), { loadingValue: "gray" });
+ * const initialColor = untrack(color); // "gray" while the fetch is unresolved
  * ```
  */
 export declare function untrack<T>(fn: () => T, strictReadLabel?: string | false): T;
@@ -209,8 +246,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 +257,47 @@ 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;
+/**
+ * A callback run before every signal or store write lands, while set, with
+ * the written signal or the store proxy whose setter runs. The
+ * server-components client sets it while slot occurrences are left
+ * unmounted after hydration (deferred hydration): a write may be one an
+ * unmounted component would have observed, so the client mounts what is
+ * left before the write applies, and clears the hook. `null` otherwise.
+ */
+export declare let writeHook: ((node?: object) => void) | null;
+/** @internal */
+export declare function setWriteHook(hook: ((node?: object) => void) | null): void;
+/**
+ * `el`'s comparator verdict (`_equals`), the one guarded call for recompute,
+ * setSignal (user setters and async landings) and the seam's
+ * staged-equals-committed check.
+ * - A comparator that read an unresolved async source has not shown the
+ *   values equal (#4111): falsy, a change, whose readers suspend in their own
+ *   tracked context.
+ * - Any other throw is an error of `el`'s computation (A3, #2837): routed
+ *   through the status path so error boundaries contain it, instead of
+ *   unwinding a flush or a setter; answered "same" so nothing commits.
+ * @internal
+ */
+export declare function isSame(el: Signal<any>, a: unknown, b: unknown): unknown;
 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/dev.d.ts

@@ -6,6 +6,8 @@ export interface DevHooks {
     onGraph?: (value: any, owner: Owner | null) => void;
     onUpdate?: () => void;
     onStoreNodeUpdate?: (state: any, property: PropertyKey, value: any, prev: any) => void;
+    /** @internal Every node read (the frames client's identity-drift check; `setReadWatch`). */
+    onRead?: (node: object) => void;
 }
 /**
  * `info` is the advisory tier: a structural fact worth surfacing that is not
@@ -14,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" | "ACTION_CALLED_IN_OWNED_SCOPE" | "RUN_WITH_DISPOSED_OWNER" | "NO_OWNER_CLEANUP" | "CLEANUP_IN_FORBIDDEN_SCOPE" | "SETTLED_CLEANUP_UNOWNED" | "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" | "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" | "BINDING_SLOT_POSITION" | "FRAME_MARKER_CORRUPTED" | "DYNAMIC_ASYNC_COMPONENT";
+export type DiagnosticCode = "STRICT_READ_UNTRACKED" | "PENDING_ASYNC_UNTRACKED_READ" | "PENDING_ASYNC_FORBIDDEN_SCOPE" | "REACTIVE_WRITE_IN_OWNED_SCOPE" | "ASYNC_STORE_SETTER" | "ACTION_CALLED_IN_OWNED_SCOPE" | "RUN_WITH_DISPOSED_OWNER" | "NO_OWNER_CLEANUP" | "CLEANUP_IN_FORBIDDEN_SCOPE" | "SETTLED_CLEANUP_UNOWNED" | "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" | "FRAME_MARKER_CORRUPTED" | "DYNAMIC_ASYNC_COMPONENT";
 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"
@@ -46,6 +48,15 @@ export interface DiagnosticEvent {
      * is usually the finding itself).
      */
     ownerPath?: string[];
+    /**
+     * Source location of the innermost located node enclosing the subject
+     * (`file:line:col`, root-relative — the compiler's `sourceNames`
+     * `locations` kind): the subject's own `loc`, else the nearest owner's up
+     * the chain (a component root carries its JSX site). Absent when nothing
+     * on the chain was compiled with locations. A host event that sets it
+     * keeps it.
+     */
+    loc?: string;
     data?: Record<string, unknown>;
 }
 /**
@@ -117,6 +128,21 @@ export interface AttributionSlot {
      * navigation it ran for by the identity of the object, not by time.
      */
     currentOrigin(): ChangeOrigin | undefined;
+    /**
+     * Stamps a flight (a promise or async iterable a computation will await)
+     * with when its work really started, before anything reads it. A route
+     * preloader, query cache or `lazy()` calls this on what it hands out (on
+     * the wrapper it mints, with the original kickoff time), so a reader that
+     * meets it later is judged against the real start: work already running
+     * when the previous wait landed is parallel, not a waterfall link. The
+     * client engine's `ASYNC_WATERFALL` and the server's
+     * `SSR_BOUNDARY_WATERFALL` both read these stamps. Earliest wins. Works
+     * with no engine installed. `startedAt` is on the `performance.now()`
+     * clock and defaults to now.
+     */
+    markFlight(flight: object, startedAt?: number): void;
+    /** The earliest start `markFlight` declared for `flight`, if any. */
+    flightOrigin(flight: object): number | undefined;
 }
 /**
  * The records delivered on `OBSERVE.records`, by type — each entry
@@ -386,12 +412,14 @@ export interface Dev {
     /** Console face of an emitted event — see `reportDiagnostic`. */
     report(entry: DiagnosticEvent): void;
     /**
-     * The stable URL of `code`'s section in the repair guide — the
-     * `reactivity-diagnostics` skill shipped with `solid-js`, one section per
-     * code. The one place the URL is built: the console footer prints it and
-     * the performance tracks' Insights link (`learnMoreUrl`) reads it, so both
-     * name the same section. Dev-tier: it is guidance for a developer, and a
-     * URL string on a retained object is a cost every observe build would pay.
+     * The URL of `code`'s page in the docs — what the finding means and how
+     * to fix it, one page per code
+     * (`https://v2.solidjs.com/reference/solid-js/diagnostics/<slug>`, slug =
+     * the code lowercased with `-` for `_`). The one place the URL is built:
+     * the console footer prints it and the performance tracks' Insights link
+     * (`learnMoreUrl`) reads it, so both name the same page. Dev-tier: it is
+     * guidance for a developer, and a URL string on a retained object is a
+     * cost every observe build would pay.
      */
     guideUrl(code: DiagnosticCode): string;
 }
@@ -439,17 +467,19 @@ export declare function ownerPath(subject: DiagnosticSubject | null | undefined)
  * default (right for the synchronous rule checks — they fire inside the
  * scope that misbehaved); pass the node for scheduler-time findings whose
  * ambient context is the flush, or `null` for events that have no location
- * by nature. An `ownerPath` already on the event wins over the subject walk
- * (hosts whose owners are not signals' owners compute their own). Console
- * output is a separate, dev-tier step — see `reportDiagnostic`.
+ * by nature. An `ownerPath` (or `loc`) already on the event wins over the
+ * subject walk (hosts whose owners are not signals' owners compute their
+ * own). Console output is a separate, dev-tier step — see `reportDiagnostic`.
  */
 export declare function emitDiagnostic(event: Omit<DiagnosticEvent, "sequence">, subject?: DiagnosticSubject | null | undefined): DiagnosticEvent;
 /**
  * The console face of a diagnostic — ONE entry per finding: the message, the
  * owner path (`in <App> › <TodoRow> › effect`) so a human can locate it, the
- * once-per-code footer as trailing lines, and — when the subject is a
- * binding effect the rendering runtime tagged — the element it writes, as a
- * second console argument (hover highlights it, click jumps to Elements).
+ * source location (`at src/App.tsx:18:3` — see `locationLine`) when a node on
+ * the chain was compiled with one, the once-per-code footer as trailing
+ * lines, and — when the subject is a binding effect the rendering runtime
+ * tagged — the element it writes, as a second console argument (hover
+ * highlights it, click jumps to Elements).
  * Severity picks the console method. Call sites report the entry
  * `emitDiagnostic` returned so the structured and console channels never
  * disagree. Dev-tier: in an observe build this is a no-op, so wiring paths

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

@@ -8,6 +8,17 @@ export declare function setSlotUnobserved(fn: (node: Signal<any>) => void): void
 export declare function unlinkSubs(link: Link): Link | null;
 export declare function trimStaleDeps(el: Computed<any>): void;
 export declare function clearDeps(el: Computed<unknown>): void;
+/**
+ * Last-one-out releases held back while a pass tears down the frame of an
+ * earlier pass that never committed (#4142). The pass is about to rebuild
+ * the same children, which read the same lazy nodes again. Released on the
+ * spot, a lazy async memo whose only reader was the old frame's child memo
+ * was torn down, re-ran on the new child's read, went pending, and the cycle
+ * repeated forever. `recompute` collects them around that teardown and
+ * releases what is still unobserved when the pass ends.
+ */
+export declare let deferredReleases: Computed<any>[] | null;
+export declare const deferReleases: (list: Computed<any>[] | null) => Computed<any>[] | null;
 export declare function unobserved(el: Computed<unknown>): void;
 /**
  * Deferred dormancy for never-observed auto-dispose computeds (#3078).

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

@@ -0,0 +1,17 @@
+/** @internal The identity of a plain signal named while identities were on. */
+export declare function signalName(node: object | undefined): string | undefined;
+/** @internal Name plain signals from now on (`on`), or stop. */
+export declare function setSignalIdentities(on: boolean): void;
+/**
+ * @internal Called with every plain signal `createSignal` makes, and every
+ * plain store root `createStore` makes, while set (the namer above). Never
+ * set unless `setSignalIdentities` is imported, so a bundle without it keeps
+ * only a null check.
+ */
+export declare let signalHook: ((node: object) => void) | null;
+/**
+ * @internal Dev only: `watch` is called with every node read while set (the
+ * dev hook `onRead`) — the frames client's identity-drift check watches the
+ * named signals a deferred occurrence reads as it mounts. A no-op in prod.
+ */
+export declare function setReadWatch(watch: ((node: object) => void) | null): void;

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

@@ -1,9 +1,10 @@
 export { ContextNotFoundError, NoOwnerError, NotReadyError, TimeoutError } from "./error.js";
 export { isPending, latest } from "./verdict.js";
 export { action } from "./action.js";
-export { isEqual, untrack, runWithOwner, computed, signal, read, setSignal, setMemo, markRefresh, staleValues, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots } from "./core.js";
+export { isEqual, untrack, runWithOwner, computed, signal, read, setSignal, setWriteHook, setMemo, markRefresh, staleValues, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots } from "./core.js";
 export { enableExternalSource, _resetExternalSourceConfig, type ExternalSourceFactory, type ExternalSource, type ExternalSourceConfig } from "./external.js";
 export { createOwner, createRoot, dispose, getNextChildId, getObserver, getOwner, isDisposed, cleanup, peekNextChildId } from "./owner.js";
+export { setSignalIdentities, signalName, signalHook, setReadWatch } from "./identities.js";
 export { createContext, getContext, setContext, type Context, type ContextRecord } from "./context.js";
 export { handleAsync } from "./async.js";
 export type { Computed, Disposable, Link, Owner, Root, Signal, NodeOptions } from "./types.js";

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

@@ -1,9 +1,7 @@
+import { laneValueOf } from "./truth.js";
 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). */
-export declare function laneValueOf(el: Signal<any> | Computed<any>): unknown;
+export { laneValueOf };
 /** What the screen shows for a lane's node: the lane's value once the lane
  * has revealed, the committed truth before. */
 export declare function display(el: Signal<any> | Computed<any>): unknown;

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

@@ -63,9 +63,11 @@ export declare function getOwner(): Owner | null;
 /**
  * Low-level: registers `fn` as a disposal callback on the current owner.
  * Most code should use `onCleanup()` from `solid-js`, which adds dev-mode
- * checks. `cleanup()` is the unchecked primitive used by internals.
+ * checks. `cleanup()` is the unchecked primitive used by internals; `owner`
+ * (internal) targets a specific owner's disposal list instead of the ambient
+ * one.
  */
-export declare function cleanup(fn: Disposable): Disposable;
+export declare function cleanup(fn: Disposable, owner?: Owner | null): Disposable;
 /**
  * Returns `true` if the owner has been disposed. Pair with a captured owner
  * to bail out of late callbacks whose surrounding component already
@@ -128,7 +130,7 @@ export declare function createOwner(options?: {
  * const detached = runWithOwner(null, () => createRoot(d => d));
  * ```
  *
- * @description https://docs.solidjs.com/reference/reactive-utilities/create-root
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/owner-introspection/create-root
  */
 export declare function createRoot<T>(init: ((dispose: () => void) => T) | (() => T), options?: {
     id?: string;

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

@@ -1,5 +1,43 @@
 import { type Heap } from "./heap.js";
-import type { Computed, Signal } from "./types.js";
+import type { Computed, Owner, Signal } from "./types.js";
+export declare let laneReadHook: ((c: Computed<any> | null, el: Signal<any> | Computed<any>) => unknown) | null;
+export declare let laneStageHook: ((el: Computed<any>, l: Transaction, create: boolean, errored: boolean | Computed<any>) => boolean) | null;
+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 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;
+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;
+export declare let boundarySeamHook: (() => void) | null;
+export declare let heldRunHook: ((node: Computed<any>) => boolean) | null;
+export declare function installBoundaryHooks(caught: NonNullable<typeof catchHook>, fresh: NonNullable<typeof freshHook>, hidden: NonNullable<typeof hiddenHook>, seam: NonNullable<typeof boundarySeamHook>, heldRun: NonNullable<typeof heldRunHook>): void;
+/** Store (store/store.ts): `park` — the flush parked into `t`: the store
+ * materializes and holds the container node of every staging that had none
+ * (a staging needs the node as its home only when something can read the
+ * frame through it; a hold can); `commit` — fold the pending backings whose
+ * container nodes this flush committed (the owned-raw model's one mutation
+ * point). */
+export declare let storeParkHook: ((t: Transaction) => void) | null;
+export declare let storeCommitHook: (() => void) | null;
+export declare function installStoreHooks(park: NonNullable<typeof storeParkHook>, commit: NonNullable<typeof storeCommitHook>): void;
+/** `affects()` marks (affects.ts): the releases at a landing and at the seam
+ * (ambient marks). */
+export declare let releaseMarksHook: ((nodes: Signal<any>[]) => void) | null;
+export declare let releaseAmbientMarksHook: ((parked: Transaction | null) => void) | null;
+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;
+/** External-source bridge (wired by enableExternalSource(); undefined while
+ * no config is active — including after _resetExternalSourceConfig()). */
+export declare let wireExternalSourceHook: ((self: Computed<any>) => void) | undefined;
+export declare let externalUntrackHook: (<T>(fn: () => T) => T) | undefined;
+export declare function setExternalHooks(wire: typeof wireExternalSourceHook, untrack: typeof externalUntrackHook): void;
 export interface Transaction {
     /** Held staged nodes: committed at the landing. For a lane: its guesses
      * and its work (their lane values in `_x._lane`), revealed at the seam. */
@@ -123,6 +161,11 @@ export declare function holdNode(n: Signal<any>, t: Transaction): void;
  * transaction whose `_nodes` it is on (every site that sets one does the
  * other), so a re-pass, a re-landing or a re-staging adds nothing. */
 export declare function list(n: Signal<any>, t: Transaction): void;
+/** The nodes under `owner` a transaction other than `t` holds (boundaries.ts:
+ * what an earlier hold staged under a re-armed boundary). */
+export declare function heldUnder(owner: Owner, t: Transaction | null, fn: (n: Computed<any>) => void): void;
+/** `n` leaves the hold it was staged in: its next pass publishes mainline. */
+export declare function unhold(n: Signal<any>): void;
 export declare const dirtyQueue: Heap;
 export declare let clock: number;
 export declare let _hitUnhandledAsync: boolean;
@@ -189,54 +232,36 @@ export declare class GlobalQueue implements IQueue {
     static _update: (el: Computed<unknown>) => void;
     static _dispose: (el: Computed<unknown>, self: boolean, zombie?: boolean) => void;
     static _runEffect: (el: Computed<unknown>) => void;
-    static _wireExternalSource: ((self: Computed<any>) => void) | undefined;
-    static _externalUntrack: (<T>(fn: () => T) => T) | undefined;
-    static _laneRead: ((c: Computed<any> | null, el: Signal<any> | Computed<any>) => unknown) | undefined;
-    static _laneStage: ((el: Computed<any>, l: Transaction, create: boolean, errored: boolean | Computed<any>) => boolean) | undefined;
-    static _laneOutcome: ((el: Computed<any>, value: unknown, errored: boolean) => boolean) | undefined;
-    static _laneWrite: (<T>(el: Signal<T> | Computed<T>, v: T) => T) | undefined;
-    static _applyGuesses: ((parent: Transaction | null) => void) | undefined;
     /** A slot node's truth is in flight (its family's derive — store/store.ts). */
     static _slotFlight: ((n: Signal<any>) => boolean) | 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). */
     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
      * `laneWrite`): the store re-bases an arrangement guess over it
      * (store/optimistic.ts). */
     static _laneRebase: ((el: Signal<any>, truth: unknown) => void) | undefined;
-    static _laneSeams: ((leaks: Computed<any>[] | null) => void) | undefined;
-    static _laneCorrections: (() => boolean) | undefined;
-    static _endLanes: ((u: Transaction) => void) | undefined;
-    static _lanesBlocked: ((t: Transaction) => boolean) | undefined;
     static _verdictLane: ((t: Transaction) => Transaction) | undefined;
-    static _observeFlight: ((c: Computed<any>, el: Computed<any>) => boolean) | undefined;
     static _laneGuesses: ((t: Transaction) => Signal<any>[]) | undefined;
-    /** Store (store/store.ts): fold the pending backings whose container
-     * nodes this flush committed — the owned-raw model's one mutation point. */
-    static _storeCommit: (() => void) | undefined;
-    /** The flush parked into `t`: the store materializes and holds the
-     * container node of every staging that had none (store/store.ts — a
-     * staging needs the node as its home only when something can read the
-     * frame through it; a hold can). */
-    static _storePark: ((t: Transaction) => void) | undefined;
+    /** `createDeferred` (deferred.ts): a deferred node with a flight up that
+     * `c` derives from, if any — a truth reader waits on it. */
+    static _lagging: ((c: Computed<any>) => Computed<any> | undefined) | undefined;
     static _marked: ((el: Signal<any> | Computed<any>) => boolean) | undefined;
-    static _releaseMarks: ((nodes: Signal<any>[]) => void) | undefined;
-    static _releaseAmbientMarks: ((parked: Transaction | null) => void) | undefined;
-    static _catch: ((node: Computed<any>, flags: number, error: unknown) => boolean) | undefined;
-    static _fresh: ((node: Computed<any>) => unknown) | undefined;
-    static _hidden: ((r: Computed<any>) => boolean) | undefined;
-    static _boundarySeam: (() => void) | undefined;
-    static _heldRun: ((node: Computed<any>) => boolean) | undefined;
     flush(): void;
     /** L2 — the seam: end of the pure phase. Commit this flush's staged nodes,
      * or park them with the transaction the flush joined; then land every

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

@@ -0,0 +1,16 @@
+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). */
+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`).
+ *
+ * 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;