@solidjs/signals 2.0.0-rc.3 → 2.0.0-rc.5

package/dist/types/store/next/patch.d.ts

@@ -0,0 +1,91 @@
+import type { Owner } from "../../core/types.js";
+import { type StoreNextTarget } from "./target.js";
+export type PatchFn = (next: any, prev: any, force?: boolean) => void;
+interface PatchEntry {
+    fn: PatchFn;
+    owner: Owner | null;
+}
+/**
+ * Emit a record's visibility transition. Callers gate on `hasPatches()` and
+ * `t.d` cheaply; this function re-checks and walks ancestors (§4b).
+ */
+export declare function emitPatch(t: StoreNextTarget, next: any, prev: any): void;
+/** Emission for sites that already stand at the record with both sides in
+ * hand and have already handled ancestors (the adoption walk descends —
+ * parents were visited first), so no bubbling walk. */
+export declare function emitPatchLocal(t: StoreNextTarget, next: any, prev: any): void;
+export declare function emitPatchOptimistic(t: StoreNextTarget, next: any, prev: any): void;
+/** Row-ops emission at OPTIMISTIC (lane) timing: user drafts on an
+ * optimistic family must show structure IN FLIGHT — bypassing the
+ * transition stash exactly like emitPatchOptimistic. Two forms:
+ * - `ops` given (write site): `nextRows` is the draft's intended visible
+ *   list, ops the identity diff against the pre-write optimistic view.
+ * - `ops === null` (revert site): RESYNC — the consumer rebuilds retention
+ *   by row identity against the live post-revert view, resolved from the
+ *   target at drain time (overrides are gone by then, so `pb ?? v` IS the
+ *   committed truth). */
+export declare function emitRowOpsOptimistic(t: StoreNextTarget, nextRows: any[] | null, ops: RowOps | null): void;
+/** Test-only accounting probe: the live registration count must return to
+ * baseline across register/unbind/demote cycles. @internal */
+export declare function patchCountForTests(): number;
+export declare function hasPatches(): boolean;
+export declare function registerPatch(record: any, fn: PatchFn): () => void;
+/** Dual-driver bind probe (compiler runtime contract): when `record` is a
+ * patchable store record, returns its CURRENT raw backing (the driver's
+ * initial force-apply reads it directly — no proxy traffic, no tracking);
+ * returns undefined otherwise (driver falls back to the effect path).
+ * Not patchable: non-records, non-proxies, accessor-bearing records
+ * (patches read raw — getters need tracked evaluation), broken chains. */
+export declare function patchableRaw(record: any): Record<PropertyKey, any> | undefined;
+/** Accessor demotion (design §5): a record that acquires an accessor after
+ * registration stops being patchable — reads must go through tracked
+ * evaluation. Clears patches and repairs the global count; callers re-drive
+ * the pulled bodies (demoteToEffects). */
+export declare function demotePatches(t: StoreNextTarget): PatchEntry[] | null;
+/** The demotion re-drive (re-audit blocker 3): each pulled body becomes the
+ * SAME dual-driver effect fallback the web runtime would have chosen had the
+ * record carried the accessor at bind — a tracked compute pass (next === prev
+ * short-circuits every compare into a pure read THROUGH THE PROXY, so getter
+ * dependencies track) plus an untracked force-apply at effect timing.
+ *
+ * Creation is DEFERRED to the effect phase: the trap that discovers the
+ * accessor runs mid-draft, and an effect's initial pass must not read
+ * through the proxy inside the write window. The record's own transition
+ * for that draft is covered by the new effect's initial force-apply.
+ *
+ * Known edge (documented): a demoted LIST-ROW body re-drives under its
+ * registering owner (the list owner), so per-row severing on removal is
+ * lost for demoted rows — the effect lives until the LIST disposes. Rows
+ * only demote when user code defines an accessor on a row record at
+ * runtime. */
+export declare function demoteToEffects(t: StoreNextTarget): void;
+/** Structural ops for one keyed-array transition. `prefix` rows key-matched
+ * in place; for each later index i (absolute), `sources[i - prefix]` is the
+ * OLD index its row retained from, or -1 for a new row. `removed` holds the
+ * dropped old row values (unbind/teardown handles). Aligned value ticks emit
+ * NOTHING — ops exist only when structure changed. */
+export interface RowOps {
+    prefix: number;
+    sources: number[];
+    removed: any[];
+}
+/** `ops === null` is the RESYNC form (optimistic revert): the consumer
+ * rebuilds retention by row identity against `next` (the live view). */
+export type RowOpsFn = (next: any[], ops: RowOps | null) => void;
+/** Register a structural-ops consumer on a keyed store array (the list
+ * container's channel — what `For` consumes through the seam). */
+export declare function registerRowOps(array: any, fn: RowOpsFn): () => void;
+/** Slot patches (shallow arrays) ride the same apply queue: the walk emits
+ * per aligned value-replaced slot; application happens at effect phase under
+ * the registration owner's lifetime. */
+export declare function emitSlotPatch(t: StoreNextTarget, index: number, next: any, prev: any): void;
+/** Slot patch for shallow arrays: the reconcile walk emits (index, next,
+ * prev) for KEY-ALIGNED value-replaced slots (structure rides row ops), and
+ * the emission queues through the patch apply queue — effect-phase timing,
+ * transition stamping, disposed-owner drop — like every other channel. */
+export declare function registerSlotPatchNext(arr: any, fn: (index: number, next: any, prev: any) => void): () => void;
+/** Row-ops ride the SAME apply queue/timing as record patches: transition-
+ * stamped, applied at effect phase, in emission order (structure before the
+ * new rows' own patches can exist; retained rows' value patches commute). */
+export declare function emitRowOps(t: StoreNextTarget, next: any[], ops: RowOps): void;
+export {};

package/dist/types/store/next/projection.d.ts

@@ -5,4 +5,4 @@ export declare function createProjectionNext<T extends object = {}>(fn: (draft:
  * masks the recompute for the tick (core R31 — the manual write wins over a
  * same-flush dependency change). */
 export declare function createStoreDerivedNext<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [Refreshable<Store<T>>, (f: (draft: T) => T | void) => void];
-export declare function runProjectionComputedNext<T extends object>(wrappedStore: Store<T>, fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, key: string | ((item: NonNullable<any>) => any) | null, wrapCommit?: (write: () => void) => void, onDraftWrite?: () => void): Computed<void | T>;
+export declare function runProjectionComputedNext<T extends object>(wrappedStore: Store<T>, fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, key: string | ((item: NonNullable<any>) => any) | null, wrapCommit?: (write: () => void, value: T) => void, aroundDraftWrite?: (op: () => void) => void): Computed<void | T>;

package/dist/types/store/next/reconcile.d.ts

@@ -1,3 +1,17 @@
+import type { RowOps } from "./patch.js";
+import { type StoreNextTarget } from "./target.js";
 type KeyFn = (item: any) => any;
 export declare function reconcileNextState(value: any, state: any, key: string | KeyFn | null | undefined, replace?: boolean): void;
+/** Key equality for EVERY key comparison in this module (re-audit 2, P1-5):
+ * SameValueZero, matching the Map-based matchers (buildRowOps, the adoption
+ * window) — NaN keys are equal to themselves, so aligned NaN rows stay
+ * aligned in the prefix walk instead of forever misaligning. Adoption and
+ * row ops MUST agree on key equality or retained DOM rows go stale. */
+export declare function sameKey(a: any, b: any): boolean;
+export declare function emitSetterRowOps(t: StoreNextTarget, prevRows: any[], nextRows: any[]): void;
+/** Identity-keyed structural diff, returned rather than emitted: shared by
+ * the setter channel (regular queue) and the OPTIMISTIC write channel (lane
+ * queue) — same retention semantics, different dispatch timing. Returns
+ * null when the lists are identity-aligned (no structure changed). */
+export declare function buildIdentityRowOps(prevRows: any[], nextRows: any[]): RowOps | null;
 export {};

package/dist/types/store/next/store.d.ts

@@ -1,5 +1,7 @@
 import type { Signal } from "../../core/types.js";
-import { type StoreNextFamily, type StoreNextTarget } from "./target.js";
+import { type StoreNextFamily, type StoreNextTarget, type PatchChannel } from "./target.js";
+/** Lazily allocate the patch-channel extension (one literal shape). */
+export declare function pcOf(t: StoreNextTarget): PatchChannel;
 export declare function wrapNext<T extends Record<PropertyKey, any>>(value: T, parent?: StoreNextTarget | null, parentKey?: PropertyKey | null, fam?: StoreNextFamily | null): T;
 /** Unwrap our own proxies to their current backing; leave everything else. */
 export declare function unwrapValue(v: any): any;
@@ -9,6 +11,10 @@ export declare function getKeySetNode(target: StoreNextTarget): Signal<number>;
 /** Deep-witness bump: any value/shape change on a record with a live deep()
  * subscriber notifies it. One null check when unused. */
 export declare function bumpDeep(t: StoreNextTarget): void;
+/** Scanned plainness for patch admission (patchableRaw): runs the one-time
+ * accessor scan if it hasn't happened yet — the sticky `a` flag alone is not
+ * trustworthy before a scan (it starts false and is discovered lazily). */
+export declare function targetIsPlain(target: StoreNextTarget): boolean;
 /** Downgrade a prototype-overlay pending backing to the clone path: builds
  * the real container (committed + overlay writes − deletes) that fold will
  * SWAP in as the committed backing, exactly as if the draft had started on
@@ -24,9 +30,16 @@ export declare function materializePB(target: StoreNextTarget): void;
  * authoritative base (R21/R32).
  */
 export declare function adoptPB(target: StoreNextTarget, incoming: Record<PropertyKey, any>, eager?: boolean): void;
+/** Parked truth-staged pending backings (#3164 fold): a tentative draft that
+ * opens while a folded landing's backing is live moves the staged container
+ * here (see ensurePB); the tentative discard in notifyOptimisticWrites
+ * restores it in place of the usual null. */
+export declare const stagedTruthPB: WeakMap<StoreNextTarget, Record<PropertyKey, any>>;
 /** Same logical slot: both values resolve to one (re-pointed) child target —
  * adoption preserved identity, so the slot did not change (R9). */
 export declare function targetsEqual(ov: any, nv: any): boolean;
+export declare function arrayStructureChanged(old: any[], neu: any[]): boolean;
+export declare function membershipChanged(old: Record<PropertyKey, any>, neu: Record<PropertyKey, any>): boolean;
 /**
  * The fold diff walks SUBSCRIPTION KEYS ONLY (legacy parity: `for key in
  * nodes`): nodes exist exactly where something tracked, so unobserved data
@@ -56,6 +69,21 @@ export declare function runAuthoritative<T>(fn: () => T): T;
 /** Active optimistic override on an armed node (armed slot idles at
  * NOT_PENDING; undefined = unarmed plain node). */
 export declare function hasActiveOverride(node: Signal<any>): boolean;
+/** The reading computation is until()'s authoritative-view predicate — same
+ * source of truth as core read()'s A17 carve-out (`context`, which persists
+ * under untrack). optimisticView()'s composition gate consults exactly this:
+ * write-side machinery (patch emission, tentative re-application) must keep
+ * composing even when it runs inside an authoritative-write bracket. */
+export declare function authoritativeRead(): boolean;
+/** Serve-side authoritative gate: until()'s predicate PLUS truth authors —
+ * the projection derive's draft (wrapDraft trap brackets, runAuthoritative;
+ * the same posture pair ensurePB classifies drafts by). A source computing
+ * the next truth must never read its callers' tentative overlays: a derive
+ * continuation's `store.push` computing its index from an action's
+ * optimistic row landed truth in the wrong slot and corrupted committed
+ * state (#3108). Trap-level overlay serves gate on this so values, length,
+ * membership, and keys leave the authoritative view together. */
+export declare function authoritativeServe(): boolean;
 export type SetStoreNextFunction<T> = (fn: (draft: T) => T | void) => void;
 /** Low-level setter primitive: opens write mode on a next proxy, runs `fn`,
  * emits write-time notifications at outermost exit, applies returned
@@ -63,8 +91,30 @@ export type SetStoreNextFunction<T> = (fn: (draft: T) => T | void) => void;
  * projection recomputes legitimately write from inside their computed. */
 export declare function storeSetterNext<T>(proxy: T, fn: (draft: T) => T | void, guard?: boolean): void;
 export declare function createStoreNext<T extends Record<PropertyKey, any>>(init: T, shallow?: boolean): [T, SetStoreNextFunction<T>];
+/** True when `proxy` is a SHALLOW store (children served verbatim, slots
+ * replaced by reference — #2932). The list driver uses this to choose the
+ * slot-patch channel (collected row bodies) over per-record registration. */
+export declare function storeIsShallow(proxy: any): boolean;
+/** True when `proxy` belongs to a projection/optimistic FAMILY. The list
+ * driver must DECLINE family arrays (external audit finding): family
+ * structural changes never emit row/slot ops (the setter channel is
+ * fam-gated; optimistic writes ride node overrides), and the proxy identity
+ * is stable so the each-watch cannot catch the change either — an engaged
+ * list would freeze on optimistic/projection structural updates. Record-
+ * level family patches are unaffected (they have their own emission). */
+export declare function storeHasFamily(proxy: any): boolean;
+/** True when `proxy` belongs to an OPTIMISTIC family specifically. The list
+ * driver declines these (audit finding, narrowed): optimistic user writes
+ * ride node-level overrides — they never enter the reconcile walk, so no
+ * row/slot ops are emitted and an engaged list would freeze on optimistic
+ * structural changes. PROJECTION (non-optimistic) families are drivable:
+ * their recomputes go through the reconcile walk, whose emissions are
+ * transition-stamped in the apply queue like any other (equivalence-matrix
+ * gated). Re-admitting optimistic families requires a lane-timed structural
+ * emission mirroring emitPatchOptimistic, plus revert resync. */
+export declare function storeHasOptimisticFamily(proxy: any): boolean;
 /** Tracking deep snapshot (`deep()` for next targets): subscribes to the
- * key-set and every property node at every reachable level, then returns the
+ * key-set and deep-witness node at every reachable level, then returns the
  * plain view. Shared references and cycles handled via the visited set. */
 export declare function deepNext<T>(value: T): T;
 /**

package/dist/types/store/next/target.d.ts

@@ -12,7 +12,7 @@
  * entry per read-through object; zero layer slots; nodes, has-nodes, and the
  * key-set node are lazy, materialized only by subscription.
  */
-import type { Computed, Signal } from "../../core/types.js";
+import type { Computed, Owner, Signal } from "../../core/types.js";
 /** Projection family (§7b): children wrap into the family's own map (writes
  * land in the projection, never the source family), and every node created
  * under the family carries the projection computed as its firewall. */
@@ -27,11 +27,56 @@ export interface StoreNextFamily {
     /** Targets currently carrying active node overrides (landing-consumption
      * walk, RUL-2: visible landed truth replaces optimism). */
     overlaid?: Set<any>;
+    /** Retaining transactions (#3164 fold ruling): every transaction that made
+     * an optimistic setter call on this family and may still be open. While
+     * any member is live, truth landings FOLD — they stage into the retaining
+     * transaction and reveal atomically at its settle, exactly like a signal
+     * landing under an active override. Dead members prune lazily at each
+     * landing (retainingTransition). */
+    rt?: Set<any>;
+    /** Normalized row-key fn (same resolution as the projection channels:
+     * `options.key`, "id" default, null = unkeyed). The staged-landing walk
+     * reads it: key-matched rows keep their proxy identity across a fold. */
+    key?: ((item: any) => any) | null;
     map: WeakMap<object, StoreNextTarget>;
     /** The projection computed — assigned after creation (accessor pattern). */
     node: Computed<any> | null;
     shallow?: boolean;
 }
+/** Write-side patch-channel state (stage 2), grouped off the target's named
+ * fields — see the shape rule on `StoreNextTarget.pc`. One literal shape,
+ * allocated by `pcOf` on first use. */
+export interface PatchChannel {
+    /** Slot-patch hooks for shallow arrays — the reconcile walk emits
+     * (i, next, prev) for key-aligned value-replaced slots through the patch
+     * apply queue (records are raw, no per-record targets exist).
+     * MULTI-CONSUMER (external audit): one array can drive several lists. */
+    sp: {
+        fn: (index: number, next: any, prev: any) => void;
+        owner: Owner | null;
+    }[] | null;
+    /** Patch-channel consumers (next/patch.ts): per-record compiled patch
+     * entries, multi-consumer. null when unpatched (the common case). */
+    p: object[] | null;
+    /** Same-batch coalescing stamp (re-audit 2/3): the container array this
+     * channel last pushed a non-forced SELF entry into, plus that entry. A
+     * later same-batch emission UPDATES the queued entry's `next` in place
+     * (latest state wins — adoption REPLACES the captured object, so dropping
+     * the later emission would apply stale state) while `prev` stays the
+     * batch's earliest. The drain clears both stamps so a quiet record
+     * retains nothing from its last batch. */
+    qa: unknown;
+    qe: unknown;
+    /** Row-ops consumers (next/patch.ts, PR-B): structural list ops —
+     * (nextRows, { prefix, sources, removed }) at apply timing. */
+    ro: object[] | null;
+    /** Keys written through the traps since the last fold commit. Bounds the
+     * setter notify/hold-check to O(written) instead of O(subscribed nodes) —
+     * a record with thousands of per-key subscriptions (selection maps) would
+     * otherwise pay a full node scan on every write. null = no trap writes
+     * this batch (bulk paths fall back to the full scan). */
+    wk: Set<PropertyKey> | null;
+}
 export interface StoreNextTarget {
     /** Committed backing: source object (shared) or owned clone. */
     v: Record<PropertyKey, any>;
@@ -47,6 +92,15 @@ export interface StoreNextTarget {
     h: Record<PropertyKey, Signal<boolean>> | null;
     /** Lazy key-set node: membership/iteration/$TRACK subscriptions (§6). */
     k: Signal<number> | null;
+    /** Patch-channel extension (lazily allocated on first use): groups the
+     * write-side stage-2 fields so they never widen the TARGET's own named
+     * field count. LOAD-BEARING SHAPE RULE: array proxy targets carry their
+     * fields as named properties on a real array, and V8 normalizes an array
+     * to dictionary properties as the named count grows (empirically at
+     * counts ≡ 0 mod 3 from 18 up on V8 13.x) — every trap field read then
+     * becomes a hash lookup (~15% uibench, tree suites worst). New
+     * patch-channel state MUST go inside this object, not on the target. */
+    pc: PatchChannel | null;
     /** Lazy deep-witness node: `deep()` subscribes ONE node per record instead
      * of one per path; write paths bump it only when it exists. Separate from
      * `k` so $TRACK/mapArray never rerun on leaf value changes (R9). */
@@ -79,17 +133,21 @@ export interface StoreNextTarget {
     /** Keys deleted in the overlay window (a prototype overlay cannot shadow
      * a delete); null when none. */
     del: Set<PropertyKey> | null;
-    /** Keys written through the traps since the last fold commit. Bounds the
-     * setter notify/hold-check to O(written) instead of O(subscribed nodes) —
-     * a record with thousands of per-key subscriptions (selection maps) would
-     * otherwise pay a full node scan on every write. null = no trap writes
-     * this batch (bulk paths fall back to the full scan); WK_ALL sentinel =
-     * bound unusable this batch (array length write implies index deletes). */
-    wk: Set<PropertyKey> | null;
     /** Projection family, null for plain stores (§7b). */
     fam: StoreNextFamily | null;
     /** Shallow store root (values served raw). */
     s: boolean;
+    /** Held committed view (#3074/#3075): the pre-hold committed backing,
+     * served to committed-visibility readers while `ht` is live. Adoption is
+     * eager by contract, but a projection recompute deriving from uncommitted
+     * inputs (a transition-held source, or a latest()-pull ahead of the flush)
+     * swaps the backing SPECULATIVELY — the old view must stay servable until
+     * the hold resolves. */
+    hv: Record<PropertyKey, any> | null;
+    /** The holder for `hv`: a live transition (cleared lazily when it is done)
+     * or the PLAIN_HOLD sentinel (a latest()-pull staging — cleared by the
+     * fold commit). null = no hold. */
+    ht: any;
 }
 /**
  * Ownership (first cut, decision 2026-08-16d): one WeakSet of store-owned
@@ -112,6 +170,13 @@ export interface OptStoreHooks {
     notifyOptimisticWrites(t: any, pb: Record<PropertyKey, any>): void;
     optimisticView(t: any, src: Record<PropertyKey, any>): Record<PropertyKey, any>;
     applyTentative(t: any, incoming: any, keyFn: ((item: any) => any) | null): void;
+    /** #3164 fold: does this live transaction still retain optimism (armed
+     * nodes or tracked stores)? Backs the held-truth masks in next/store.ts so
+     * plain-store bundles don't carry the transition-optimism probe. */
+    retainsOptimism(t: any): boolean;
 }
 export declare let optHooks: OptStoreHooks | null;
 export declare function setOptHooks(h: OptStoreHooks): void;
+/** Sticky descendants flag walk (§6d): reconcile's keyed pruning descends
+ * only where subscriptions exist at/below. Nodes AND patches count. */
+export declare function markDescendants(target: StoreNextTarget): void;

package/dist/types-cjs/core/async.d.cts

@@ -16,6 +16,8 @@ export declare function releaseSettledDependents(el: Computed<any>): void;
 export declare function settleErroredDependents(el: Computed<any>, error: any): void;
 export declare function settlePendingSource(el: Computed<any>): void;
 export declare function isThenable<T>(value: T | PromiseLike<T>): value is PromiseLike<T>;
+/** Fire and clear a node's iterator-flight cancellation hook (#3122). */
+export declare function releaseFlightTeardown(el: Computed<any>): void;
 export declare function handleAsync<T>(el: Computed<T>, result: T | PromiseLike<T> | AsyncIterable<T>, setter?: (value: T) => void): T;
 export declare function clearStatus(el: Computed<any>, clearUninitialized?: boolean): void;
 export declare function notifyStatus(el: Computed<any>, status: number, error: any, blockStatus?: boolean, lane?: OptimisticLane): void;

package/dist/types-cjs/core/attribution.d.cts

@@ -60,11 +60,16 @@ export interface RerunEvent {
     /** Wall time of this run including nested recomputes (ms). */
     totalMs: number;
     /**
-     * Whether the run committed a changed value. A PLAIN memo run with
+     * Whether the run produced a changed value. A PLAIN memo run with
      * `changed: false` was pure waste — the equality cutoff stopped it from
-     * notifying anyone; an effect run with `changed: false` computed without
-     * firing its effect phase. Summed as `wastedMs` in costs() (plain,
-     * non-held runs only — see `phase`).
+     * notifying anyone. Effects run with `_equals: false` in core (their
+     * effect phase re-fires on every recompute), so the engine derives this
+     * fact itself: an effect run whose compute output is identical to the
+     * previous run's reports `changed: false` — the phase re-fired with the
+     * same input, pure waste. Side-effect-only computes (`undefined` output)
+     * are exempt: identity of `undefined` proves nothing about their work.
+     * Summed as `wastedMs` in costs() (plain, non-held runs only — see
+     * `phase`).
      */
     changed: boolean;
     /**

package/dist/types-cjs/core/constants.d.cts

@@ -51,6 +51,60 @@ export declare const CONFIG_CHILD_COMPANIONS: number;
  * moved into the cold extension (§12), and an unconditional `_x` deref per
  * marked node measurably taxed the propagation hot path (diamond -22%). */
 export declare const CONFIG_FW_CHILDREN: number;
+/** Authoritative-view reader (`until()`): while this node computes, reads
+ * dodge active optimistic OVERRIDES only — the predicate must observe
+ * arriving truth, never the caller's own tentative writes (which would
+ * trivially satisfy it). Everything else reads normally, INCLUDING
+ * transition-staged `_pendingValue`: staged data is authoritative (optimism
+ * lives only in override slots), and a hold that refused staged reads would
+ * deadlock on data the open transaction itself is holding (a refresh the
+ * action issued lands staged and cannot commit until the hold releases).
+ * read() checks the bit on the reading computation (`context`) directly — no
+ * ambient flag — so a shared computed the predicate pulls recomputes as
+ * itself (no bit) under the normal view, and its cache never forks. */
+export declare const CONFIG_AUTHORITATIVE_READ: number;
+/** Sticky mark: an authoritative-view reader read this node PAST an active
+ * override. The ack shape — an authoritative arrival EQUAL to the override —
+ * rides paths that are deliberately silent under A17 (every ordinary reader
+ * sees the override, so an equal landing changes nothing for them). A marked
+ * node notifies those readers on such paths anyway, so the landed truth is
+ * seen without re-firing ordinary subscribers. Never cleared — only nodes an
+ * until() predicate observed mid-override pay. */
+export declare const CONFIG_AUTHORITATIVE_OBSERVED: number;
+/** Promise-delivery effect (resolve()/until()): commits its computed value
+ * directly even when recomputing under its own held transition. These
+ * effects deliver applies on a microtask (#2930) instead of the stashed
+ * effect queues, so the value must ride the same immediate schedule — a
+ * staged value with an immediate apply delivers stale state (resolve) or
+ * deadlocks the hold (until). Safe because the node is a private leaf: no
+ * subscriber reads an effect's value, only its own apply does. */
+export declare const CONFIG_DIRECT_COMMIT: number;
+/** Fresh-pull reader (awaitable `refresh()`'s waiter effect): a read of a
+ * dirty source recomputes it inline even when the height gate defers to the
+ * flush. Closes the same-flush ordering race where a waiter created
+ * alongside a refresh() mark read the PRE-re-ask value as settled and
+ * delivered stale; with the pull, the waiter either parks on the re-ask's
+ * pending window (async — woken by the settle walk, which runs on every
+ * landing including equal-value ones) or serves its sync answer. resolve()
+ * deliberately keeps that race — its contract is "first settled value"
+ * (#2930), not "next quiescent state". */
+export declare const CONFIG_FRESH_READ: number;
+/** HELD truth (#3164): this node's staged `_pendingValue` is confirming
+ * truth riding a transaction that retains optimism, revealed only at that
+ * transaction's settle. Two arming sites, one meaning: the store fold
+ * (a landing staged into the retaining transaction) and until()'s
+ * flip-entanglement (a foreign carrier's staged write, stolen when it
+ * flipped the awaited predicate truthy). Until the reveal, ordinary
+ * readers — lane and speculative recomputes included — keep committed:
+ * the staging notified subscribers as a plain write, so without the mask
+ * a mid-hold recompute composes live optimism with the confirming truth,
+ * a frame no timeline contains (GabbeV's union tear). Authoritative
+ * readers (until()'s predicate) and latest() tunnel through — the
+ * exemption that keeps holds deadlock-free. Override-covered nodes never
+ * arm: the override is their display and its revert their notification
+ * (A17). Cleared at commit (the commit IS the reveal); subscribers masked
+ * during the hold are woken by finalizePureQueue's post-revert pass. */
+export declare const CONFIG_HELD_TRUTH: number;
 export declare const STATUS_NONE = 0;
 export declare const STATUS_PENDING: number;
 export declare const STATUS_ERROR: number;

package/dist/types-cjs/core/core.d.cts

@@ -1,4 +1,3 @@
-import { type Refreshable } from "./constants.cjs";
 import { type OptimisticLane } from "./lanes.cjs";
 import type { Computed, FirewallSignal, NodeExtension, NodeOptions, Owner, Signal } from "./types.cjs";
 export declare const PRIMITIVE_IN_FORBIDDEN_SCOPE_MESSAGE = "[PRIMITIVE_IN_FORBIDDEN_SCOPE] Cannot create reactive primitives inside createTrackedEffect or owner-backed onSettled";
@@ -38,7 +37,21 @@ export declare function ext(el: {
  * mode (recompute is called explicitly by `effect()`), so we hardcode the lazy bits and skip
  * the auto-dispose CONFIG bit (effect() previously cleared it post-construction).
  */
-export declare function createEffectNode<T>(fn: (prev?: T) => T, effectFn: (val: T, prev: T | undefined) => void | (() => void), errorFn: ((err: unknown, cleanup: () => void) => void | (() => void)) | undefined, type: number, notifyStatus: ((status?: number, error?: any) => void) | undefined, options: NodeOptions<T> | undefined): any;
+export declare function createEffectNode<T>(fn: (prev?: T) => T, effectFn: (val: T, prev: T | undefined) => void | (() => void), errorFn: ((err: unknown, cleanup: () => void) => void | (() => void)) | undefined, type: number, options: NodeOptions<T> | undefined): any;
+/**
+ * The shared status notifier for effect nodes, installed once by effect.ts
+ * at module evaluation (`this`-dispatched — one function serves every
+ * effect, so nodes never store it). Boundary computeds keep their own
+ * per-node channel on `_x._notifyStatus`, which takes precedence.
+ */
+export declare let effectStatusNotify: ((this: any, status?: number, error?: any) => void) | null;
+export declare function setEffectStatusNotify(fn: NonNullable<typeof effectStatusNotify>): void;
+/** Resolve a node's status notifier: an own `_x` channel (boundaries) wins;
+ * effect nodes (`_type` — EFFECT_PURE is 0, and only effect literals carry
+ * the field) fall back to the shared notifier. Presence doubles as the
+ * "display consumer" membership test in the status walks, exactly as the
+ * per-node field did when every effect carried one. */
+export declare function statusNotifierOf(el: any): ((this: any, status?: number, error?: any) => void) | undefined;
 export declare function signal<T>(v: T, options?: NodeOptions<T>): Signal<T>;
 export declare function signal<T>(v: T, options?: NodeOptions<T>, firewall?: Computed<any>): FirewallSignal<T>;
 export declare function optimisticSignal<T>(v: T, options?: NodeOptions<T>): Signal<T>;
@@ -93,6 +106,19 @@ export declare const READ_SLOW: unique symbol;
  * snapshot / transition / lane / dev-strictRead state all take the full
  * resolution. Anything slow returns READ_SLOW; the caller then calls read().
  */
+/**
+ * Wake only authoritative-view readers (until() predicates) subscribed to `el`.
+ * The A17-silent ack paths — an authoritative arrival equal to the active
+ * override — use this so the predicate re-evaluates without re-firing
+ * ordinary subscribers whose visible (override) value did not change.
+ * Pay-for-use: reached through GlobalQueue._notifyAuthoritativeObservers,
+ * installed at first until() call — apps that never use until() shake it.
+ */
+export declare function notifyAuthoritativeObservers(el: Signal<any> | Computed<any>): void;
+/** Installs the until() machinery hook. Idempotent; called by until() before
+ * any authoritative-view read happens (same late-binding contract as the
+ * optimistic engine). */
+export declare function installAuthoritativeRead(): void;
 export declare function readNodeFast<T>(el: Signal<T>): T | typeof READ_SLOW;
 export declare function read<T>(el: Signal<T> | Computed<T>): T;
 /**
@@ -141,23 +167,10 @@ export declare function setMemo<T>(el: Computed<T>, v: T | ((prev: T) => T)): T;
 export declare function runWithOwner<T>(owner: Owner | null, fn: () => T): T;
 export declare function staleValues<T>(fn: () => T, set?: boolean): T;
 /**
- * Invalidates one reactive source, forcing it to re-execute even if its inputs
- * haven't changed.
- *
- * Pass either a Solid-created accessor or a projected store created from
- * `createStore(fn, ...)` / `createProjection(...)`. `refresh()` is a
- * write-like invalidation operation: it does not read the target's value, and
- * refreshing a plain signal accessor is a no-op.
- *
- * Use it to invalidate cached async values (e.g. force a re-fetch) without
- * tearing the consumer down.
- *
- * @example
- * ```ts
- * const user = createMemo(async () => fetch(`/users/${id()}`).then(r => r.json()));
- *
- * // Re-fetch on demand
- * <button onClick={() => refresh(user)}>Reload</button>
- * ```
+ * Core marking half of `refresh()` (the public wrapper lives in signals.ts —
+ * it validates the target, marks through here, then builds the quiescence
+ * promise on the resolve()/until() effect machinery). Flags the node's next
+ * recompute as a quiet re-ask and schedules it; no-ops for non-derived or
+ * disposed targets and for same-tick manual writes.
  */
-export declare function refresh<T>(target: Refreshable<T>): void;
+export declare function markRefresh(node: Computed<any>): void;

package/dist/types-cjs/core/dev.d.cts

@@ -33,6 +33,14 @@ export interface DiagnosticCapture {
 export interface Diagnostics {
     subscribe(listener: DiagnosticListener): () => void;
     capture(): DiagnosticCapture;
+    /**
+     * Registers a console footer printed after the first console report of
+     * each diagnostic code — a discovery pointer to deeper guidance (e.g.
+     * solid-js registers its shipped repair skill). Returning undefined for
+     * an event suppresses the footer. Passing undefined unregisters and
+     * resets the once-per-code memory.
+     */
+    setConsoleFooter(footer: ((event: DiagnosticEvent) => string | undefined) | undefined): void;
 }
 export interface Dev {
     hooks: DevHooks;

package/dist/types-cjs/core/error.d.cts

@@ -39,6 +39,15 @@ export declare class StatusError extends Error {
 }
 /** Return the user's error from an internal status wrapper. */
 export declare function unwrapStatusError(error: unknown): unknown;
+/**
+ * Rejection value of `until(fn, { timeout })` when the predicate does not turn
+ * truthy within the window. Inside an `action()`, the rejection is thrown back
+ * in at the `yield` point — catchable there, or the action fails and its
+ * optimistic state reverts.
+ */
+export declare class TimeoutError extends Error {
+    constructor(message?: string);
+}
 export declare class NoOwnerError extends Error {
     constructor();
 }

package/dist/types-cjs/core/graph.d.cts

@@ -3,4 +3,26 @@ export declare function unlinkSubs(link: Link): Link | null;
 export declare function trimStaleDeps(el: Computed<any>): void;
 export declare function clearDeps(el: Computed<unknown>): void;
 export declare function unobserved(el: Computed<unknown>): void;
+/**
+ * Deferred dormancy for never-observed auto-dispose computeds (#3078).
+ *
+ * An untracked top-level read of a subscriber-less observation-lifecycle memo
+ * used to call unobserved() inline at the end of read(). That kept the leak
+ * closed (the compute links the memo into its deps' sub lists — without a
+ * teardown point a never-observed memo is retained by its sources forever;
+ * upstream alien-signals has exactly this retention), but it made reads
+ * destructive: each read disposed the node, the next read revived it with a
+ * full recompute in whatever ambient transition/lane context happened to be
+ * current, so consecutive reads could return different answers with no write
+ * in between.
+ *
+ * Instead, reads queue the node here and the scheduler sweeps at the top of
+ * the next flush (before runHeap, so a same-tick dirtying is reclaimed
+ * instead of recomputed). Reads become idempotent within a tick (the node
+ * stays alive and serves its cache, uniform with observed memos) while
+ * reclamation still happens within one microtask — the enqueue site arms
+ * schedule(), so a flush is guaranteed even when no other work is queued.
+ */
+export declare const dormantNodes: Set<Computed<unknown>>;
+export declare function sweepDormant(): void;
 export declare function link(dep: Signal<any> | Computed<any>, sub: Computed<any>, pendingObserver?: boolean): void;

package/dist/types-cjs/core/index.d.cts

@@ -1,5 +1,5 @@
-export { ContextNotFoundError, NoOwnerError, NotReadyError } from "./error.cjs";
-export { isEqual, untrack, runWithOwner, computed, signal, read, setSignal, setMemo, suppressComputedRecompute, optimisticSignal, optimisticComputed, refresh, staleValues, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots } from "./core.cjs";
+export { ContextNotFoundError, NoOwnerError, NotReadyError, TimeoutError } from "./error.cjs";
+export { isEqual, untrack, runWithOwner, computed, signal, read, setSignal, setMemo, suppressComputedRecompute, optimisticSignal, optimisticComputed, installAuthoritativeRead, markRefresh, staleValues, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots } from "./core.cjs";
 export { enableExternalSource, _resetExternalSourceConfig, type ExternalSourceFactory, type ExternalSource, type ExternalSourceConfig } from "./external.cjs";
 export { createOwner, createRoot, dispose, getNextChildId, getObserver, getOwner, isDisposed, cleanup, peekNextChildId } from "./owner.cjs";
 export { createContext, getContext, setContext, type Context, type ContextRecord } from "./context.cjs";