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

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

@@ -1,15 +1,208 @@
+import { type DiagnosticSubject } from "./dev.js";
 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";
+import type { Computed, Owner, Signal } from "./types.js";
+export declare let laneReadHook: ((c: Computed<any> | null, el: Signal<any> | Computed<any>) => unknown) | null;
+export declare let laneStageHook: ((el: Computed<any>, l: Transaction, create: boolean, errored: boolean | Computed<any>) => boolean) | null;
+export declare let laneOutcomeHook: ((el: Computed<any>, value: unknown, errored: boolean) => boolean) | null;
+export declare let laneWriteHook: (<T>(el: Signal<T> | Computed<T>, v: T) => T) | null;
+export declare let applyGuessesHook: ((parent: Transaction | null) => void) | null;
+export declare let laneSeamsHook: ((t: Transaction | null) => void) | null;
+export declare let laneCorrectionsHook: (() => boolean) | null;
+export declare let endLanesHook: ((u: Transaction) => void) | null;
+export declare let lanesBlockedHook: ((t: Transaction) => boolean) | null;
+/** R5 (lanes.ts `laneSeams` parks a frame flight): the landing's re-derive
+ * of a reader adopts the flight instead (true: adopted, nothing to queue). */
+export declare let laneAdoptHook: ((r: Computed<any>) => boolean) | null;
+/** core.ts `frameRead` served lane work or a verdict reader a held node's
+ * committed value (lanes.ts `laneServed`). */
+export declare let laneServedHook: ((c: Computed<any>, el: Signal<any> | Computed<any>) => void) | null;
+/** A guess was written (lanes.ts `optimisticWrite`): the arms only a guess
+ * reaches (CONFIG_GUESS) — a build without `createOptimistic` or
+ * `createOptimisticStore` never sets it, and its bundler folds them. */
+export declare let guessing: boolean;
+export declare function armGuessing(): void;
+export declare function installLaneHooks(read: NonNullable<typeof laneReadHook>, stage: NonNullable<typeof laneStageHook>, outcome: NonNullable<typeof laneOutcomeHook>, write: NonNullable<typeof laneWriteHook>, applyGuesses: NonNullable<typeof applyGuessesHook>, seams: NonNullable<typeof laneSeamsHook>, corrections: NonNullable<typeof laneCorrectionsHook>, end: NonNullable<typeof endLanesHook>, blocked: NonNullable<typeof lanesBlockedHook>, adopt: NonNullable<typeof laneAdoptHook>, served: NonNullable<typeof laneServedHook>): void;
+export declare let catchHook: ((node: Computed<any>, flags: number, error: unknown) => unknown) | null;
+export declare let freshHook: ((node: Computed<any>, held?: unknown) => unknown) | null;
+export declare let hiddenHook: ((r: Computed<any>) => unknown) | null;
+export declare let boundarySeamHook: (() => void) | null;
+export declare let heldRunHook: ((node: Computed<any>) => boolean) | null;
+export declare function installBoundaryHooks(caught: NonNullable<typeof catchHook>, fresh: NonNullable<typeof freshHook>, hidden: NonNullable<typeof hiddenHook>, seam: NonNullable<typeof boundarySeamHook>, heldRun: NonNullable<typeof heldRunHook>): void;
+/** Store (store/store.ts): `park` — the flush parked into `t`: the store
+ * materializes and holds the container node of every staging that had none
+ * (a staging needs the node as its home only when something can read the
+ * frame through it; a hold can); `commit` — fold the pending backings whose
+ * container nodes this flush committed (the owned-raw model's one mutation
+ * point). */
+export declare let storeParkHook: ((t: Transaction) => void) | null;
+export declare let storeCommitHook: (() => void) | null;
+export declare function installStoreHooks(park: NonNullable<typeof storeParkHook>, commit: NonNullable<typeof storeCommitHook>): void;
+/** `affects()` marks (affects.ts): the releases at a landing and at the seam
+ * (ambient marks). */
+export declare let releaseMarksHook: ((nodes: Signal<any>[]) => void) | null;
+export declare let releaseAmbientMarksHook: ((parked: Transaction | null) => void) | null;
+export declare function installMarkHooks(release: NonNullable<typeof releaseMarksHook>, releaseAmbient: NonNullable<typeof releaseAmbientMarksHook>): void;
+/** Verdicts (verdict.ts). */
+export declare let observeFlightHook: ((c: Computed<any>, el: Computed<any>) => boolean) | null;
+/** D-25's hold work (verdict.ts `holdWork`): on `source` going pending,
+ * whether verdict reader `n` waits on it instead of re-deriving. */
+export declare let holdWorkHook: ((n: Computed<any>, source: Computed<any>) => unknown) | null;
+export declare function installVerdictHooks(observeFlight: NonNullable<typeof observeFlightHook>, holdWork: NonNullable<typeof holdWorkHook>): void;
+/** External-source bridge (wired by enableExternalSource(); undefined while
+ * no config is active — including after _resetExternalSourceConfig()). */
+export declare let wireExternalSourceHook: ((self: Computed<any>) => void) | undefined;
+export declare let externalUntrackHook: (<T>(fn: () => T) => T) | undefined;
+export declare function setExternalHooks(wire: typeof wireExternalSourceHook, untrack: typeof externalUntrackHook): void;
+export interface Transaction {
+    /** Held staged nodes: committed at the landing. For a lane: its guesses
+     * and its work (their lane values in `_x._lane`), revealed at the seam. */
+    _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;
+    /** Lane: a current truth that differs folded beneath one of its keyed
+     * guesses (lanes.ts `laneWrite`, D-34) — the store's reader of it: a
+     * deriving pass outside the lane, or `latest()` (`c` null), is served
+     * the hold's world from its guesses; NOT_PENDING otherwise
+     * (store/optimistic.ts `foldedRead`). Unset until then; not
+     * `_`-prefixed: a new mangled name shifts every later one
+     * (scripts/mangle-props.mjs), which costs the floors bytes for a path
+     * only optimistic stores reach. */
+    folded?: (c: Computed<any> | null, el: Signal<any> | Computed<any>) => unknown;
+    /** `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 flush's transaction while only a `latest()` read of a staging opened
+ * it (verdict.ts `provisionalVerdict`): it holds nothing, and a verdict
+ * reader's plain read of a staging in it is the frame's read (D-22). */
+export declare let latestOpened: Transaction | null;
+export declare function openedByLatest(): void;
+/** The transaction the passes running OUTSIDE a flush this tick derive from
+ * (a mainline mount, a mainline re-pass): the passes' own (A29, creation-
+ * time form — "the entry is the pass's alone"): their results are staged
+ * 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;
+/** The nodes under `owner` a transaction other than `t` holds (boundaries.ts:
+ * what an earlier hold staged under a re-armed boundary). */
+export declare function heldUnder(owner: Owner, t: Transaction | null, fn: (n: Computed<any>) => void): void;
+/** `n` leaves the hold it was staged in: its next pass publishes mainline. */
+export declare function unhold(n: Signal<any>): void;
 export declare const dirtyQueue: Heap;
-export declare const zombieQueue: Heap;
 export declare let clock: number;
-export declare let activeTransition: Transition | null;
-export declare let projectionWriteActive: boolean;
 export declare let _hitUnhandledAsync: boolean;
-export declare function resetUnhandledAsync(): void;
+/**
+ * Consume the unhandled-async hit. Returns whether this is the first report
+ * of the current enforcement window — the caller warns only then.
+ */
+export declare function resetUnhandledAsync(): boolean;
 /**
  * Toggles the dev-mode "must be inside a `<Loading>` boundary" enforcement
  * window. Only `render()` calls this — wrapping the initial mount so that a
@@ -19,128 +212,184 @@ export declare function resetUnhandledAsync(): void;
  * @internal
  */
 export declare function enforceLoadingBoundary(enabled: boolean): void;
-export declare function setProjectionWriteActive(value: boolean): void;
 export declare function setTrackedQueueCallback(value: boolean): void;
-export declare function setEffectCallback(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;
+/** Dev-only: matches no event, so a window or phase holding it applies
+ * whatever event is current (see `strictReadEvent`, core.ts). */
+export declare const ANY_EVENT: {};
+/** Dev-only: the DOM event current when the effect phase was entered. A
+ * handler dispatched synchronously from that phase (`el.focus()`) runs under
+ * a different event and is not in it (#4235). */
+export declare let effectCallbackEvent: unknown;
+export declare function setEffectCallback(value: boolean, event?: unknown): 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>>;
-    _queueStash: QueueStub;
-    _done: boolean | Transition;
-    _gatedSubs: Set<Computed<any>>;
-}
 export declare function schedule(): void;
 /**
  * Permanently halts the reactive system. Called when a user error escapes
  * every boundary — app state is undefined at that point, so scheduling stops
  * entirely rather than limping along with a half-applied update.
  */
+/**
+ * The key a root owner carries its client error hook under (`render`'s
+ * `onError`) — registered, so a runtime writes it with no import of the hook
+ * module (core/error-hooks.ts) and no property mangling in the way. Defined
+ * HERE, not there: a runtime that only writes the key must not retain the
+ * hook machinery (pay-for-use).
+ */
+export declare const ROOT_ERROR_HOOK: unique symbol;
 export declare function haltReactivity(cause?: unknown): void;
+/**
+ * Dev: `haltReactivity`, located at `subject` — the computation the uncaught
+ * error escaped from — for the REACTIVITY_HALTED message's owner path. Call
+ * sites pick it in dev builds only (`haltReactivity(e)` in production), so
+ * production keeps the one-argument halt and its bytes unchanged.
+ */
+export declare function haltReactivityAt(cause: unknown, subject: DiagnosticSubject): void;
 /** @internal Test/dev-reload hook. Revives scheduling after a halt. */
 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;
 }
-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;
-    static _gatedRead: ((el: Signal<any>, owner: OptimisticNode, c: Computed<any>) => boolean) | null;
-    static _laneSuspends: ((owner: OptimisticNode) => 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;
-    static _laneAsyncSettled: ((el: Computed<any>) => void) | null;
-    static _trackOptimisticStore: ((store: any) => void) | null;
+    /** A slot node's truth is in flight (its family's derive — store/store.ts). */
+    static _slotFlight: ((n: Signal<any>) => boolean) | undefined;
+    /** A write to a slot node's guess (lanes.ts `laneWrite`): true when the
+     * store made the slot its derive's lane's derivation (optimistic.ts);
+     * `back`: the slot's node now, for a guess that comes back (lanes.ts
+     * `endLanes`). */
+    static _slotTake: ((n: Signal<any>, back?: boolean) => any) | undefined;
+    /** The value a slot node's guess covered: its committed value — a chained
+     * link's refreshed from the inner store, whose commits it never learned
+     * while the guess served the reads (store/store.ts, §7b). */
+    static _slotCovered: ((n: Signal<any>) => unknown) | undefined;
+    /** The store's row judgment for a guessed slot (optimistic.ts): the truth
+     * is the guess's echo when reconcile would write nothing into it. */
+    static _echoes: ((guess: unknown, truth: unknown) => boolean) | undefined;
+    /** Truth readers (lanes.ts `truthRead`/`truthConfirmed`), installed by the
+     * first `until`/`refresh` (signals.ts `watch`). */
+    static _truth: ((el: any) => unknown) | undefined;
+    static _confirmed: ((l: Transaction) => void) | undefined;
+    /** `affects()` on a store (store/affects.ts): a store's node for a key
+     * (store/store.ts `getNode`); a bare registration (birth inheritance); a
+     * witnessed mark on an untracked probe (verdict.ts). */
+    static _storeNode: ((t: any, key: PropertyKey) => Signal<any>) | undefined;
+    static _storeWrappable: ((v: unknown) => boolean) | undefined;
+    static _mark: ((node: Signal<any> | Computed<any>) => void) | undefined;
+    static _witnessMark: (() => void) | undefined;
+    /** A truth landing on a guess (lanes.ts `laneWrite`), `older` when it
+     * answers an older question: the store re-bases an arrangement guess over
+     * it; a current one differing from a shown keyed arrangement guess folds
+     * beneath it instead of voiding it (D-34) — true: the lane stages it
+     * beneath (store/optimistic.ts). */
+    static _laneRebase: ((el: Signal<any>, truth: unknown, older: boolean) => boolean | void) | undefined;
+    static _verdictLane: ((t: Transaction) => Transaction) | undefined;
+    static _laneGuesses: ((t: Transaction) => Signal<any>[]) | undefined;
+    /** `createDeferred` (deferred.ts): a deferred node with a flight up that
+     * `c` derives from, if any — a truth reader waits on it. */
+    static _lagging: ((c: Computed<any>) => Computed<any> | undefined) | undefined;
+    static _marked: ((el: Signal<any> | Computed<any>) => boolean) | undefined;
     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. Truthy when an effect re-derives (`land`). */
+export declare function reruns(u: Transaction): unknown;
+/** 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;
+/** Nodes staged this flush (`_pendingValue` set), committed at its end. */
+export declare const pendingNodes: Signal<any>[];
+/** 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;
-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;
-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.
+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`).
  *
- * @internal
- */
-export declare function shiftAffectsMarks(delta: 1 | -1): void;
+ * A render effect re-run by a verdict memo's change (`createMemo(() =>
+ * latest(x))`, CONFIG_VERDICT) is the verdict reader the same read inline
+ * makes it, for that pass (F-6; D-26 `[s(), L()]`, #4284): a frame reader
+ * of its other reads — a staging's screen, a flight's committed value. One
+ * an earlier propagation this flush seated in another lane leaves that
+ * seat: its pass starts from the frame's, as the inline effect's does, and
+ * `laneRead` re-derives it on the screen if that lane holds (`entered`). */
+export declare function laneDirty(node: Signal<any> | Computed<any>, l: Transaction): void;
+/** One lane, or two of one link group (#3335): one reveal unit. */
+export declare function sameLane(a: Transaction, b: Transaction): boolean;
+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
@@ -175,6 +424,8 @@ export declare const globalQueue: GlobalQueue;
  */
 export declare function flush(): void;
 export declare function flush<T>(fn: () => T): T;
-export declare function currentTransition(transition: Transition): Transition;
-export declare function setActiveTransition(transition: Transition | null): void;
-export declare function runInTransition<T>(transition: Transition, fn: () => T): T;
+/** Dev-only: the DOM event current when the running effect queue started,
+ * or `ANY_EVENT` outside one. Read once per queue rather than once per
+ * effect (the getter is costly under jsdom); no event starts or ends between
+ * two effects of one synchronous queue (#4235). */
+export declare let queueEvent: unknown;

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

@@ -0,0 +1,18 @@
+import type { Transaction } from "./scheduler.js";
+import type { Computed, Signal } from "./types.js";
+/** A lane node's current value: its guess, or the latest it derived — the
+ * staging a shown lane holds for its next reveal, else its slot; the
+ * committed value while it has none (its first lane pass in flight) —
+ * NOT_PENDING for a node with no committed value either (born in the lane,
+ * uninitialized: its reads throw NotReady, A7; #4363). */
+export declare function laneValueOf(el: Signal<any> | Computed<any>): unknown;
+/** Truth readers (`until`, `refresh`; CONFIG_AUTHORITATIVE) — pay-for-use:
+ * the first one installs these on GlobalQueue (signals.ts `watch`).
+ *
+ * A truth reader's read of a lane node: the lane's value when it is the
+ * truth (#3943), else the truth staged beneath a guess, else the committed
+ * value. */
+export declare function truthRead(el: Signal<any> | Computed<any>): unknown;
+/** A guess confirmed: its lane's truth readers re-read — of the lane's
+ * derivations too, which may be the truth now (#3943). */
+export declare function truthConfirmed(l: Transaction): void;