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

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

@@ -1,29 +1,21 @@
-import { type OptimisticLane } from "./lanes.js";
-import type { Transition } from "./scheduler.js";
-import type { Computed, FirewallSignal, NodeExtension, NodeOptions, Owner, Signal } from "./types.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;
+/** Dev: the effect phase (render and user effects, their cleanups) runs with
+ * no ambient owner, and a computation created there with none is outside
+ * every owner and every hold (maintainer, 2026-10-01: ownerless only —
+ * `runWithOwner` in a callback is deliberate, Portal and createReaction do
+ * it; a bare createRoot is the mistake). Computeds and roots; a signal
+ * created there is inert and harmless. Tracked effects and onSettled are
+ * children-forbidden and refuse through PRIMITIVE_IN_FORBIDDEN_SCOPE. */
+export declare function assertNotInEffectCallback(): void;
 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;
-/** @internal verdict-module glue */
-export declare function setLatestReadActive(v: boolean): void;
-/** @internal verdict-module glue */
 export declare function setContextInternal(v: Owner | null): void;
 export declare let stale: boolean;
-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;
@@ -50,41 +42,39 @@ export declare function createEffectNode<T>(fn: (prev?: T) => T, effectFn: (val:
 /**
  * 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.
+ * effect, so nodes never store it). CARVE 4: the boundaries' per-node
+ * channel (`_x._notifyStatus`) went with them; effects are the only
+ * display consumers.
  */
 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. */
+/** Resolve a node's status notifier: effect nodes (`_type` — EFFECT_PURE is
+ * 0, and only effect literals carry the field) get 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;
+/** A store slot node (CONFIG_SLOT_NODE): the whole node in ONE literal — the
+ * target and key as back-refs in place of closures (`equals` is a method
+ * call, `this` the node; the unobserved sweep dispatches to one shared hook,
+ * graph.ts), the store's wrap cache (`px`/`pxv`: the proxy last served for
+ * this key and the raw it wrapped — one pointer compare replaces a WeakMap
+ * lookup per read) and the accessor verdict (`acc`) pre-shaped. No options
+ * 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). */
+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
  * scope will log a dev-mode warning. Managed automatically by `untrack(fn, strictReadLabel)`.
  */
+/** The verdict windows' read (verdict.ts), installed while a `latest` or
+ * `isPending` window is open and null otherwise: `read` dispatches to it
+ * then, and a program that never imports them never has one. */
+export declare let verdict: ((el: Signal<any> | Computed<any>, c: Computed<any> | null) => unknown) | null;
+export declare function setVerdict(fn: typeof verdict): void;
 export declare let strictRead: string | false;
 /** Dev-only: explicit untrack() nesting, so deliberate post-await reads stay quiet. */
 export declare let untrackDepth: number;
@@ -154,249 +144,99 @@ export declare let spectating: boolean;
 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
- * date so its status flags reflect the current graph.
+ * `refresh` additionally pulls the node fully up to date so its status flags
+ * reflect the current graph.
  */
 export declare function prepareComputed(comp: Computed<unknown>, refresh: boolean): void;
 /**
- * Sentinel returned by readNodeFast when the plain-signal fast path does not
- * apply and the caller must fall back to the full read().
- */
-export declare const READ_SLOW: unique symbol;
-/**
- * read()'s plain-signal fast path as a standalone entry for hot callers
- * (store traps). Safe to substitute for read() only because the bail
- * conditions mirror read()'s prelude and fast-path guard exactly: the
- * latestRead and pendingCheck windows run side-effectful hooks before the
- * fast path, `_fn` nodes need prepareComputed, and firewall / override /
- * 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:
+ * Rule 1 (value selection): does this reader see a STAGED node's COMMITTED
+ * value? One implementation of the rule the fast paths (read's fast block)
+ * carry as their trivial ternary. 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).
+ *   never the graph — A32).
+ * False means the reader derives from the staged value.
  */
-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 function readerSeesCommitted(el: Signal<any> | Computed<any>, c: Computed<any> | null): boolean;
+/** A28 — set when a node is staged (queuePendingNode) 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;
+/** A28 — a write becomes visible at flush. Outside a flush, a node holding a
+ * staged value was written since the last flush: staging commits at flush
+ * end, so nothing else leaves a node in this state. Inside a flush the rule
+ * does not apply (A28 (4): promoted within the round). The value an
+ * unflushed node serves is its committed value, or NOT_PENDING when nothing
+ * is unflushed. Exempt: promoted writes (A28 (4): a write issued inside a
+ * recompute is promoted at that recompute's end — boundary and loading
+ * machinery, signals declared for in-computation writes). */
+export declare function unflushedValue(el: Signal<any> | Computed<any>): unknown;
+/** A28: a held node rewritten outside a flush keeps the staging the last
+ * flush left (`_flushed`) until the flush that carries the rewrite — the
+ * stash is stamped with the clock, which that flush advances. */
+export declare function stashFlushed(el: Signal<any> | Computed<any>): void;
 /** 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;
+/** A tracked read's pull of a computed: bring it current when the flush has
+ * 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;
 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);
+ * `el`. Called by read()'s slow tail; the fast path (read's fast block) keeps
+ * its trivial ternary by design (perf, see the doc). Arms, in order:
+ * - a node born staged 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. Exactly setSignal's guard condition
- * minus the node-specific exemptions (ownedWrite/firewall), which don't
- * 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.
+ * - readerSeesCommitted, else the staged value.
  */
-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 serve(el: Signal<any> | Computed<any>, c: Computed<any> | null): unknown;
+/** A pass read a staging of this flush: it derives from what the flush may
+ * yet hold (REACTIVE_STAGED_READ — the seam decides). Lane work too (plan sec. 28, a
+ * lane sees the screen plus its own guesses): the staging is the screen if
+ * the frame commits — one pass, the common case — and a held write if it
+ * parks, which the seam repairs (`stagedReaders`): the pass re-derives on
+ * the committed world and its lane's runs wait that round, so the held
+ * 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. */
+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()]`
+ * is `[b, a]` — once the frame has a transaction, and re-derives when it
+ * lands: at this very seam if nothing holds it (the stale run is void,
+ * #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). */
+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;
 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
- * when a manual write should win over dependency changes queued in the same
- * tick. The MANUAL_WRITE flag is cleared by the pending-node drain; projection
- * computeds don't commit values, but they still need the same end-of-tick
- * 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. 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).
+ * User-facing setter for the memo form of `createSignal(fn)`. A write applies
+ * first, then derivations re-run (A34 as amended 2026-10-01, rule B; core
+ * R31): the write stages like any other, and a source change — in this flush
+ * or a later one, under a hold or on mainline — re-derives with the staged
+ * write as `prev`. The write never refuses the re-run (the frame-scoped mask
+ * of #3733/#3740 and #2692's "write wins the tick" before it are gone; call
+ * order inside a flush was never observable) and on its own never causes one.
+ * REACTIVE_MANUAL_WRITE only marks the staging as a user proposal — the A34
+ * (1)/(3) discriminator — until a pass re-derives it or the commit lands it.
  */
 export declare function setMemo<T>(el: Computed<T>, v: T | ((prev: T) => T)): T;
 /**
@@ -425,6 +265,6 @@ export declare function staleValues<T>(fn: () => T, set?: boolean): T;
  * 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.
+ * disposed targets.
  */
 export declare function markRefresh(node: Computed<any>): void;

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

@@ -14,7 +14,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" | "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" | "BEHAVIOR_CLAIM_DROPPED" | "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" | "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 DiagnosticKind = "strict-read" | "async" | "write" | "lifecycle" | "owner" | "error" | "perf" | "graph"
 /** Perceived responsiveness: the runtime behaved correctly but the user saw no feedback. */
  | "responsiveness"
@@ -22,7 +22,7 @@ export type DiagnosticKind = "strict-read" | "async" | "write" | "lifecycle" | "
  | "ssr"
 /** The response head: `<head>` tags, preload descriptors, HTTP headers. */
  | "head"
-/** The renderer's insert positions, on either platform: a value it has no rendering for. */
+/** The renderer's insert and attribute positions: a value it has no rendering for, or one it renders other than intended. */
  | "render";
 /** First warning when a change reaches (or a pass tracks) this many edges. */
 export declare const GRAPH_SIZE_WARN_AT = 2000;
@@ -210,6 +210,24 @@ export type RecordLive<K extends RecordType> = RecordTypes[K] extends {
     live: infer L;
 } ? L : never;
 export type RecordListener<K extends RecordType> = (event: RecordEvent<K>, live: RecordLive<K>) => void;
+/**
+ * What a `Records.subscribe` asks of the emitter beyond the record itself.
+ */
+export interface RecordSubscribeOptions {
+    /**
+     * Ask for the record's BODIES: the live handles that cost the emitter
+     * something per record to take, and are taken only while a listener of
+     * the type has asked — so a consumer that reads ids, statuses and
+     * timings (an APM adapter, the performance tracks) never pays for what a
+     * body viewer (devtools' network panel) reads. Accepted for any type, the
+     * channel being generic; meaningful today for `"call"`, whose
+     * `live.request` (a reconstruction of the dispatched request) and
+     * `live.response` (an unread clone, a transient double-buffer of the
+     * payload) are taken only under it — without it, the transport's own
+     * objects. An emitter asks with `observed(type, "bodies")`.
+     */
+    bodies?: boolean;
+}
 /**
  * The records channel — `OBSERVE.records`, on either platform: one place a
  * consumer (an APM adapter's `init()`, devtools, the diagnostics harness)
@@ -235,14 +253,28 @@ export interface Records {
      * Deliver `type` records as they complete; returns the unsubscribe. The
      * subscription is the channel's, not any emitter's: it outlives the
      * attribution engine's `enable()`/`disable()` cycles and is dropped only
-     * by its own unsubscribe.
+     * by its own unsubscribe. `options` asks the emitter for more than the
+     * record — see `RecordSubscribeOptions`. One entry per listener function:
+     * its options are read at its first subscription to the type, a repeat
+     * subscription of the same function changes nothing, and either disposer
+     * removes it. What an emitter takes is decided once per record from the
+     * union of the type's subscribers, so a listener without `bodies` that
+     * shares a call with one that asked receives the same `live` — the clone.
      */
-    subscribe<K extends RecordType>(type: K, listener: RecordListener<K>): () => void;
+    subscribe<K extends RecordType>(type: K, listener: RecordListener<K>, options?: RecordSubscribeOptions): () => void;
     /**
      * Whether anything is subscribed to `type` — an emitter's pre-check, so
      * a record nobody will hear costs nothing to not build (no clock read).
      */
     observed(type: RecordType): boolean;
+    /**
+     * Whether a listener of `type` asked for its bodies
+     * (`subscribe(type, listener, { bodies: true })`) — the emitter's
+     * pre-check for the live handles that cost something per record to take.
+     * `false` while every listener of the type is a plain one, and once the
+     * last body-wanting one unsubscribed.
+     */
+    observed(type: RecordType, facet: "bodies"): boolean;
     /**
      * Delivers a completed record to `type`'s listeners, synchronously: how a
      * runtime publishes. Snapshot semantics without a snapshot — the listener
@@ -299,11 +331,32 @@ export interface Observe {
      * and stores created under it are excluded subjects wherever their writes
      * come from (a click handler, an adapter callback), so writes need no
      * `runWithOwner` — and must not use one: a write under an owner is a write
-     * in an owned scope (REACTIVE_WRITE_IN_OWNED_SCOPE). Irrevocable for the
-     * owner's lifetime.
+     * in an owned scope (REACTIVE_WRITE_IN_OWNED_SCOPE). One mark per owner:
+     * a later `exclude` or `include` on the same owner replaces it, and
+     * `include` re-admits a subtree beneath it.
      */
     exclude(owner: Owner): void;
-    /** Whether `subject` sits under an excluded owner (itself included). */
+    /**
+     * Marks `owner`'s subtree as the app's again, beneath an excluded owner.
+     * The verdict for a subject is the NEAREST marked ancestor's (the subject
+     * itself included): an `include` under an `exclude` re-admits that
+     * subtree, an `exclude` under an `include` excludes it again, and the
+     * markers nest to any depth. For an observer that WRAPS the app it
+     * watches — a toolbar rendering `<DevToolbar><App/></DevToolbar>` — so
+     * the toolbar's own root is excluded and the app's root, created under
+     * it, is included back. Mark the root as it is created, as with
+     * `exclude`: the attribution engine caches each node's verdict the first
+     * time it asks and keeps it for the node's life, so a mark set after a
+     * node was judged does not reach it. Alone — with no excluded ancestor —
+     * an included owner is what it already was. One mark per owner: a later
+     * `exclude` or `include` on the same owner replaces it.
+     */
+    include(owner: Owner): void;
+    /**
+     * Whether `subject` sits under an excluded owner (itself included) — the
+     * nearest marked ancestor on its owner chain answers, with the one mark
+     * (the latest `exclude`/`include`) that owner carries.
+     */
     isExcluded(subject: DiagnosticSubject | null | undefined): boolean;
     /**
      * Root-first names of the owners enclosing `subject` (inclusive when the

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

@@ -1,4 +1,3 @@
-import { type Transition } from "./scheduler.js";
 import type { Computed, NodeOptions, Owner } from "./types.js";
 export interface Effect<T> extends Computed<T>, Owner {
     _effectFn: (val: T, prev: T | undefined) => void | (() => void);
@@ -7,12 +6,6 @@ export interface Effect<T> extends Computed<T>, Owner {
     _prevValue: T | undefined;
     _type: number;
     _boundRunEffect?: (type: number) => void;
-    /** The transaction whose staged view produced `_value` (null = committed
-     * view). Effects have one value slot and do not entangle transactions, so
-     * a second transaction recomputing the same effect overwrites a value the
-     * first one still owes a run for; see the contested-effect arm of recompute
-     * (#3322). */
-    _valueTransition: Transition | null;
 }
 /**
  * Effects are the leaf nodes of our reactive graph. When their sources change, they are

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

@@ -1,4 +1,10 @@
 import type { Computed, Link, Signal } from "./types.js";
+/** The store's shared slot-node release handler (store/store.ts installs it
+ * once) — a live binding read directly by the sweep site: no wrapper frame,
+ * no null check (a CONFIG_SLOT_NODE node existing implies the store module
+ * loaded and registered it). */
+export declare let slotUnobservedHook: (node: Signal<any>) => void;
+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;
@@ -25,4 +31,4 @@ export declare function unobserved(el: Computed<unknown>): void;
  */
 export declare const dormantNodes: Set<Computed<unknown>>;
 export declare function sweepDormant(): void;
-export declare function link(dep: Signal<any> | Computed<any>, sub: Computed<any>, pendingObserver?: boolean): void;
+export declare function link(dep: Signal<any> | Computed<any>, sub: Computed<any>): void;

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

@@ -1,12 +1,10 @@
 import type { Computed } from "./types.js";
-/** The queue a node belongs to, picked from its own zombie flag. */
-export declare function queueFor(n: Computed<any>): Heap;
 /**
- * Schedule one subscriber to re-run on the next flush: inserted into its own
- * (zombie-flag-routed) heap with the `_min` cursor pulled down. Tracked
- * effects ride the heap too — the heap visit is their (empty) compute phase,
- * which hands the callback to the user queue once the pass has committed
- * (see GlobalQueue._update, #3291).
+ * Schedule one subscriber to re-run on the next flush: inserted into the
+ * dirty heap with the `_min` cursor pulled down. Tracked effects ride the
+ * heap too — the heap visit is their (empty) compute phase, which hands the
+ * callback to the user queue once the pass has committed (see
+ * GlobalQueue._update, #3291).
  */
 export declare function enqueueSub(node: Computed<any>): void;
 export interface Heap {