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

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

@@ -1,22 +1,131 @@
 import { type Heap } from "./heap.js";
-import { activeLanes, assignOrMergeLane, findLane, type OptimisticLane } from "./lanes.js";
 import type { Computed, Signal } from "./types.js";
-export { activeLanes, assignOrMergeLane, findLane };
-export { getOrCreateLane, hasActiveOverride, mergeLanes, resolveLane } from "./lanes.js";
-export declare const transitions: Set<Transition>;
+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. */
+    _nodes: Signal<any>[];
+    /** Stashed effect queues (render, user): run ahead of the landing flush's. */
+    _queues: [QueueCallback[], QueueCallback[]];
+    /** Render effects that read a held node as committed (A15's stale
+     * readers): re-derived after the landing. One entry per pass. */
+    _reruns: Computed<any>[];
+    /** Merged into another (overlap): resolve through it (`txOf`). */
+    _into: Transaction | null;
+    /** Lane: the transition it is a sub-frame of — it reads that world through
+     * and ends with it. */
+    _parent: Transaction | null;
+    /** A lane. Cleared when a blocked lane outlives its parent and continues
+     * as a transaction. */
+    _lane: boolean;
+    /** The lane the readers of this transaction's verdicts (`isPending`,
+     * `latest`) break out into — a guess the system supplies: "pending, until
+     * this lands", "the proposal is the value". Opened at the first such read,
+     * ends with the transaction. */
+    _verdict: Transaction | null;
+    /** Actions (action.ts) still running in it: held open — blocked — until
+     * every one has returned. Summed when transactions merge. */
+    _open: number;
+    /** An action ran in it (action.ts). Its body ending (`_open` back to 0)
+     * supersedes the guesses still in force whose own truth is not in flight
+     * (A18 body-end corollary, #3427; lanes.ts). */
+    _acted: boolean;
+    /** Lane: the lanes a frame derives from together with this one (a pass
+     * read two lanes' work — #3335): one reveal unit, each blocked while any
+     * is; shared array. Lifetimes stay their own (#2912). */
+    _links: Transaction[] | null;
+    /** Lane: it has revealed — its values are the screen (`display`,
+     * lanes.ts) and its passes stage for the next reveal. Set at the first
+     * seam it is not blocked; a verdict lane is born shown. */
+    _shown: boolean;
+    /** Lane: the last seam found it blocked (its own flight up). A frame
+     * leaf reading a held lane that has not shown is a stale reader of it
+     * (#3460); one reading a lane the seam has not judged yet is its work. */
+    _held: boolean;
+    /** `affects()` marks declared in it (affects.ts): released at the landing.
+     * Not nodes — a mark holds nothing (`blocked` never sees one). */
+    _marks: Signal<any>[] | null;
+}
+/** A transaction (listed here) or a lane (lanes.ts lists its own). */
+export declare function newTransaction(lane: boolean, parent?: Transaction | null): Transaction;
+/** The lane the running pass is work of; set at `recompute`'s head from the
+ * node, moved by a derivation's lane read, saved and restored around the
+ * pass. */
+export declare let passLane: Transaction | null;
+export declare function setPassLane(l: Transaction | null): void;
+/** The transaction this flush parks into: set by the first join, merged
+ * with every further one. Consumed at the seam. A join outside a flush (a
+ * mount's pending observer, a write to a held node, an action opening)
+ * schedules the seam that consumes it: membership is the tick's — the same
+ * synchronous frame — and the next tick's writes are not this one's. */
+export declare let flushTransaction: Transaction | null;
+/** The transaction the passes running OUTSIDE a flush this tick derive from
+ * (a mainline mount, a mainline re-pass): the passes' own (A29, creation-
+ * time form — "the entry is the pass's alone"): their results are staged
+ * into it, and nothing else in the tick is — a write made after the mount
+ * is a mainline write, a render effect mounted beside it a stale reader.
+ * Inside a flush, or in a tick that already has its transaction (an
+ * action's body), the frame joins instead (`flushTransaction`) — except a
+ * first pass a loading boundary that has not shown content catches (`own`,
+ * A29's boundary exemption, #3540): it is the boundary's, not the tick's,
+ * and a flush that has joined nothing keeps it pass-scoped as outside one.
+ * Cleared by the flush the join schedules, and at the end of a flush that
+ * set it. */
+export declare let passTx: Transaction | null;
+export declare function joinPassTx(t: Transaction, own?: unknown): void;
+/** The transaction holding a node (CONFIG_HELD set), resolved through
+ * merges; the path is compressed. */
+export declare function txOf(n: Signal<any> | Computed<any>): Transaction;
+/** `t` resolved through merges while it is still parked or open; null once
+ * it has landed. */
+export declare function liveTx(t: Transaction): Transaction | null;
+export declare function resolveTx(t: Transaction): Transaction;
+/** The flush joins transaction `t` — or needs one of its own (`null`: a pass
+ * went pending with nothing held). Joining a second one merges it into the
+ * flush's: the work that touched both entangles them (A15). */
+export declare function joinFuture(t: Transaction | null): void;
+/** `t` merges into `f`: the work that touched both entangles them (A15).
+ * A lane never merges: it is a sub-frame, not a peer — its work is routed
+ * per pass (`passLane`). */
+export declare function merge(t: Transaction, f: Transaction): void;
+/** A15: a hold is a property of the async node — observed pending by a
+ * render reader. A transaction is blocked while a node it holds, in flight,
+ * has one: a pending render effect (the frame itself), or a pending held
+ * node a render effect reads. A stale reader served the committed value
+ * never went pending, but derives from the flight all the same (#3494) and
+ * is still linked to it; a memo between them is pending, and held, too — so
+ * one hop of `_subs` is the chain. Reads of the reader's LAST pass only (the
+ * link's generation is the pass's): a tail kept for A30 — the committed
+ * frame's dependency, awaiting the run that retires it — is not a read of
+ * the flight, and a reader that stopped reading releases it (O3, #3494).
+ * An errored pass (NotReady included) did not stop: it never got there, and
+ * its full list stands (A30) — the reads it did not reach still observe. A
+ * flight nobody renders holds nothing (A29). Only the nodes `t` still owns
+ * count: one a lane took over since is the lane's to wait on. A guess whose
+ * own truth is in flight blocks the lane's parent, not the lane — it stands
+ * in for the flight (A17: "visible until its own fetch settles"). */
+export declare function blocked(t: Transaction): boolean;
+/** Observe tier: the flights `t` waits on — its pending held sources a
+ * frame reader observes (`blockedBy`'s predicate, collected; the readers
+ * themselves are not sources). */
+export declare function blockersOf(t: Transaction): Computed<any>[];
+/** `t`'s own flights only — not its lanes': a flight the frame asked for
+ * (a refetch, a plain load) is authoritative; a lane's derivation flight is
+ * not (lanes.ts, the body-end corollary). A pending reader counts only if
+ * one of the sources it waits on is `t`'s (a render effect marked pending
+ * by a lane flight, never re-run, is the lane's wait, not the frame's). */
+export declare function ownFlights(t: Transaction): boolean;
+export declare function heldTrim(el: Computed<any>): void;
+export declare function deferZombie(el: Computed<any>): void;
+/** Put a staged node in a transaction: flagged, stamped, on its landing
+ * list. */
+export declare function holdNode(n: Signal<any>, t: Transaction): void;
+/** Put a node on a transaction's list, once: a node's `_transaction` is the
+ * 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;
 export declare const dirtyQueue: Heap;
-export declare const zombieQueue: Heap;
 export declare let clock: number;
-export declare let activeTransition: Transition | null;
-export declare let projectionWriteActive: boolean;
-/** > 0 while an action's generator body is on the stack (the synchronous
- * slice between yields). Maintained by action.ts around `it.next()`. */
-export declare let actionStepDepth: number;
-export declare function enterActionStep(): void;
-export declare function exitActionStep(): void;
 export declare let _hitUnhandledAsync: boolean;
-/** Slot hook's deferral: release this node when its carried state resolves. */
-export declare function deferSlotRelease(node: Signal<any>): void;
 /**
  * Consume the unhandled-async hit. Returns whether this is the first report
  * of the current enforcement window — the caller warns only then.
@@ -31,104 +140,28 @@ export declare function resetUnhandledAsync(): boolean;
  * @internal
  */
 export declare function enforceLoadingBoundary(enabled: boolean): void;
-export declare function setProjectionWriteActive(value: boolean): void;
 export declare function setTrackedQueueCallback(value: boolean): void;
+/** Action bodies on the stack (action.ts): `flush()` is refused inside one —
+ * the body's writes are its transaction's and commit when it settles; a
+ * drain mid-step cannot reveal them, and dev says so. */
+export declare let actionDepth: number;
+export declare function enterAction(): void;
+export declare function exitAction(): void;
+/** Provenance (A18, #3331): the question being asked — an action's
+ * sequence while a slice of its body and the flush that carries it run, 0
+ * otherwise. A guess is stamped with it (lanes.ts; a mainline guess takes a
+ * fresh sequence: the newest intent), a flight with the question that
+ * started it (async.ts; mainline is always the current question). An
+ * answer from an older question than the guess it lands on is stale: held
+ * silently, it does not move the graph. */
+export declare let question: number;
+export declare function setQuestion(q: number): void;
+export declare function nextQuestion(): number;
+export declare const MAINLINE_QUESTION = 2147483647;
+export declare let inEffectCallback: boolean;
 export declare function setEffectCallback(value: boolean): void;
 export type QueueCallback = (type: number) => void;
-type QueueStub = {
-    _queues: [QueueCallback[], QueueCallback[]];
-    _children: QueueStub[];
-};
-type OptimisticNode = Signal<any> | Computed<any>;
-export interface Transition {
-    _time: number;
-    _asyncReporters: Map<Computed<any>, Set<Computed<any>>>;
-    _pendingNodes: Signal<any>[];
-    _optimisticNodes: OptimisticNode[];
-    _affectsNodes: OptimisticNode[];
-    _optimisticStores: Set<any>;
-    _actions: Array<Generator<any, any, any> | AsyncGenerator<any, any, any>>;
-    /** An action ran in this transaction (#3427, set by action()): once
-     * `_actions` drains, its bodies are OVER — as opposed to a transaction that
-     * never had one, whose bare optimistic writes live until it settles. */
-    _acted?: boolean;
-    _queueStash: QueueStub;
-    _done: boolean | Transition;
-    _gatedSubs: Set<Computed<any>>;
-    /** Effects whose single value slot was written under this transaction AND
-     * another live one (#3322). Re-dirtied at commit, ahead of the effect
-     * phase, so the run publishes a value derived from the committed world
-     * rather than whichever transaction's staged view wrote last. */
-    _contested: Computed<any>[] | null;
-}
-/**
- * Flip-entanglement (#3164 follow-up): `until()` is a declaration of
- * relatedness — the predicate names the condition that confirms the awaiting
- * transaction. When the predicate settles truthy, every live foreign
- * transition whose staged write it read IS the confirming event by the
- * user's own definition, so it merges into the awaiting transaction and
- * reveals at the joint settle — the cross-primitive twin of the family fold
- * (a landing on an optimism-carrying family joins the retaining
- * transaction). Non-flipping updates never pass through here: falsy
- * evaluations don't entangle, so unrelated traffic on the watched sources
- * reveals freely on its own schedule.
- *
- * Runs inside the predicate's compute (pure phase) — the confirming
- * transition's stamps are still live and its commit decision hasn't run, so
- * the merge lands before any reveal. Only the tree-shaken graphs that call
- * `until()` retain this.
- */
-export declare function entangleConfirmingTransitions(obs: Computed<any>, target: Transition): void;
 export declare function schedule(): void;
-/** Arm the microtask `schedule()` withheld under projectionWriteActive. The
- * projection draft calls this after a write made outside its run with no
- * flight up (proj R37): nothing else will drain, and leaving `scheduled`
- * armed with no microtask strands the whole scheduler — every later
- * `schedule()` early-returns — until something calls `flush()` by hand.
- * (`withheld` was set in the same synchronous slice as this call, so the
- * syncDepth/_running gates it passed still hold; a stale mark left by a
- * landing's own flush arms at worst one no-op drain.) */
-export declare function scheduleWithheld(): void;
-/**
- * Parked transactions whose reporter set changed without a write. A
- * transaction completes when nothing live reports a flight it waits on, but
- * the flush only judges the ACTIVE transaction: a parked one is re-entered by
- * a stamped node's landing or an action's resume. A reporter that stops
- * counting for another reason — its loading boundary flipped to the fallback
- * (#3375), or it was disposed by ambient work (#3372) — is neither: the
- * pruning in `reporterBlocksSource` would drop it at the next check, but no
- * check comes, and the writes held with it stay staged. Such sites record the
- * transaction here (deduped: one idle pass per transaction, however many
- * reporters changed); the flush re-enters it on an otherwise idle pass, so
- * the re-evaluation adopts no unrelated ambient work.
- */
-export declare const wokenTransitions: Transition[];
-/** Wake every parked transaction — for a site that knows a reporter stopped
- * counting but not whose (a boundary reset). */
-export declare function wakeParked(): void;
-/** A boundary that can be re-armed (boundaries.ts `CollectionQueue._rearm`). */
-export interface Rearmable {
-    _rearm(): void;
-}
-/**
- * Boundaries whose `on` dependencies notified this flush (#3540; a Set:
- * many notifications, one re-arm). The notification arrives inside a pass,
- * at the height of the `on` reads — before the readers the write put in
- * flight are registered — so the re-arm waits for the heap and runs before
- * the verdict (GlobalQueue.run → drainRearms), still under the write's
- * transaction: the release is seen by the verdict that follows, and the
- * staged fallback swap lands with the write's frame.
- */
-export declare const pendingRearms: Set<Rearmable>;
-export declare function queueRearm(boundary: Rearmable): void;
-/** Transactions a mainline tick has PROPOSED against (A34, #3494): a write to a
- * node one of them holds — the same value or another — is a second proposal
- * on a contested node, and the tick reveals with the hold ("both are
- * suggesting a value; if one finished before the other that would be odd").
- * Entered at the next flush's start, where the ambient batch is adopted;
- * never from the write itself, which left `activeTransition` set across the
- * caller's block and made creation after the write the transaction's (A29). */
-export declare const batchJoins: Transition[];
 /**
  * Permanently halts the reactive system. Called when a user error escapes
  * every boundary — app state is undefined at that point, so scheduling stops
@@ -148,188 +181,130 @@ export declare function resetErrorHalt(): void;
 export interface IQueue {
     enqueue(type: number, fn: QueueCallback): void;
     run(type: number): boolean | void;
-    addChild(child: IQueue): void;
-    removeChild(child: IQueue): void;
-    created: number;
     notify(node: Computed<any>, mask: number, flags: number, error?: any): boolean;
-    stashQueues(stub: QueueStub): void;
-    restoreQueues(stub: QueueStub): void;
-    _parent: IQueue | null;
-    /** Loading/error boundary queues (boundaries.ts): the status dimension the
-     * queue consumes, and whether it currently shows content (initialized) or
-     * its fallback (collecting). Read by `reporterBlocksSource`. */
-    _collectionType?: number;
-    _initialized?: boolean;
 }
-export declare class Queue implements IQueue {
-    _parent: IQueue | null;
+export declare class GlobalQueue implements IQueue {
     _queues: [QueueCallback[], QueueCallback[]];
-    _children: IQueue[];
-    _ranAt: number;
-    created: number;
-    addChild(child: IQueue): void;
-    removeChild(child: IQueue): void;
-    notify(node: Computed<any>, mask: number, flags: number, error?: any): boolean;
-    run(type: number): void;
-    enqueue(type: number, fn: QueueCallback): void;
-    stashQueues(stub: QueueStub): void;
-    restoreQueues(stub: QueueStub): void;
-}
-export declare class GlobalQueue extends Queue {
     _running: boolean;
-    _batch: Transition;
     static _update: (el: Computed<unknown>) => void;
-    static _dispose: (el: Computed<unknown>, self: boolean, zombie: boolean) => void;
+    static _dispose: (el: Computed<unknown>, self: boolean, zombie?: boolean) => void;
     static _runEffect: (el: Computed<unknown>) => void;
-    static _clearOptimisticStores: ((stores: Set<any>, completing: Transition | null) => void) | null;
-    static _releaseAffectsScope: ((node: OptimisticNode) => void) | null;
-    static _releaseAffectsMarks: ((nodes: OptimisticNode[]) => void) | null;
-    static _markAffects: ((node: OptimisticNode) => void) | null;
-    static _releaseAffectsMark: ((node: OptimisticNode) => void) | null;
-    static _wireExternalSource: ((self: Computed<any>) => void) | null;
-    static _externalUntrack: (<T>(fn: () => T) => T) | null;
-    static _syncCompanions: (<T>(el: Signal<T> | Computed<T>, value: T) => void) | null;
-    static _updatePendingSignal: ((el: OptimisticNode) => void) | null;
-    static _updateChildCompanions: ((el: Computed<any>) => void) | null;
-    static _snapCompanions: ((el: OptimisticNode) => void) | null;
-    static _latestRead: (<T>(el: Signal<T> | Computed<T>) => T) | null;
-    static _pendingCheck: ((el: OptimisticNode, c: Computed<any> | null, owner: OptimisticNode, firewall: Computed<any> | null) => void) | null;
-    static _recordFresh: ((el: OptimisticNode, value: any) => void) | null;
-    static _applyReask: ((el: Computed<any>, hadReask: boolean) => boolean) | null;
-    static _repollVerdicts: ((el: Computed<any>, snap?: boolean) => void) | null;
-    static _witnessAffects: ((node: OptimisticNode) => void) | null;
-    static _wakeSuppressedProbes: ((transition: Transition) => void) | null;
-    static _optimisticWrite: (<T>(el: Signal<T> | Computed<T>, v: T | ((prev: T) => T)) => T) | null;
-    static _resolveOptimistic: ((nodes: OptimisticNode[]) => void) | null;
-    static _transitionBlocked: ((transition: Transition) => boolean) | null;
-    static _cleanupLanes: ((completingTransition: Transition | null) => void) | null;
-    static _runLaneEffects: ((type: number) => void) | null;
-    /** Patch-channel optimistic drain (next/patch.ts): optimistic emissions
-     * apply at lane-effect timing — visible in flight, unlike the regular
-     * effect queues an action stashes. Injected; null when unused. */
-    static _drainPatchOptimistic: (() => void) | null;
-    static _gatedRead: ((el: Signal<any>, owner: OptimisticNode, c: Computed<any>) => boolean) | null;
-    static _laneSuspends: ((owner: OptimisticNode) => boolean) | null;
-    /** Is the node routed through a LIVE lane (`resolveLane`)? read()'s reveal
-     * carve-out asks before showing a foreign-held pending node's committed
-     * value: a lane-derived flight's inputs are already revealed through the
-     * lane (#3334). Gated on CONFIG_HAS_LANE, which only the engine sets. */
-    static _laneLive: ((el: Computed<any>) => boolean) | null;
-    static _laneReadsCommitted: ((el: OptimisticNode, owner: OptimisticNode, c: Computed<any>) => boolean) | null;
-    static _recomputeLane: ((el: Computed<any>, own: boolean) => OptimisticLane | null | false) | null;
-    static _laneAsyncPending: ((el: Computed<any>) => void) | null;
-    /** Authoritative-view reader wakeup: installed by until() and refresh() before
-     * their first read. Call sites are gated by CONFIG_AUTHORITATIVE_OBSERVED, which
-     * only such a reader's carve-out read can set, so `!` invocations are safe once
-     * the gate holds (#3303). */
-    static _notifyAuthoritativeObservers: ((el: Signal<any> | Computed<any>) => void) | null;
-    static _laneAsyncSettled: ((el: Computed<any>) => void) | null;
-    /** A18 supersession (#3331): own-source truth `value` landed under an active
-     * override. The engine decides whether the graph re-derives — the value
-     * differs from the override and is not a stale (older-action) answer (mark
-     * the node, demote its lane cascade, notify), or returns to it after an
-     * earlier differing arrival (clear the mark, notify) — and owns the
-     * authoritative-observer wake for a silent confirm. Installed with the
-     * optimistic engine; only reachable on a node that has an override. */
-    static _supersedeOverride: ((el: Signal<any> | Computed<any>, value: unknown) => void) | null;
-    /** The flush's pre-verdict step (#3427): once the transaction's action
-     * bodies have all ended and nothing authoritative is left in flight, the
-     * engine supersedes every override still in force with the truth it
-     * reverts to, so the graph re-derives from it now, as the transaction's
-     * held work, instead of after the flights the overrides fed have landed.
-     * True when it superseded something: the caller re-runs the heap ahead of
-     * the verdict. The engine owns every gate (acted, actions drained, has
-     * overrides, no store edits, no authoritative flight); null without it. */
-    static _endOptimism: ((transition: Transition) => boolean) | null;
-    /** read()'s value for a TRACKED reader of a superseded node (#3331): the
-     * staged truth, unless the reader is a stale (render) reader of another
-     * transaction — then the displayed override, as it keeps a foreign
-     * transaction's committed value over its staged write. */
-    /** A tracked read of an active override: the lane outside-view rule
-     * (#3460) and the A18 supersession selection (#3331) — see optimistic.ts. */
-    static _overrideRead: ((el: Computed<any>, c: Computed<any>) => unknown) | null;
-    /** A lane pass's publish for a memo (#3479, lanes stage): the speculative
-     * result becomes a DERIVED override, `_value` stays committed — see
-     * optimistic.ts laneOverride. Set with the engine, which a lane implies. */
-    static _laneOverride: ((el: Computed<any>, value: unknown, lane: OptimisticLane) => void) | null;
-    /** Verdict-layer recompute in progress (companion creation, latest()/
-     * isPending() pulls): never born held — see core.ts enterStagedRead. */
-    static _verdictPull: boolean;
-    /** setSignal's authoritative (projection-write) landing on an override-
-     * covered node (#3331 store twin): stage the truth for its transaction's
-     * commit whatever its relation to the committed value — a landing equal to
-     * committed still differs from the override — then _supersedeOverride
-     * decides. Installed with the optimistic engine; only reachable on a node
-     * that has an override — or, from `mapArray` once a lane pass has run over
-     * the map, on a per-slot signal (never CONFIG_OPTIMISTIC): the slot arm
-     * publishes a lane pass's write as the slot's derived override, lands a
-     * plain pass's write over one, and is the plain `setSignal` otherwise (F1,
-     * see optimistic.ts landOnOverride). */
-    static _landOnOverride: (<T>(el: Signal<T> | Computed<T>, v: T | ((prev: T) => T)) => T) | null;
-    static _trackOptimisticStore: ((store: any) => void) | null;
+    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;
+    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;
+    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
+     * transaction no frame is waiting on. The landing flush is an ordinary
+     * flush: the settle walk (async.ts) re-ran the parked readers in its pure
+     * phase, and here no flight the transaction holds has a frame deriving
+     * from it (`blocked`). */
+    settle(): void;
+    run(type: number): void;
+    enqueue(type: number, fn: QueueCallback, lane?: Transaction | null): void;
+    /** Status reaching the root: pending is absorbed (the root mount defers —
+     * dev records it for the ASYNC_OUTSIDE_LOADING_BOUNDARY FYI); an error is
+     * unhandled (`false` → the caller halts).
+     *
+     * L2: this is where a transaction is registered. Pending that reaches an
+     * observer (a render effect: the frame) is a frame that cannot show — the
+     * flush parks, and the transaction waits on the flight while a frame
+     * derives from it (`blocked`). Pending nobody observes holds nothing: a
+     * memo in flight that no frame reads is not a frame waiting. (Base: the
+     * queue's `_asyncReporters`, INV-3's one registration site.)
+     *
+     * A boundary between the observer and the root (boundaries.ts) is asked
+     * first: a fallback catches what is not ready under it, and the root
+     * never hears of it. */
     notify(node: Computed<any>, mask: number, flags: number, error?: any): boolean;
-    initTransition(transition?: Transition | null): void;
 }
+/** A15's stale readers: a frame whose LAST pass read a held node as
+ * committed re-derives on the landed world — next round, after the commits.
+ * One re-derived since (any later pass cleared the bit: in the transaction,
+ * or without the held read) owes nothing. A run this transaction stashed
+ * for it is void (#3322: an effect has one value slot, and the stale pass
+ * overwrote the value that run was for) — the re-derivation's run replaces
+ * it. */
+export declare function reruns(u: Transaction): void;
+/** The held runs join this flush's effect phase after its own runs (the
+ * landing's re-passes, in height order): the frame's effects run as one
+ * pass would have queued them — a shell re-derived at the landing before a
+ * boundary swap held since the write (#3540's log order). */
+export declare function releaseQueues(u: Transaction): void;
+/** Passes that read a staging of this flush as the screen — lane work
+ * (core.ts `stagedRead`), a verdict reader before the frame's verdict
+ * (verdict.ts): if the frame parks they read a held write — re-derived next
+ * round (lanes.ts; a lane's runs wait that round). */
+export declare const stagedReaders: Computed<any>[];
+/** A15's stale reader: `c` was served the committed value of a node `t`
+ * holds (a render effect, a verdict reader, lane work) and is re-derived
+ * after `t`'s landing (`_reruns`). Once per pass. */
+export declare function staleReader(c: Computed<any>, t: Transaction): void;
 export declare function queuePendingNode(node: Signal<any>): void;
-export declare let reaskArmed: boolean;
 /** §12d: bumped by every recompute and every new subscriber edge. A node's
  * staged-rewrite skip is sound only while NOTHING recomputed or linked since
  * its last notify — a mid-batch pull can clean a marked subscriber, and a
  * skipped re-write would leave it stale. */
 export declare let notifyEpoch: number;
 export declare function bumpNotifyEpoch(): void;
-export declare function armReaskClear(): void;
-/** Provenance of the work currently running (A18 supersession, #3331): the
- * invocation sequence of the action whose ambient window this is — set by
- * action() for each slice; the flush that ends the window clears it — or,
- * inside an async landing, the sequence captured when that flight was
- * registered (asyncWrite sets it for the landing's synchronous propagation,
- * so a sync recompute downstream of the landing — an optimistic wrapper over
- * the async source — derives under the flight's provenance, and flights it
- * registers inherit it). 0 is mainline: no action, always the current
- * question. An override stamps this at its write (`_overrideStamp`); an
- * answer whose flight an OLDER action issued is a stale question the user
- * has since changed — it holds silently to commit instead of superseding. A
- * slow source must not leak back in over a newer intent. Transactions merge,
- * so the transition object cannot say WHICH action asked; this can. */
-export declare let origin: number;
-export declare function setOrigin(seq: number): number;
-export declare function insertSubs(node: Signal<any> | Computed<any>, optimistic?: boolean): void;
-export declare let storeCommitHook: (() => void) | null;
-export declare function setStoreCommitHook(fn: () => void): void;
-/** Patch-channel release hook (next/patch.ts): transition-stamped patch
- * emissions are released when THEIR batch commits. Transitions never
- * abort: failed actions still commit (only optimistic overrides revert),
- * and merged-away transitions hand their stash to the survivor
- * (mergeTransitionState) — every stash drains exactly once. Injected like
- * storeCommitHook to stay tree-shakeable. */
-export declare let patchCommitHook: ((batch: Transition) => void) | null;
-export declare function setPatchCommitHook(fn: (batch: Transition) => void): void;
-/** Unchanged passes with a stale dependency tail, waiting on this flush's
- * verdict (A30, #3469). A pass that changed nothing replaced nothing either —
- * and cannot know at its own tail whether the flush that ran it will park:
- * parked, its inputs are held and the committed frame still derives from the
- * tail (`b() ? b() : a()` computed `1` from the held `b`, equal to the `1` it
- * had from `a` — with `a` trimmed, the mainline `a = 2` never reached it).
- * Trimmed when the flush commits; dropped with a park, the tail stays linked
- * until a committing pass trims it (one spurious recompute at most). */
-export declare const heldTrims: Computed<any>[];
-export declare function finalizePureQueue(completingTransition?: Transition | null, incomplete?: boolean): void;
-/**
- * Count of live `affects()` registrations across the system (including
- * store-scope inherited marks). Gates the read-path mark check in `read()` so
- * graphs that never use the feature pay one integer compare.
- */
-export declare let activeAffectsMarks: number;
-/**
- * Counter mutation seam for the mark engine in affects.ts: an imported `let`
- * binding is read-only, and the read-path gate above must stay a plain module
- * variable so `read()` pays one integer compare, not a function call.
- *
- * @internal
- */
-export declare function shiftAffectsMarks(delta: 1 | -1): void;
+export declare function insertSubs(node: Signal<any> | Computed<any>): void;
+/** Lane work re-staged (lanes.ts; `recompute`): the lane's members among
+ * its subscribers re-derive as the lane's work (REACTIVE_LANE_DIRTY), their
+ * runs held with it — not as stale readers republishing the committed view
+ * (#3460). After `insertSubs`. A render effect on no lane is marked too:
+ * inert for its pass (`recompute` seats a lane only from its own `_x`), it
+ * is a live write if the effect becomes a zombie later this flush — an
+ * on-screen reader whose removal an adopted write stages follows the lane
+ * (the lane-membership ruling, 2026-10-05; `_update`). */
+export declare function laneDirty(node: Signal<any> | Computed<any>, l: Transaction): void;
+/** One lane, or two of one link group (#3335): one reveal unit. */
+export declare function sameLane(a: Transaction, b: Transaction): boolean;
+export declare function commitPendingNode(n: Signal<any>): void;
 export declare const globalQueue: GlobalQueue;
 /**
  * Synchronously processes the pending reactive queue, or runs `fn` in a synchronous
@@ -364,60 +339,3 @@ export declare const globalQueue: GlobalQueue;
  */
 export declare function flush(): void;
 export declare function flush<T>(fn: () => T): T;
-/** Does `reporter` still hold the transaction waiting on `source` — live,
- * routed to no collecting loading boundary, and deriving from the source in
- * its current pass? The verdict's per-reporter test (sourceObserved), also
- * a boundary re-arm's (boundaries.ts `_rearm` runs before the verdict prunes
- * registrations that stopped counting). */
-export declare function reporterBlocksSource(reporter: Computed<any>, source: Computed<any>, verdict?: Transition): boolean;
-/**
- * Does a live reporter of `transition` still observe `source` pending? Dead
- * reporters (disposed, behind a fallback, no longer reading the source) are
- * pruned as they are found, and the source's entry with them. Shared by the
- * settle verdict and the lane's hold check (`waitingTransition`): a live
- * action parks its transaction without a verdict, so this prune is the only
- * one an optimistic lane whose last async reader unmounted mid-action ever
- * gets — without it the lane held on the dead reporter's registration until
- * the flight it no longer observed landed (#3426).
- */
-export declare function sourceObserved(transition: Transition, source: Computed<any>, verdict?: Transition): boolean;
-/** A fresh, unentered transaction (#3146): the optimistic store's truth
- * flight DECLARES an owned transaction instead of relying on whatever the
- * ambient adoption machinery stamped on its firewall. Activate it with
- * initTransition; it is a plain batch until then. */
-export declare function createTransition(): Transition;
-export declare function currentTransition(transition: Transition): Transition;
-/**
- * The live transition blocked on `source` — the one whose render reader
- * observed it pending (INV-3 records the observation in whichever transaction
- * was active when the reader was notified). The observation is a fact about
- * the node, so a hold check must not assume it was recorded in the transaction
- * it happens to hold — lanes merge across transactions (#2912), and a merged
- * root's transaction knows nothing of the async its members' transactions
- * observed (#3335). Null when nobody is waiting — a registration whose every
- * reporter has since died is nobody (#3426).
- */
-export declare function waitingTransition(source: Computed<any>): Transition | null;
-/** A landing enters EVERY parked transaction still waiting on `source`, folding
- * them into the active one (A15: each reveal that discovered the flight
- * completes at its landing). The fold used to happen as the waiters' stamped
- * readers recomputed under the landing — recompute re-entering an effect's
- * stamp — which also folded in writes those readers merely shared a hole
- * with (#3407); effects no longer re-enter, so the landing folds explicitly.
- * Live iteration is safe: a merge deletes the outgoing (active) entry and
- * re-adds the visited one. */
-export declare function enterWaiting(source: Computed<any>): void;
-export declare function setActiveTransition(transition: Transition | null): void;
-export declare function runInTransition<T>(transition: Transition, fn: () => T): T;
-/** Run `fn` with `transition` as BOTH the ambient transaction and the
- * registration batch, restoring both after. runInTransition alone is not
- * enough for code that WRITES on behalf of a transaction from inside someone
- * else's window (optimistic replay re-arming a still-open action's edits
- * during a landing commit, #3123): registrations route through the queue's
- * batch pointer, and a bare activeTransition swap leaves them in the ambient
- * batch — a plain batch "completes" at the next flush and reverts optimistic
- * registrations that were supposed to live with the transaction.
- * initTransition is the wrong tool here: it MERGES the currently ambient
- * transaction into the target, entangling whatever the interrupted window
- * belonged to. */
-export declare function runAsTransitionBatch<T>(transition: Transition, fn: () => T): T;