@solidjs/signals 2.0.0-rc.1 → 2.0.0-rc.10

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

@@ -18,6 +18,15 @@ export declare const REACTIVE_MANUAL_WRITE: number;
  * pending window does not read as pending (question-scoped pending model).
  */
 export declare const REACTIVE_REASK: number;
+/**
+ * A dependency write landed while this subscriber was mid-recompute — a
+ * nested pull committed beneath one of its reads (#3037). The heap refuses
+ * RECOMPUTING nodes, so recompute's tail consumes this latch and reschedules:
+ * values the pass read before the nested commit are stale. Only set for
+ * links validated this pass (gen-current): a write to an untouched link is
+ * either re-read later in the pass (fresh) or trimmed with it (not a dep).
+ */
+export declare const REACTIVE_MISSED_WAKE: number;
 export declare const CONFIG_OWNED_WRITE: number;
 export declare const CONFIG_NO_SNAPSHOT: number;
 export declare const CONFIG_TRANSPARENT: number;
@@ -25,6 +34,173 @@ export declare const CONFIG_IN_SNAPSHOT_SCOPE: number;
 export declare const CONFIG_CHILDREN_FORBIDDEN: number;
 export declare const CONFIG_AUTO_DISPOSE: number;
 export declare const CONFIG_SYNC: number;
+export declare const CONFIG_OPTIMISTIC: number;
+export declare const CONFIG_HAS_COMPANIONS: number;
+export declare const CONFIG_HAS_SNAPSHOT: number;
+export declare const CONFIG_HAS_LANE: number;
+/** Set on a FIREWALL computed when any of its child signals creates an
+ * isPending()/latest() companion. Gates the post-recompute child-companion
+ * walk (#3038): a store computed's `_child` chain holds one node per
+ * materialized leaf, so walking it unconditionally makes every update cost
+ * O(all leaves ever read). Sticky — set at companion creation, never
+ * cleared; sync-only apps never set it and never pay the walk. */
+export declare const CONFIG_CHILD_COMPANIONS: number;
+/** Set on a computed when its first firewall child signal is installed
+ * (projection machinery). Gates markNode's firewall-children walk with one
+ * masked read of the always-present _config — the walk's old `_child` read
+ * moved into the cold extension (§12), and an unconditional `_x` deref per
+ * marked node measurably taxed the propagation hot path (diamond -22%). */
+export declare const CONFIG_FW_CHILDREN: number;
+/** Authoritative-view reader (`until()`): while this node computes, reads
+ * dodge active optimistic OVERRIDES only — the predicate must observe
+ * arriving truth, never the caller's own tentative writes (which would
+ * trivially satisfy it). Everything else reads normally, INCLUDING
+ * transition-staged `_pendingValue`: staged data is authoritative (optimism
+ * lives only in override slots), and a hold that refused staged reads would
+ * deadlock on data the open transaction itself is holding (a refresh the
+ * action issued lands staged and cannot commit until the hold releases).
+ * read() checks the bit on the reading computation (`context`) directly — no
+ * ambient flag — so a shared computed the predicate pulls recomputes as
+ * itself (no bit) under the normal view, and its cache never forks. */
+export declare const CONFIG_AUTHORITATIVE_READ: number;
+/** Sticky mark: an authoritative-view reader read this node PAST an active
+ * override. The ack shape — an authoritative arrival EQUAL to the override —
+ * rides paths that are deliberately silent under A17 (every ordinary reader
+ * sees the override, so an equal landing changes nothing for them). A marked
+ * node notifies those readers on such paths anyway, so the landed truth is
+ * seen without re-firing ordinary subscribers. Never cleared — only nodes an
+ * until() predicate observed mid-override pay. */
+export declare const CONFIG_AUTHORITATIVE_OBSERVED: number;
+/** Promise-delivery effect (resolve()/until()): commits its computed value
+ * directly even when recomputing under its own held transition. These
+ * effects deliver applies on a microtask (#2930) instead of the stashed
+ * effect queues, so the value must ride the same immediate schedule — a
+ * staged value with an immediate apply delivers stale state (resolve) or
+ * deadlocks the hold (until). Safe because the node is a private leaf: no
+ * subscriber reads an effect's value, only its own apply does. */
+export declare const CONFIG_DIRECT_COMMIT: number;
+/** Fresh-pull reader (awaitable `refresh()`'s waiter effect): a read of a
+ * dirty source recomputes it inline even when the height gate defers to the
+ * flush. Closes the same-flush ordering race where a waiter created
+ * alongside a refresh() mark read the PRE-re-ask value as settled and
+ * delivered stale; with the pull, the waiter either parks on the re-ask's
+ * pending window (async — woken by the settle walk, which runs on every
+ * landing including equal-value ones) or serves its sync answer. resolve()
+ * deliberately keeps that race — its contract is "first settled value"
+ * (#2930), not "next quiescent state". */
+export declare const CONFIG_FRESH_READ: number;
+/** HELD truth (#3164): this node's staged `_pendingValue` is confirming
+ * truth riding a transaction that retains optimism, revealed only at that
+ * transaction's settle. Two arming sites, one meaning: the store fold
+ * (a landing staged into the retaining transaction) and until()'s
+ * flip-entanglement (a foreign carrier's staged write, stolen when it
+ * flipped the awaited predicate truthy). Override-covered nodes never
+ * arm: the override is their display and its revert their notification
+ * (A17).
+ *
+ * To a DERIVING reader the truth is a staged value like any other: a memo
+ * or user effect served it enters the transaction and is held with it
+ * (A29), so a pass that composes it with a superseded override's truth
+ * composes ONE staged world — never staged truth beside committed
+ * neighbours (#3568: the mask served the retaining transaction's own pass
+ * the landed `length` through the override while the rows past it stayed
+ * committed, and `<For>` walked into a hole). Stale readers of a foreign
+ * transaction keep committed through the stale-of-foreign clause,
+ * untracked reads keep committed (Rule 1), and latest() and until()'s
+ * predicate tunnel through — the exemption that keeps holds deadlock-free.
+ *
+ * The one reader the mark gates is a LANE pass, owning transaction or not
+ * (ruled 2026-09-22, superseding #3589's owner exemption): a lane applies
+ * its frame display-ahead at the park, so a lane pass served the truth
+ * would paint the confirmation beside the optimism it confirms —
+ * `saving=true` beside the saved row, a frame no timeline contains
+ * (GabbeV's union tear). It keeps committed and is re-run by the reveal's
+ * post-revert wake. A lane under the retaining transaction owns its
+ * overrides and its lane cargo (`ownsLane`), not the transaction's
+ * confirming truth. Cleared at commit (the commit IS the reveal);
+ * subscribers masked during the hold are woken by finalizePureQueue's
+ * post-revert pass. */
+export declare const CONFIG_HELD_TRUTH: number;
+/** SLOT node (store leaf): created through `slotSignal` with `_host`/`_key`
+ * backrefs baked into the literal. The unobserved sweep dispatches these to
+ * the ONE shared hook (`setSlotUnobserved`) instead of a per-node closure
+ * held in a per-node extension — store mounts materialize one signal per
+ * touched leaf, so per-node allocations (options object, equals closure,
+ * unobserved closure, NodeExtension) were the measured create-floor bytes
+ * (warm dbmon profile: store node machinery ~36% + GC ~29%). */
+export declare const CONFIG_SLOT_NODE: number;
+/** Optimistic node whose own source arrived with a value DIFFERENT from its
+ * active override (A18 supersession, #3331). The override survives only as
+ * the displayed value — untracked reads and the applied frame keep it until
+ * the owning transaction commits — while the graph has already moved to the
+ * staged truth in `_pendingValue`: tracked readers see it and the corrected
+ * cascade is that transaction's held work. Set by the two own-source write
+ * paths (asyncWrite, transition-held recompute); cleared by a fresh optimistic
+ * write (a new override re-masks) and by the revert. */
+export declare const CONFIG_OVERRIDE_SUPERSEDED: number;
+/** HELD children (#3404): this node's `_firstChild` chain (and `_disposal`
+ * list) was built by a recompute whose result has not committed — a staged
+ * value, a pending window, or a run under a held transaction. A later
+ * recompute may tear those children down immediately: nothing observable
+ * was ever built on them. Unset, the children belong to the committed frame
+ * and a recompute defers them as zombies (`_pendingFirstChild`) until this
+ * node commits — regardless of whether the recompute runs under a
+ * transaction. A parked node (status propagation stamps `_transition`
+ * without recomputing) recomputed when its source lands otherwise disposed
+ * its committed children mid-hold, running their cleanups before the
+ * transaction's atomic reveal. Cleared by `commitPendingNode`. */
+export declare const CONFIG_HELD_CHILDREN: number;
+/** The frame parked in `_pendingFirstChild` / `_pendingDisposal` is a LANE
+ * frame (#3662, A15 lanes corollary): an effect's lane pass direct-commits,
+ * so the frame it replaces leaves the screen when the lane's queue applies
+ * the run (A30) — not at the action's commit like #3404's transaction
+ * zombies, and not at the pass (a held lane defers the run). Drained by the
+ * lane's render entry the parking site pushed ahead of the new frame's
+ * effects (cleanups before side effects), by `commitPendingNode` if a hold
+ * commits the node first, or with the owner's death. While set the parked
+ * frame is not a hold (the node is not queued or stamped for it), a
+ * superseding pass disposes the never-shown live children on the spot, and a
+ * lane-channel dirty on a member is cancelled (`laneZombie`). Effects only: a
+ * memo's lane pass publishes an override (A17, #3479). */
+export declare const CONFIG_LANE_FRAME: number;
+/** In-flight async node whose inputs were PUBLISHED while it was pending: a
+ * batch or transaction committed with the node still `STATUS_PENDING` (an
+ * unobserved flight, #3305), so the inputs are on screen and the node's
+ * committed `_value` is stale against them. Governs read()'s reveal
+ * carve-out: a stale (render) reader in some OTHER transaction may show a
+ * foreign-held pending node's committed value — parallel transactions, no
+ * entanglement — only while that value is coherent with the visible frame,
+ * i.e. while the flight's inputs are themselves held (unpublished) and not
+ * lane-revealed. Set by `commitPendingNodes`; cleared when the node next
+ * enters pending fresh (a new flight from a settled state). */
+export declare const CONFIG_INPUTS_PUBLISHED: number;
+/** A28 (4): the node was written inside a recompute that ran OUTSIDE a flush
+ * (a creation-time compute — boundary machinery, a mapArray's first run). Such
+ * a write is promoted at that recompute's end: readers in the same block see
+ * it. Cleared when the next flush begins; set only on that rare path. */
+export declare const CONFIG_PROMOTED: number;
+/** A28 for same-tick adoption: the node was staged outside a flush and then
+ * adopted by a transaction (initTransition) before any flush carried the
+ * staging — the stamp says "held", but nothing flushed is staged for it, so
+ * on no channel is the write visible yet: `latest()` answers the committed
+ * value, the verdict sees nothing pending (as the store's leaves already did
+ * through their own selection). Cleared when the carrying flush re-stamps the
+ * transaction's pending nodes (reassignPendingTransition). */
+export declare const CONFIG_ADOPTED_UNFLUSHED: number;
+/** The node's active override is a DERIVED one: a lane pass published its
+ * speculative result into the override slot instead of `_value` (lanes
+ * stage — an optimistic derivation is an override, #3479). Its truth is not
+ * `_value` but a recompute from its inputs' truth, so the body-end
+ * supersession (`endOptimism`) and the authoritative-flight blockage
+ * (`transitionBlocked`) skip it; the revert drops the override and re-derives
+ * it (`resolveOptimisticNodes`). Cleared with the override. */
+export declare const CONFIG_DERIVED_OVERRIDE: number;
+/** Observe tiers only: the node is framework plumbing (the `solid-js/refresh`
+ * HMR memo between a component's root and its body) — it has no name, is no
+ * segment of any owner path, and the attribution engine records nothing about
+ * it (creation, re-runs, checks), while the nodes it owns stay fully observed.
+ * Set from the internal `_plumbing` option at creation; never set in prod. */
+export declare const CONFIG_PLUMBING: number;
 export declare const STATUS_NONE = 0;
 export declare const STATUS_PENDING: number;
 export declare const STATUS_ERROR: number;
@@ -33,6 +209,9 @@ export declare const EFFECT_PURE = 0;
 export declare const EFFECT_RENDER = 1;
 export declare const EFFECT_USER = 2;
 export declare const EFFECT_TRACKED = 3;
+/** OR-ed into the `type` a lane passes to its effect runners: lane runs
+ * apply ahead of their transaction and are exempt from ownership parking. */
+export declare const LANE_RUN = 4;
 export declare const NOT_PENDING: {};
 export declare const NO_SNAPSHOT: {};
 /**

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

@@ -1,9 +1,10 @@
-import { type Refreshable } from "./constants.js";
 import { type OptimisticLane } from "./lanes.js";
-import type { Computed, FirewallSignal, NodeOptions, Owner, Signal } from "./types.js";
+import type { Transition } from "./scheduler.js";
+import type { Computed, FirewallSignal, 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 REACTIVE_WRITE_IN_OWNED_SCOPE_SIGNAL_MESSAGE: string;
 export declare const REACTIVE_WRITE_IN_OWNED_SCOPE_REFRESH_MESSAGE: string;
+export declare const ASYNC_STORE_SETTER_MESSAGE: string;
 export declare let tracking: boolean;
 /** @internal verdict-module glue */
 export declare function setPendingCheckActive(v: boolean): void;
@@ -16,6 +17,13 @@ export declare let pendingCheckActive: boolean;
 export declare let latestReadActive: boolean;
 export declare let context: Owner | null;
 export declare let currentOptimisticLane: OptimisticLane | null;
+/** Notify `node`'s subscribers on `lane`'s channel: they recompute as the
+ * lane's passes — a memo publishes a derived override (lanes stage, #3479),
+ * an effect runs from the lane's queue, at the park, ahead of the
+ * transaction — the display-ahead view. The write itself is already staged
+ * (setSignal) and commits with the frame; this walk shows it now. Used by a
+ * boundary re-armed from a lane pass (boundaries.ts `_swap`, #3540). */
+export declare function notifyOnLane(node: Signal<any>, lane: OptimisticLane): void;
 export declare let snapshotCaptureActive: boolean;
 export declare let snapshotSources: Set<any> | null;
 export declare function setSnapshotCapture(active: boolean): void;
@@ -25,15 +33,51 @@ export declare function clearSnapshots(): void;
 export declare function recompute(el: Computed<any>, create?: boolean): void;
 export declare function computed<T>(fn: (prev?: T) => T | PromiseLike<T> | AsyncIterable<T>): Computed<T>;
 export declare function computed<T>(fn: (prev: T) => T | PromiseLike<T> | AsyncIterable<T>, options?: NodeOptions<T>): Computed<T>;
+/** Lazily allocate a node's cold extension (ONE shape for signals and
+ * computeds — `_x` access stays monomorphic). Installers write through
+ * this; hot paths read `el._x?._field` gated by the _config presence bits.
+ * Never call ext() just to store a field's default. */
+export declare function ext(el: {
+    _x: NodeExtension | null;
+}): NodeExtension;
 /**
  * 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
  * mode (recompute is called explicitly by `effect()`), so we hardcode the lazy bits and skip
  * the auto-dispose CONFIG bit (effect() previously cleared it post-construction).
  */
-export declare function createEffectNode<T>(fn: (prev?: T) => T, effectFn: (val: T, prev: T | undefined) => void | (() => void), errorFn: ((err: unknown, cleanup: () => void) => void | (() => void)) | undefined, type: number, notifyStatus: ((status?: number, error?: any) => void) | undefined, options: NodeOptions<T> | undefined): any;
+export declare function createEffectNode<T>(fn: (prev?: T) => T, effectFn: (val: T, prev: T | undefined) => void | (() => void), errorFn: ((err: unknown, cleanup: () => void) => void | (() => void)) | undefined, type: number, options: NodeOptions<T> | undefined): any;
+/**
+ * The shared status notifier for effect nodes, installed once by effect.ts
+ * at module evaluation (`this`-dispatched — one function serves every
+ * effect, so nodes never store it). Boundary computeds keep their own
+ * per-node channel on `_x._notifyStatus`, which takes precedence.
+ */
+export declare let effectStatusNotify: ((this: any, status?: number, error?: any) => void) | null;
+export declare function setEffectStatusNotify(fn: NonNullable<typeof effectStatusNotify>): void;
+/** Resolve a node's status notifier: an own `_x` channel (boundaries) wins;
+ * effect nodes (`_type` — EFFECT_PURE is 0, and only effect literals carry
+ * the field) fall back to the shared notifier. Presence doubles as the
+ * "display consumer" membership test in the status walks, exactly as the
+ * per-node field did when every effect carried one. */
+export declare function statusNotifierOf(el: any): ((this: any, status?: number, error?: any) => void) | undefined;
 export declare function signal<T>(v: T, options?: NodeOptions<T>): Signal<T>;
 export declare function signal<T>(v: T, options?: NodeOptions<T>, firewall?: Computed<any>): FirewallSignal<T>;
+/** The shared slot-node unobserved handler — a live binding read directly by
+ * the sweep sites (no wrapper frame, no null check: a CONFIG_SLOT_NODE node
+ * existing implies the store module loaded and registered the hook). */
+export declare let slotUnobservedHook: (node: Signal<any>) => void;
+/** Install the shared slot-node unobserved handler (store module, once). */
+export declare function setSlotUnobserved(fn: (node: Signal<any>) => void): void;
+/** Release a firewall child the store no longer addresses (unobserved sweep
+ * dropped it from its target's cache): unlink it from the chain so the
+ * projection stops retaining it and its last value. The node keeps its own
+ * `_nextChild` so a walk that is mid-chain on it still terminates. It also
+ * leaves `_companionChildren` (#3503): the companions themselves are
+ * permanent on the node, but the node is unreachable through the store, so
+ * the set would only retain it and its last value. */
+export declare function unlinkFirewallChild(node: Signal<any>): void;
+export declare function slotSignal<T>(v: T, equals: (a: T, b: T) => boolean, host: object, key: PropertyKey, acc: boolean, firewall?: Computed<unknown> | null): Signal<T>;
 export declare function optimisticSignal<T>(v: T, options?: NodeOptions<T>): Signal<T>;
 export declare function optimisticComputed<T>(fn: (prev?: T) => T | PromiseLike<T> | AsyncIterable<T>, options?: NodeOptions<T>): Computed<T>;
 export declare function isEqual<T>(a: T, b: T): boolean;
@@ -42,6 +86,30 @@ export declare function isEqual<T>(a: T, b: T): boolean;
  * scope will log a dev-mode warning. Managed automatically by `untrack(fn, strictReadLabel)`.
  */
 export declare let strictRead: string | false;
+/** Dev-only: explicit untrack() nesting, so deliberate post-await reads stay quiet. */
+export declare let untrackDepth: number;
+/**
+ * Dev-only: > 0 while Solid runs user code that is imperative by construction
+ * — an effect callback (effect.ts) or an action body's synchronous slice
+ * (action.ts). Both run with no owner, exactly like an async continuation, so
+ * the post-await read check (dev.ts) consults this rather than blame the
+ * continuation that called flush() or invoked the action. Both sites bracket
+ * with try/finally, so a throw cannot leave it raised.
+ */
+export declare let callbackDepth: number;
+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
+ * `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.
+ */
+export declare let disposalDepth: number;
+export declare function enterDisposal(): void;
+export declare function exitDisposal(): void;
+export declare function resetDisposalDepth(): void;
 export declare function setStrictRead(v: string | false): string | false;
 /**
  * Runs `fn` outside of any reactive tracking — reads inside `fn` will not
@@ -66,6 +134,24 @@ export declare function setStrictRead(v: string | false): string | false;
  * ```
  */
 export declare function untrack<T>(fn: () => T, strictReadLabel?: string | false): T;
+/**
+ * Set while runtime bookkeeping reads a node inside another node's pass (a
+ * loading boundary priming its tree at creation, from whatever pass is
+ * mounting it). `context` is that node, but the read is nobody's: the value
+ * is probed, never derived from, so nothing the read would normally record
+ * on `context` may be recorded — not the untracked-pending re-run link
+ * (`read`, `!tracking`; #3528: a boundary's `on` key read this way from
+ * `notify` linked the key's source into an unrelated async memo, a cycle that
+ * never converged), and not a transaction entry (`enterStagedRead`; #3540: a
+ * born-held tree would otherwise pull the mounting pass into the hold).
+ */
+export declare let spectating: boolean;
+/**
+ * Evaluates `fn` untracked, recording nothing on the current `context`: no
+ * untracked-pending re-run link, no transaction entry. For bookkeeping reads
+ * made on behalf of no node — see `spectating`.
+ */
+export declare function spectate<T>(fn: () => T): T;
 /**
  * Bring a computed to a readable state: lazy/disposed nodes are (re)computed;
  * an isPending() probe (`refresh`) additionally pulls the node fully up to
@@ -86,16 +172,198 @@ export declare const READ_SLOW: unique symbol;
  * snapshot / transition / lane / dev-strictRead state all take the full
  * resolution. Anything slow returns READ_SLOW; the caller then calls read().
  */
+/**
+ * Wake only authoritative-view readers (until() predicates) subscribed to `el`.
+ * The A17-silent ack paths — an authoritative arrival equal to the active
+ * override — use this so the predicate re-evaluates without re-firing
+ * ordinary subscribers whose visible (override) value did not change.
+ * Pay-for-use: reached through GlobalQueue._notifyAuthoritativeObservers,
+ * installed at first until() call — apps that never use until() shake it.
+ */
+export declare function notifyAuthoritativeObservers(el: Signal<any> | Computed<any>): void;
+/** Installs the authoritative-reader wakeup hook. Idempotent; called by every
+ * creator of a CONFIG_AUTHORITATIVE_READ computation — until() and refresh() —
+ * before its first read (same late-binding contract as the optimistic engine;
+ * the gating bit is only ever set by such a read, so the `!` call sites are
+ * safe once every setter installs, #3303). */
+export declare function installAuthoritativeRead(): void;
+/**
+ * Stale-reader term of the value selections below: a render effect reading a
+ * node some OTHER live transaction has staged sees the committed value. The
+ * commit is silent — the staging walk was the notification — so a reader
+ * that linked AFTER that walk (an effect created during the hold, a store
+ * key first read under it) would show the old value past the reveal: record
+ * it for the transaction's commit replay (the `_gatedSubs` contract lanes
+ * already use). An effect the transaction itself computed re-derives at its
+ * commit on its own (parked run, or the contested re-derive, #3322) and is
+ * not recorded — replaying it too would publish the frame twice.
+ *
+ * Flight twin (the pending-branch carve-out): the reader is served the
+ * node's committed, pre-flight value and now observes that flight — A15:
+ * async work observed by a reader settles as one unit with the writes that
+ * asked it — so it joins the transaction's reporters for the node. The
+ * reporter the transaction recorded when the flight started may be gone (a
+ * keyed remount disposed it, #3374); a completion check that found no live
+ * reporter committed the writes ahead of the answer, tearing the new
+ * reader's frame (`Count: 1` beside `Details: 0`). Joins an entry the
+ * transaction already holds; a flight nobody had observed yet has none (the
+ * reader is its first observer — a conditional that just revealed it, #3458)
+ * and is notified up the reader's own queue chain under that transaction,
+ * the one sanctioned registration site (INV-3): a collecting boundary above
+ * the reader consumes it as it would any pending, an unboundaried reader
+ * opens the entry — and the transaction, judged complete on its other
+ * flights, revealed the inputs beside the reader's pre-flight value
+ * otherwise (`Count: 1 | A: 1` beside `B: 0`). A staged signal or a settled
+ * node registers nothing. Every reporter dies with its reader
+ * (reporterBlocksSource: the read linked it as a dep). The node's own entry
+ * is the only one that can matter: a chain's intermediate memo is re-pulled
+ * by the read (updateIfNecessary's retry) and enters the transaction, so the
+ * reader holds through the normal path; a node with its own flight that is
+ * also pending on an upstream re-ask blocks through that flight until it
+ * lands, and its landing re-runs the reader into the normal path.
+ */
+/** The replay half of the stale-of-foreign clause (A15 / A26): a stale reader
+ * served the committed value because `txn` holds what it read re-runs at
+ * txn's commit, when the value it was denied becomes the frame — unless its
+ * own last value already came from that transaction. One registration for
+ * the node path (heldFromStale) and the store's backing paths, which have
+ * no node to carry the hold (heldFromReader, the adoption hold view). */
+export declare function recordStaleReplay(txn: Transition, c: Computed<any>): void;
+/**
+ * The ownership relation (DESIGN-CONSOLIDATION §6, ruled 2026-09-17): is
+ * `hold` part of the running pass's world? A plain reader's world is the
+ * transaction it runs under, through merges. A lane reader's world is its
+ * lane AND the transition that owns the lane — the one asymmetry between a
+ * lane and a separate transaction (a lane sees what lands from its parent as
+ * its own; a separate transaction would wait for the parent to settle) —
+ * see `ownsLane` in lanes.ts, built on this. One relation for the
+ * stale-of-foreign clause (heldFromStale), the lane arm (readsHeldCommitted)
+ * and the store's backing holds (foreignHold); `serve` has no lane arm of
+ * its own, the lane's extra visibility lives here.
+ */
+export declare function ownsHold(hold: Transition): boolean;
+export declare function enterStagedRead(el: Signal<any> | Computed<any> | null, t?: Transition | null | undefined): void;
+/**
+ * Rule 1 (value selection), the full arm: does this reader see a STAGED
+ * node's COMMITTED value? One implementation of the rule the fast paths
+ * (readNodeFast, read's fast block) carry as their trivial ternary and that
+ * every slow site — read's tail, the store's backing selection, the lane and
+ * verdict arms — used to restate by hand (docs/DESIGN-CONSOLIDATION.md, move 3b). In order:
+ * - no reader at all (an untracked read) — the committed frame;
+ * - a reader under an optimistic lane the engine says reads committed
+ *   (laneReadsCommitted: another lane's hold, #3460);
+ * - nothing staged;
+ * - a children-forbidden reader (createTrackedEffect / onSettled: the frame,
+ *   never the graph — A32);
+ * - a stale reader (render effect) of a FOREIGN transaction's staged write —
+ *   committed, no entanglement (heldFromStale registers the replay; a node
+ *   born held has no committed frame to fall back to, `noCommitted`);
+ * - HELD truth (#3164, CONFIG_HELD_TRUTH) read by a LANE pass: staged
+ *   confirming truth — fold-staged onto an armed family, or entangle-stolen
+ *   by an awaited until() — is masked from lane passes only, owning
+ *   transaction or not. A lane applies its frame display-ahead at the park,
+ *   so a lane pass served the truth would paint the confirmation beside the
+ *   optimism it confirms (`saving=true` beside the saved row — the #3164
+ *   tear); it keeps committed and is re-run by the reveal's post-revert
+ *   wake. Every other deriving reader falls through to A29 below: the truth
+ *   is a staged value like any other, and the pass that derives from it is
+ *   held with it — including the retaining transaction's own passes, which
+ *   a superseded override already hands the truth (#3568: masking them
+ *   composed the landed `length` with rows still masked to committed).
+ *   latest() and authoritative readers (until()'s predicate) tunnel
+ *   through — the tunnel that keeps the hold deadlock-free.
+ * False means the reader derives from the staged value and enters its
+ * transaction (enterStagedRead, A29).
+ */
+export declare function readerSeesCommitted(el: Signal<any> | Computed<any>, c: Computed<any> | null, owner: Signal<any> | Computed<any>, noCommitted: boolean): boolean;
+/** A28 — set when a node is staged (queuePendingNode) or a held node rewritten
+ * (stashHeldRewrite) OUTSIDE a flush; cleared when the next flush begins. The
+ * read sites test this one module boolean instead of `globalQueue._running`:
+ * inside a flush it is false and the A28 arm costs nothing; outside, only a
+ * tick with unflushed writes pays the staged-node check. */
+export declare let unflushedStaged: boolean;
+export declare function markUnflushedStaged(): void;
+/** A28 — a write becomes visible at flush. Outside a flush, a node holding an
+ * AMBIENT staged value (no transaction stamp) was written since the last
+ * flush: ambient staging commits at flush end, so nothing else leaves a node
+ * in this state; a stamped value is the flushed held world, which A28 says
+ * latest() serves. Inside a flush the rule does not apply (A28 (4): promoted
+ * within the round). Structural — no marker on the write path. */
+export declare function unflushed(el: Signal<any> | Computed<any>): boolean;
+/** The value an unflushed node serves — the committed value for an ambient
+ * write, the flushed staged value for a rewrite of a held node — or
+ * NOT_PENDING when nothing is unflushed. Exempt: owned-write nodes (A28 (4):
+ * a write issued inside a recompute is promoted at that recompute's end —
+ * boundary and loading machinery, until()'s internals, signals declared for
+ * in-computation writes) and engine companions (the isPending() verdict
+ * signal, the latest() shadow: the system's own writes, made at the source's
+ * write to mirror it, installing eagerly — A28, A8). */
+export declare function unflushedValue(el: Signal<any> | Computed<any>, committed?: any): unknown;
+/** A28 (5): an optimistic write becomes the ACTIVE override at the flush that
+ * carries it. `_overrideTime` is stamped with `clock` at the write and `clock`
+ * advances after every flush, so "this tick, outside a flush" is unflushed. */
+export declare function unflushedOverride(el: Signal<any> | Computed<any>): boolean;
+/** Active optimistic override on an armed node (an armed slot idles at
+ * NOT_PENDING; undefined = unarmed plain node). The writer's own channels —
+ * the draft, `in`/keys inside the setter — compose on this regardless of
+ * flush state. */
+export declare function hasActiveOverride(el: Signal<any> | Computed<any>): boolean;
+/** The override a READER sees: installed, and carried by a flush (A28 (5) —
+ * an optimistic write is a write; until its flush no reader sees it). One
+ * implementation for read()'s override arm, the verdict channels
+ * (latestRead, computePendingState) and the store's selection
+ * (docs/DESIGN-CONSOLIDATION.md, move 3b). */
+export declare function visibleOverride(el: Signal<any> | Computed<any>): boolean;
+/** A derivation served the committed value because of an unflushed write
+ * (A28) must run again in the flush that carries it — the late-linker case
+ * (#3337's reason to defer the walk): it linked after the write walked. */
+export declare function markLateLinker(c: Computed<any>): true;
+/** Companion-bearing nodes written outside a flush (setSignal); the flush
+ * that carries their writes re-syncs their companions (A28). */
+export declare const unflushedCompanions: Array<Signal<any> | Computed<any>>;
+export declare function resyncUnflushedCompanions(): void;
 export declare function readNodeFast<T>(el: Signal<T>): T | typeof READ_SLOW;
 export declare function read<T>(el: Signal<T> | Computed<T>): T;
+/**
+ * Rule 1, the one slow implementation (DESIGN-CONSOLIDATION move 3b, step
+ * 6c): the value a reader `c` (null = untracked, no pass) is served from
+ * `el`, whose committed value is `committed` — the node's own `_value` for
+ * a signal or memo, the BACKING for a store property node (single-home rule,
+ * O6: committed truth lives in the backing and a node's `_value` is never
+ * served for one). Called by read()'s slow tail and by the store's untracked
+ * node path (nodeValue); the fast paths (readNodeFast, read's fast block)
+ * keep their trivial ternary by design (perf, see the doc). Arms, in order:
+ * - the override (A17), routed through the engine for a tracked reader under
+ *   a lane or a supersession (A18), an authoritative reader marked instead;
+ * - the lane entanglement gate (committed, recorded for replay);
+ * - a node born held has nothing for an untracked reader (A19 exception 1);
+ * - an unflushed write serves committed and re-runs the reader in the
+ *   carrying flush (A28);
+ * - readerSeesCommitted, else the staged value and the transaction (A29).
+ */
+export declare function serve(el: Signal<any> | Computed<any>, c: Computed<any> | null, owner: Signal<any> | Computed<any>, committed: unknown): unknown;
 /**
  * Store-rewrite setter guard: the rewrite parks writes in a pending backing
  * (no setSignal at write time), so the owned-scope write protection must
- * fire at the setter entry instead. Mirrors setSignal's guard condition
+ * fire at the setter entry instead. Exactly setSignal's guard condition
  * minus the node-specific exemptions (ownedWrite/firewall), which don't
- * apply to plain store setters.
+ * apply to plain store setters. Roots are NOT exempt (#3500): a root body is
+ * tree construction — every dev component body, every context Provider, the
+ * top of `render()`, and the whole SSR pass run directly under one — and a
+ * write there re-runs what already read the old value (or on the server,
+ * can't). Same rule as setSignal, which never exempted roots.
  */
 export declare function devGuardStoreSetterWrite(): void;
+/**
+ * Store setter result guard: the callback's return has one meaning — a
+ * replacement root to adopt — and a thenable can never be that. It is the
+ * signature of `setStore(async d => …)` (or a sync arrow whose helper is
+ * async): only the writes before the first `await` were in the transaction;
+ * the rest land on a closed draft and vanish. Setters are synchronous
+ * transactions; async orchestration is `action()`'s job. Store-specific —
+ * a signal may legitimately hold a promise, so its setter has no such rule.
+ */
+export declare function devGuardStoreSetterResult(result: unknown): void;
 export declare function setSignal<T>(el: Signal<T> | Computed<T>, v: T | ((prev: T) => T)): T;
 /**
  * Suppresses automatic recomputation of `el` until the scheduler drains. Used
@@ -105,11 +373,30 @@ export declare function setSignal<T>(el: Signal<T> | Computed<T>, v: T | ((prev:
  * cleanup point.
  */
 export declare function suppressComputedRecompute(el: Computed<unknown>): void;
+/** A34 amendment (#3612) — is `el`'s staging a DERIVATION another transaction
+ * holds: stamped by a transaction that is not the writer's, and not a manual
+ * proposal (the mask, on the node or — a store leaf — its firewall)? #2692's
+ * "manual write wins" is a rule for one synchronous frame; across a hold the
+ * held pass result is nobody's proposal, and a user setter reaching it
+ * composes on the committed frame it was written against and becomes `prev`
+ * for the transaction's re-derivation (rederiveHeld) instead of replacing it.
+ * Writes made under the holding transaction masked the node and keep
+ * A34(1)'s last-write-wins. Only the user setters ask; an async landing or a
+ * companion writing a stamped node is the transaction's own work. */
+export declare function heldDerivation(el: Signal<any> | Computed<any>): boolean;
+/** The held-derivation write's second half: the node re-derives under its
+ * hold with the written staging as the pass's `prev`. Nothing is masked. The
+ * write took the A34 join (setSignal), which scheduled the flush that drains
+ * this; recompute re-enters the stamp. */
+export declare function rederiveHeld(el: Computed<unknown>): void;
 /**
  * User-facing setter for the memo form of `createSignal(fn)`. Behaves like
  * `setSignal`, but also cancels any pending recompute of the memo so the
  * manual value wins over a value that would otherwise be produced by an
- * upstream change in the same tick.
+ * upstream change in the same tick. Across a hold the write is not a
+ * proposal: a memo another transaction holds as a pass result composes on the
+ * committed value and re-derives under the hold with the write as `prev`
+ * (A34 amendment, #3612; heldDerivation).
  */
 export declare function setMemo<T>(el: Computed<T>, v: T | ((prev: T) => T)): T;
 /**
@@ -134,23 +421,10 @@ export declare function setMemo<T>(el: Computed<T>, v: T | ((prev: T) => T)): T;
 export declare function runWithOwner<T>(owner: Owner | null, fn: () => T): T;
 export declare function staleValues<T>(fn: () => T, set?: boolean): T;
 /**
- * Invalidates one reactive source, forcing it to re-execute even if its inputs
- * haven't changed.
- *
- * Pass either a Solid-created accessor or a projected store created from
- * `createStore(fn, ...)` / `createProjection(...)`. `refresh()` is a
- * write-like invalidation operation: it does not read the target's value, and
- * refreshing a plain signal accessor is a no-op.
- *
- * Use it to invalidate cached async values (e.g. force a re-fetch) without
- * tearing the consumer down.
- *
- * @example
- * ```ts
- * const user = createMemo(async () => fetch(`/users/${id()}`).then(r => r.json()));
- *
- * // Re-fetch on demand
- * <button onClick={() => refresh(user)}>Reload</button>
- * ```
+ * Core marking half of `refresh()` (the public wrapper lives in signals.ts —
+ * it validates the target, marks through here, then builds the quiescence
+ * promise on the resolve()/until() effect machinery). Flags the node's next
+ * recompute as a quiet re-ask and schedules it; no-ops for non-derived or
+ * disposed targets and for same-tick manual writes.
  */
-export declare function refresh<T>(target: Refreshable<T>): void;
+export declare function markRefresh(node: Computed<any>): void;