@solidjs/signals 2.0.0-rc.13 → 2.0.0-rc.15

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

@@ -1,4 +1,3 @@
-import type { OptimisticLane } from "./lanes.js";
 import type { Computed, Signal } from "./types.js";
 /**
  * Test-mode invariant checks for the async/transition/lane machinery.
@@ -17,20 +16,7 @@ import type { Computed, Signal } from "./types.js";
  * defines `__TEST__: false`.
  */
 type AnyNode = Signal<any> | Computed<any>;
-/** Wired by core.ts at module init to avoid import cycles. */
-export declare const InvariantHooks: {
-    pendingProbeActive: (() => boolean) | null;
-    /** Fresh oracle for what an isPending companion SHOULD read right now. */
-    computePendingState: ((node: AnyNode) => boolean) | null;
-};
 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;
 /**
  * Open/close the sanctioned registration window. Call sites are `__DEV__`
  * guarded (no prod cost); the code inside the window must not throw.
@@ -38,21 +24,6 @@ export declare function devTrackAffects(node: AnyNode): void;
 export declare function beginAsyncReporterWrites(): void;
 export declare function endAsyncReporterWrites(): void;
 export declare function createAsyncReporters(): Map<Computed<any>, Set<Computed<any>>>;
-/**
- * INV-2: a node with an *active* override must be registered for reversion in
- * the queue's or a transition's `_optimisticNodes`. An unregistered active
- * override would survive transition completion forever. Runs at the end of
- * every flush (not just quiescence — the invariant holds mid-transition).
- * (There is no revert-target requirement: authoritative values commit
- * silently into `_value` under the override mask — A17 — so reverting is
- * just dropping the override.)
- */
-export declare function devCheckActiveOverrides(isRegisteredForRevert: (node: AnyNode) => boolean): void;
-/** INV-1: an isPending() probe must never leak past its own call. */
-export declare function devCheckFlushStart(): void;
-/** INV-5: a merged lane's work moved to its root on merge and must stay empty. */
-export declare function devCheckMergedLaneEmpty(lane: OptimisticLane): void;
-export declare function devCensusCompanions(isQueuedForCommit?: (node: AnyNode) => boolean): void;
 /**
  * Quiescence checks. Run only when the system is fully drained: nothing
  * scheduled, no active/stashed transitions, no live lanes. At that point no

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

@@ -1,88 +1,76 @@
-import { hasActiveOverride } from "./core.js";
-export { hasActiveOverride };
-import { type QueueCallback, type Transition } from "./scheduler.js";
+import { type Transaction } from "./scheduler.js";
 import type { Computed, Signal } from "./types.js";
-/**
- * OptimisticLane represents the context for a single optimistic write.
- * Each optimistic signal creates its own lane. Lanes merge when their
- * dependency graphs overlap.
- */
-export interface OptimisticLane {
-    _source: Signal<any>;
-    _pendingAsync: Set<Computed<any>>;
-    _effectQueues: [QueueCallback[], QueueCallback[]];
-    _mergedInto: OptimisticLane | null;
-    _transition: Transition | null;
-    _parentLane: OptimisticLane | null;
-}
-export declare const signalLanes: WeakMap<Signal<any>, OptimisticLane>;
-export declare const activeLanes: Set<OptimisticLane>;
-/**
- * Get an existing lane for a signal or create a new one.
- * Reuses lane for multiple writes to the same signal.
- */
-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.
+/** 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). */
+export declare function laneValueOf(el: Signal<any> | Computed<any>): unknown;
+/** What the screen shows for a lane's node: the lane's value once the lane
+ * has revealed, the committed truth before. */
+export declare function display(el: Signal<any> | Computed<any>): unknown;
+/** What the writer sees of a node: an unflushed guess to it, else the
+ * lane's value or the committed one — what an optimistic updater composes
+ * on (a store setter's draft too, store/optimistic.ts). */
+export declare function guessedValueOf<T>(n: Signal<T> | Computed<T>): T;
+/** The unflushed guess to `n`, else NOT_PENDING. */
+export declare function pendingGuessOf(n: Signal<any> | Computed<any>): unknown;
+export declare function optimisticWrite<T>(n: Signal<T> | Computed<T>, v: T | ((prev: T) => T)): T;
+/** The running pass read lane `l`'s work as a derivation: it is `l`'s — or,
+ * already another lane's, the frame it computes derives from both guesses
+ * and cannot show one without the other (#3335, A15 for lanes): the two
+ * lanes are linked — one reveal unit, each blocked while any is — while
+ * their lifetimes stay their own (#2912: a guess reverts with its own
+ * action, not with the one it shares a reader with). A nested lane reading
+ * through an ancestor's guess stays its own (the screen plus its own
+ * guesses). */
+export declare function enterLane(l: Transaction, c: Computed<any>): void;
+/** Verdicts (maintainer, 2026-10-01): `isPending` and `latest` are
+ * optimistic state the system supplies — a verdict is a guess ("pending,
+ * until this lands"; "the proposal is the value") decided at the seam like
+ * a user's, and its readers break out of the hold the same way: work of a
+ * lane under the holder, shown now, re-derived at the landing, ending with
+ * it. Judged at the seam like any lane: blocked while a verdict reader's
+ * own derivation is in flight (lane rule 3), shown otherwise. */
+export declare function verdictLane(t: Transaction): Transaction;
+/** A lane pass's node (core.ts `recompute`, before its staging; a pending
+ * propagation under a lane pass, async.ts): listed, carrying the lane's
+ * value from now (a derivation of a guess — its readers become lane work).
+ * Entering the lane supersedes a frame staging the node carried: this
+ * pass's answer replaces it, and the frame's hold on it is over. An
+ * effect's value slot is private (no lane value). A pass in a lane's seat
+ * that read none of the lane's world has left it (false): its result is the
+ * frame's — a derivation whose branch no longer reaches the guess — and no
+ * hold the lane took over from a transaction stays on it (#3698: lane work
+ * never makes its node transaction work; a born-held effect's hold went to
+ * the lane). A pass interrupted before it got there (pending, errored) did
+ * not leave (A30: it never got there). A first pass under a lane is the
+ * lane's (ruling A); a guess is written, not derived — it never leaves this
+ * way. `errored`: the pass has no answer — or, a lane pass's pending
+ * propagation (async.ts `propagateStatus`), the node gone pending. */
+export declare function laneStage(el: Computed<any>, l: Transaction, create: boolean, errored: boolean | Computed<any>): boolean;
+export declare function supersede(n: Signal<any> | Computed<any>, value: unknown, changed: boolean): void;
+/** Truth readers (`until`, `refresh`; CONFIG_AUTHORITATIVE) — pay-for-use:
+ * the first one installs these on GlobalQueue (signals.ts `watch`).
  *
- * 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.
- */
-export declare function mergeLanes(lane1: OptimisticLane, lane2: OptimisticLane): OptimisticLane;
-/**
- * Resolve a node's lane: follow union-find chain, verify active, clear if stale.
- */
-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: Signal<any> | Computed<any>, sourceLane: OptimisticLane): void;
+ * 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;
+/** Lanes. A lane's node is read by its reader's kind: an authoritative
+ * reader (`until`) sees the truth — staged beneath a guess, else committed
+ * — and is no lane's; an untracked read sees the lane's latest value (A17:
+ * "direct read shows optimistic"; A28); a children-forbidden reader sees
+ * the frame (A32). A render effect in the frame's seat reading a lane the
+ * seam found blocked, or a member whose own flight is up (held or not — the
+ * lane-membership ruling, 2026-10-05), sees the screen, re-derived at the
+ * reveal (#3460's stale reader) — or, the node a
+ * flight that has never shown (nothing to show), waits on it: its own frame
+ * holds (A15, #3334), not the lane's parent. Any other tracked reader is
+ * the lane's work from this read — a derivation; a leaf reading a lane that
+ * has shown, or one the seam has not judged yet (its run waits on the
+ * verdict: released if the lane shows, held if it blocks) — and sees the
+ * lane's latest. NOT_PENDING falls through: lane work's read of a pending
+ * member throws like any. */
+export declare function laneRead(c: Computed<any> | null, el: Signal<any> | Computed<any>): unknown;

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

@@ -67,9 +67,9 @@ export declare function getOwner(): Owner | null;
  */
 export declare function cleanup(fn: Disposable): Disposable;
 /**
- * Returns `true` if the owner has been disposed (or marked zombie pending
- * disposal). Pair with a captured owner to bail out of late callbacks whose
- * surrounding component already unmounted.
+ * Returns `true` if the owner has been disposed. Pair with a captured owner
+ * to bail out of late callbacks whose surrounding component already
+ * unmounted.
  *
  * @example
  * ```ts