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

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

@@ -2,7 +2,7 @@ import type { OptimisticLane } from "./lanes.js";
 import type { Computed, Signal } from "./types.js";
 /**
  * Test-mode invariant checks for the async/transition/lane machinery.
- * Catalog and rationale: packages/solid-signals/INTERNALS-ASYNC-STATE.md.
+ * Catalog and rationale: packages/signals/docs/INTERNALS-ASYNC-STATE.md.
  *
  * These are implementation self-consistency checks, not semantic rules: a
  * violation means the reactive system contradicted itself.
@@ -25,6 +25,10 @@ export declare const InvariantHooks: {
 };
 export declare function devTrackHeldPending(node: AnyNode): void;
 export declare function devTrackCompanionOwner(node: AnyNode): void;
+/** #3503: a firewall child the store released (unobserved sweep) leaves the
+ * registry with it — the runtime drops it from `_companionChildren` so the
+ * projection stops retaining it; the test-only set must not either. */
+export declare function devUntrackCompanionOwner(node: AnyNode): void;
 export declare function devTrackOptimistic(node: AnyNode): void;
 export declare function devTrackAffects(node: AnyNode): void;
 /**

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

@@ -1,3 +1,5 @@
+import { hasActiveOverride } from "./core.js";
+export { hasActiveOverride };
 import { type QueueCallback, type Transition } from "./scheduler.js";
 import type { Computed, Signal } from "./types.js";
 /**
@@ -24,6 +26,52 @@ export declare function getOrCreateLane(signal: Signal<any>): OptimisticLane;
  * Union-find: find the root lane.
  */
 export declare function findLane(lane: OptimisticLane): OptimisticLane;
+/**
+ * Is the lane held? `_pendingAsync` records the async the lane OWNS (derived
+ * under it); a transaction's reporter map records the async a render effect
+ * OBSERVED pending with no boundary taking it (INV-3, the one registration
+ * site). A hold needs both — the same rule the transaction itself uses, so a
+ * memo nobody renders, or one a fallback-showing boundary caught, cannot tear
+ * a frame and holds nothing (#3289). An orphan lane has no observation record
+ * and never holds.
+ *
+ * The observation is looked up per NODE, in whichever live transaction
+ * recorded it — not in this lane's transaction. Lanes merge across
+ * transactions (#2912: ownership never travels through lanes), so after a
+ * merge the root's transaction holds the observations of only one member;
+ * the async the other member's transaction observed must hold the merged
+ * reveal just the same (A15 for lanes, #3335).
+ */
+export declare function laneHeld(lane: OptimisticLane): boolean;
+/**
+ * Lanes mirror transitions (#3460): a render effect OFF a HELD lane that reads
+ * a value the lane is revealing — an override, a `latest()` shadow — sees the
+ * committed value, exactly as a stale reader of a held transaction does
+ * (A15 reveal corollary): it publishes now, with the frame that is on screen
+ * (the lane defers its own readers' runs, so the committed value is what is
+ * visible), entangles nothing — a sync write is never held by a lane — and
+ * re-derives at the release. The release re-run rides the lane's own render
+ * queue, which runs when the lane reveals (runLaneEffects) or its transaction
+ * commits (cleanupCompletedLanes). A reader ON the lane computes the lane's
+ * reveal and takes the value as before.
+ *
+ * OFF the lane is provenance, not membership — the transaction mirror
+ * exactly: a stale reader of a transaction is a pass that runs outside it. A
+ * pass under the lane's own transaction is the lane's work — its write (lane
+ * posture), or the landing of its async, which re-enters the transaction
+ * (#3334) and runs a member with no ambient lane. Read as an outsider, that
+ * pass published the committed view and queued a replay that revealed the
+ * override beside its unready derivation at the release (`1:0` for an
+ * optimistic frame that never became ready; #3479 review). Membership is the
+ * wrong test the other way: a member re-run by a sibling's sync write is a
+ * mainline pass and shows the committed view.
+ */
+export declare function readsHeldCommitted(owner: Computed<any>, c: Computed<any>): boolean;
+/** The ownership relation for a lane hold (core `ownsHold`, §6 ruling 2): the
+ * running pass owns `lane`'s hold if it runs under the transition that owns
+ * the lane (the node's, resolved through override ownership and merges) or
+ * inside the lane itself. */
+export declare function ownsLane(lane: OptimisticLane, owner: Computed<any>): boolean;
 /**
  * Merge two lanes when their dependency graphs overlap.
  */
@@ -31,26 +79,10 @@ export declare function mergeLanes(lane1: OptimisticLane, lane2: OptimisticLane)
 /**
  * Resolve a node's lane: follow union-find chain, verify active, clear if stale.
  */
-export declare function resolveLane(el: {
-    _optimisticLane?: OptimisticLane;
-}): OptimisticLane | undefined;
-export declare function resolveTransition(el: {
-    _optimisticLane?: OptimisticLane;
-    _transition?: Transition | null;
-    _overrideValue?: any;
-    _overrideOwner?: Transition | null;
-}): Transition | null | undefined;
-/**
- * Check if a node has an active optimistic override.
- */
-export declare function hasActiveOverride(el: {
-    _overrideValue?: any;
-}): boolean;
+export declare function resolveLane(el: Signal<any> | Computed<any>): OptimisticLane | undefined;
+export declare function resolveTransition(el: Signal<any> | Computed<any>): Transition | null | undefined;
 /**
  * Assign or merge a lane onto a node. At convergence points (node already has
  * a different active lane), merge unless the node has an active override.
  */
-export declare function assignOrMergeLane(el: {
-    _optimisticLane?: OptimisticLane;
-    _overrideValue?: any;
-}, sourceLane: OptimisticLane): void;
+export declare function assignOrMergeLane(el: Signal<any> | Computed<any>, sourceLane: OptimisticLane): void;

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

@@ -2,6 +2,7 @@ import type { Computed, Disposable, Owner, Root } from "./types.js";
 export declare function markDisposal(el: Owner): void;
 export declare function dispose(node: Computed<unknown>): void;
 export declare function disposeChildren(node: Owner, self?: boolean, zombie?: boolean): void;
+export declare function linkChild(parent: Owner, node: Owner): void;
 /**
  * Allocates and returns the next stable child id for `owner`. Used by
  * hydration plumbing and `createUniqueId`. Not part of the user-facing API.
@@ -95,9 +96,15 @@ export declare function createOwner(options?: {
     transparent?: boolean;
 }): Root;
 /**
- * Creates a detached reactive root. The callback receives a `dispose()`
- * function which, when called, tears down every signal, memo, effect, and
- * `onCleanup` registered inside the root.
+ * Creates a reactive root — an owner scope with its own `dispose()`. A root
+ * created inside an existing owner is owned by it and is disposed when the
+ * parent is disposed; call `dispose()` to tear it down earlier. To create a
+ * root that outlives its creator, detach explicitly:
+ * `runWithOwner(null, () => createRoot(...))`. Pass `id` to seed hydration
+ * ids for the tree it owns.
+ *
+ * `dispose()` tears down every signal, memo, effect, and `onCleanup`
+ * registered inside the root.
  *
  * Use this to host long-lived reactive scopes outside of a component (custom
  * controllers, app bootstrapping, tests). Inside a component, prefer
@@ -105,6 +112,7 @@ export declare function createOwner(options?: {
  *
  * @example
  * ```ts
+ * // At module level there is no owner, so this root lives until disposed.
  * const dispose = createRoot(dispose => {
  *   const [n, setN] = createSignal(0);
  *   createEffect(() => n(), value => console.log(value));
@@ -114,6 +122,10 @@ export declare function createOwner(options?: {
  *
  * // Later, to tear everything down:
  * dispose();
+ *
+ * // Inside an owner (component, effect, another root), detach explicitly
+ * // if the root must outlive its creator:
+ * const detached = runWithOwner(null, () => createRoot(d => d));
  * ```
  *
  * @description https://docs.solidjs.com/reference/reactive-utilities/create-root

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

@@ -3,13 +3,25 @@ import { activeLanes, assignOrMergeLane, findLane, type OptimisticLane } from ".
 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 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;
-export declare function resetUnhandledAsync(): void;
+/** 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.
+ */
+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
@@ -36,16 +48,100 @@ export interface Transition {
     _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
  * 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;
 /** @internal Test/dev-reload hook. Revives scheduling after a halt. */
 export declare function resetErrorHalt(): void;
@@ -59,6 +155,11 @@ export interface IQueue {
     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;
@@ -97,27 +198,119 @@ export declare class GlobalQueue extends Queue {
     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. */
+    static _landOnOverride: (<T>(el: Signal<T> | Computed<T>, v: T | ((prev: T) => T)) => T) | null;
     static _trackOptimisticStore: ((store: any) => void) | null;
     flush(): void;
     notify(node: Computed<any>, mask: number, flags: number, error?: any): boolean;
     initTransition(transition?: Transition | null): 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
@@ -167,6 +360,60 @@ 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;