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

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

@@ -40,6 +40,24 @@ export interface Transition {
     _done: boolean | Transition;
     _gatedSubs: Set<Computed<any>>;
 }
+/**
+ * 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;
 /**
  * Permanently halts the reactive system. Called when a user error escapes
@@ -103,11 +121,19 @@ export declare class GlobalQueue extends Queue {
     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;
     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 (until()): installed at first until() call.
+     * Call sites are gated by CONFIG_AUTHORITATIVE_OBSERVED, which only until()'s
+     * carve-out read can set, so `!` invocations are safe once the gate holds. */
+    static _notifyAuthoritativeObservers: ((el: Signal<any> | Computed<any>) => void) | null;
     static _laneAsyncSettled: ((el: Computed<any>) => void) | null;
     static _trackOptimisticStore: ((store: any) => void) | null;
     flush(): void;
@@ -126,6 +152,14 @@ 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;
+/** 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;
 export declare function finalizePureQueue(completingTransition?: Transition | null, incomplete?: boolean): void;
 /**
  * Count of live `affects()` registrations across the system (including
@@ -178,3 +212,15 @@ 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;
+/** 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;

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

@@ -27,6 +27,11 @@ export interface NodeOptions<T> {
     ownedWrite?: boolean;
     /** Exclude this signal from snapshot capture (internal — not part of public API) */
     _noSnapshot?: boolean;
+    /** Extra CONFIG_* bits OR'd into the node's config at creation (internal —
+     * not part of public API). Used by resolve()/until() for
+     * CONFIG_DIRECT_COMMIT / CONFIG_AUTHORITATIVE_READ, keeping the per-flag
+     * option arms out of the core creation path. */
+    _extraConfig?: number;
     unobserved?: () => void;
     lazy?: boolean;
     sync?: boolean;
@@ -73,6 +78,13 @@ export interface NodeExtension {
      */
     _affectsCount: number;
     _inFlight: PromiseLike<any> | AsyncIterable<any> | null;
+    /** Cancellation for the CURRENT iterator flight (#3122): closes the
+     * iterator (`it.return()`), idempotent. Fired at the sites that release
+     * `_inFlight` so a superseded stream stops at supersede time — its owner
+     * cleanup registration may ride the zombie-disposal channel, which a held
+     * transition defers until the SUPERSEDING flight settles. Null for plain
+     * promise flights (no cancellation hook exists). */
+    _flightTeardown: (() => void) | null;
     _error: unknown;
     _blocked: boolean | undefined;
     _pendingSources: Set<Computed<any>> | undefined;

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

@@ -1,9 +1,9 @@
-export { $REFRESH, ContextNotFoundError, NoOwnerError, NotReadyError, action, createContext, createOwner, createRoot, runWithOwner, flush, getNextChildId, peekNextChildId, getContext, setContext, getOwner, isDisposed, getObserver, isEqual, untrack, isPending, latest, refresh, SUPPORTS_PROXY, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots, enforceLoadingBoundary, enableExternalSource, resetErrorHalt } from "./core/index.cjs";
+export { $REFRESH, ContextNotFoundError, NoOwnerError, NotReadyError, TimeoutError, action, createContext, createOwner, createRoot, runWithOwner, flush, getNextChildId, peekNextChildId, getContext, setContext, getOwner, isDisposed, getObserver, isEqual, untrack, isPending, latest, SUPPORTS_PROXY, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots, enforceLoadingBoundary, enableExternalSource, resetErrorHalt } from "./core/index.cjs";
 import { type Dev } from "./core/index.cjs";
 export declare const DEV: Dev | undefined;
 export type { Owner, Context, ContextRecord, IQueue, ExternalSourceFactory, ExternalSource, ExternalSourceConfig, Refreshable, Dev, DevHooks, DiagnosticCapture, DiagnosticCode, DiagnosticEvent, DiagnosticKind, Diagnostics, DiagnosticSeverity } from "./core/index.cjs";
-export { createSignal, createMemo, createEffect, createRenderEffect, createTrackedEffect, createReaction, createOptimistic, resolve, onSettled, onCleanup } from "./signals.cjs";
-export type { Accessor, SourceAccessor, Setter, Signal, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, SignalOptions, MemoOptions, NoInfer } from "./signals.cjs";
+export { createSignal, createMemo, createEffect, createRenderEffect, createTrackedEffect, createReaction, createOptimistic, refresh, resolve, until, onSettled, onCleanup } from "./signals.cjs";
+export type { Truthy, UntilOptions, Accessor, SourceAccessor, Setter, Signal, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, SignalOptions, MemoOptions, NoInfer } from "./signals.cjs";
 export { affects } from "./affects.cjs";
 export { mapArray, repeat, type Maybe } from "./map.cjs";
 export * from "./store/index.cjs";

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

@@ -491,6 +491,114 @@ export declare function createReaction(effectFn: EffectFunction<undefined> | Eff
  * @param fn a reactive expression to resolve
  */
 export declare function resolve<T>(fn: () => T): Promise<T>;
+/**
+ * Invalidates one reactive source, forcing it to re-execute even if its inputs
+ * haven't changed, and returns a promise for the target's NEXT QUIESCENT
+ * STATE — the re-ask (and anything that supersedes it) has settled.
+ *
+ * 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 that resolves immediately.
+ *
+ * The returned promise is safe to ignore (fire-and-forget refresh is
+ * unchanged, and a failed refetch will not surface an unhandled rejection).
+ * Awaiting it gives imperative flows the settle point without a reactive
+ * read:
+ * - Accessor targets resolve with the settled value; store targets resolve
+ *   with the store node passed (reads through it are fresh after the await).
+ * - A failed re-ask rejects with the error (inside an action's generator,
+ *   `yield refresh(x)` throws back at the yield point and the action reverts
+ *   like any other failure).
+ * - Semantics are quiescence, not flight identity: if another refresh (or
+ *   any invalidation) supersedes this one mid-flight, the promise waits for
+ *   — and delivers — whatever finally lands.
+ * - Inside an action, truth landing into the held transaction is STAGED;
+ *   the promise still settles then (matching `resolve()`/`until()`, #2930)
+ *   and delivers the staged value — the caller's own optimistic override is
+ *   never the delivered value.
+ * - The re-ask itself stays verdict-quiet exactly as before: `isPending`
+ *   does not flip for a bare refresh (pair with `affects()` for a visible
+ *   pending window).
+ *
+ * @example
+ * ```ts
+ * const user = createMemo(async () => fetch(`/users/${id()}`).then(r => r.json()));
+ *
+ * // Fire-and-forget re-fetch
+ * <button onClick={() => refresh(user)}>Reload</button>;
+ *
+ * // Imperative settle point
+ * const fresh = await refresh(user);
+ * ```
+ */
+export declare function refresh<T>(target: Refreshable<T>): Promise<T extends (...args: any) => infer V ? V : T>;
+/** Falsy values a truthy predicate result is narrowed against. */
+export type Truthy<T> = Exclude<T, false | 0 | 0n | "" | null | undefined>;
+export interface UntilOptions {
+    /** Reject with `TimeoutError` if the predicate has not turned truthy within
+     * this many milliseconds. Strongly recommended when the confirming truth
+     * arrives over a transport that can drop (sockets, subscriptions). */
+    timeout?: number;
+    /** Reject with `signal.reason` on abort. */
+    signal?: AbortSignal;
+}
+/**
+ * Awaits a reactive predicate and resolves the first time it settles *truthy*,
+ * with that (narrowed) value. Falsy results and pending async reads both mean
+ * "not yet": the subscription stays live and re-evaluates as sources change.
+ * If the predicate settles with an error — a throw, or an async source that
+ * rejects — the promise rejects with it, as do timeout and abort.
+ *
+ * Where {@link resolve} answers "what is this value" (first settled value,
+ * whatever it is), `until` answers "when does the world confirm this
+ * condition". The difference matters inside an `action()`: `yield until(...)`
+ * holds the action's transaction — and any optimistic state riding it — open
+ * until the condition is independently true.
+ *
+ * To make that sound, `until`'s predicate reads the AUTHORITATIVE view — and
+ * this is the one read-semantics difference from `resolve`, which reads the
+ * normal (transaction's own) view where overrides are visible:
+ *
+ * - **Optimistic overrides are invisible** to the predicate. Your own
+ *   tentative write can never satisfy your own ack, even on the
+ *   single-primitive shape where the optimistic store IS the live-fed store.
+ *   (Derived computeds serve their normal cached values — express the
+ *   condition over sources of truth, not derived views of the overlay.)
+ * - **Everything else reads normally, including uncommitted transition-staged
+ *   data.** Real data is real wherever it currently lives. This is
+ *   load-bearing, not a loophole: truth that arrives *into* the open
+ *   transaction (a `refresh()` this action issued, an entangled landing)
+ *   stages and cannot commit until the hold releases — a predicate that
+ *   refused staged reads would deadlock on the very data it is waiting for.
+ *
+ * This is the acknowledgment mechanism for mutations confirmed on a live data
+ * channel (sockets, subscriptions, live queries) rather than by the mutation's
+ * own response: correlate by a client-generated id or version in the predicate,
+ * and let truth arrive however it arrives — push, refetch, or another tab.
+ *
+ * Failure composes with action semantics: a rejection is thrown back into the
+ * generator at the `yield` point — catchable there, or the action fails and
+ * its optimistic state reverts.
+ *
+ * Must be called *outside* a tracking scope.
+ *
+ * @example
+ * ```ts
+ * const send = action(async function* (text: string) {
+ *   const clientId = crypto.randomUUID();
+ *   setMessages(m => { m.push({ clientId, text, pending: true }); }); // optimistic
+ *   await socket.send({ clientId, text }); // fire-and-forget transport
+ *   // Hold until the live source echoes the write (authoritative view —
+ *   // the optimistic row above cannot satisfy this):
+ *   yield until(() => messages.some(m => m.clientId === clientId), { timeout: 10_000 });
+ * });
+ * ```
+ *
+ * @param fn a reactive predicate over authoritative state
+ * @param options optional `timeout` (ms) and abort `signal`
+ */
+export declare function until<T>(fn: () => T, options?: UntilOptions): Promise<Truthy<T>>;
 /**
  * Creates an optimistic signal that can be used to optimistically update a value
  * and then revert it back to the previous value at end of transition.

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

@@ -4,6 +4,8 @@ export { isWrappable, $TRACK, $PROXY, $TARGET } from "./store.cjs";
 import type { NoFn, ProjectionOptions, Store, StoreOptions, StoreSetter } from "./store.cjs";
 import type { Refreshable } from "../core/index.cjs";
 export { createProjectionNext as createProjection } from "./next/projection.cjs";
+export { registerPatch, registerRowOps, registerSlotPatchNext as registerSlotPatch, patchableRaw } from "./next/patch.cjs";
+export { storeIsShallow, storeHasFamily, storeHasOptimisticFamily } from "./next/store.cjs";
 export { createOptimisticStoreNext as createOptimisticStore } from "./next/optimistic.cjs";
 /** Public createStore: plain form `(init, options?)` and derived writable
  * form `(fn, seed, options?)`. */

package/dist/types-cjs/store/next/optimistic.d.cts

@@ -1,20 +1,23 @@
+import { type Transition } from "../../core/scheduler.cjs";
 import { type NoFn, type ProjectionOptions, type Store, type StoreSetter } from "../store.cjs";
-import type { StoreNextFamily, StoreNextTarget } from "./target.cjs";
+import type { StoreNextTarget } from "./target.cjs";
+/** #3164 fold: a stamped truth is HELD (masked from ordinary readers until
+ * the reveal) only while its transition is live AND retaining optimism —
+ * overrides are what make partial-coverage composition a tear. A plain
+ * async transition carries no overrides, so downstream computes must see
+ * staged values to converge (normal speculation). Resolves merges first:
+ * merge unions optimistic nodes/stores into the target. */
+export declare function transitionHoldsOptimism(transition: Transition): boolean;
 export declare function createOptimisticStoreNext<T extends object = {}>(first: T | ((store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>), second?: NoFn<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Store<T>, set: StoreSetter<T>];
 /** Diff the draft against the current OPTIMISTIC VIEW (committed + active
  * overrides — the same view the draft was seeded from) and emit engine writes
  * for exactly the changed keys. Visible-view diffing keeps no-op writes from
  * entangling lanes (RUL-10 / opt R38). */
 export declare function notifyOptimisticWrites(t: StoreNextTarget, pb: Record<PropertyKey, any>): void;
-/**
- * Landing consumption (RUL-2): fresh authoritative data supersedes every
- * tentative override in the family. Mirrors legacy clearProjectionOverride —
- * drop the override, clear lane/ownership, notify subscribers whose visible
- * value changes (reversion effects go to regular queues via the projection
- * write posture the caller holds).
- */
-export declare function consumeOverridesNext(fam: StoreNextFamily): void;
 /** Optimistic-view composition for snapshot/deep (O1: snapshot is the CURRENT
  * view, lane values included; a fresh copy per call during pending windows —
- * RUL-12). Returns `src` untouched when no override is active on `t`. */
+ * RUL-12). Returns `src` untouched when no override is active on `t`.
+ * Authoritative-view reads (until()'s predicate) skip composition entirely:
+ * the predicate observes authoritative truth, never the caller's tentative
+ * overlay. (Write-side emission callers never run under such a compute.) */
 export declare function optimisticView(t: StoreNextTarget, src: Record<PropertyKey, any>): Record<PropertyKey, any>;

package/dist/types-cjs/store/next/patch-hooks.d.cts

@@ -0,0 +1,41 @@
+import type { StoreNextTarget } from "./target.cjs";
+import type { RowOps } from "./patch.cjs";
+/**
+ * Patch-channel emission seams (pay-for-use). The store/reconcile/optimistic
+ * write paths emit through these installed hook objects instead of importing
+ * `patch.js` statically, so the channel tree-shakes out of apps that never
+ * register a patch consumer.
+ *
+ * TWO TIERS, armed at registration (patch.js installs them; it is retained
+ * only through its registration exports, which only compiled patch-mode
+ * output — via the web runtime's driver module — imports):
+ * - VALUE hooks (`patchHooks`): record patches. Armed by `registerPatch` —
+ *   present in any bundle with one eligible template under patch mode.
+ * - ROW hooks (`rowHooks`): list structure (row ops, slot ticks, the
+ *   identity/keyed diff builders in reconcile.js they drag in). Armed by
+ *   `registerRowOps`/`registerSlotPatchNext` — the LIST driver's
+ *   registrations, so value-only bundles never retain the row machinery.
+ *
+ * Soundness: every emission site is guarded by the matching `pc` channel
+ * (`pc.p` for value, `pc.ro`/`pc.sp` for rows), and a target can only
+ * acquire that channel through the corresponding registration — so each
+ * hook object is installed by the time any guard passes. Type-only imports
+ * from `patch.js` are erased.
+ */
+export interface PatchValueHooks {
+    emitPatch(t: StoreNextTarget, next: any, prev: any): void;
+    emitPatchLocal(t: StoreNextTarget, next: any, prev: any): void;
+    emitPatchOptimistic(t: StoreNextTarget, next: any, prev: any): void;
+    hasPatches(): boolean;
+    demoteToEffects(t: StoreNextTarget): void;
+}
+export interface PatchRowHooks {
+    emitRowOps(t: StoreNextTarget, next: any[], ops: RowOps): void;
+    emitSlotPatch(t: StoreNextTarget, index: number, next: any, prev: any): void;
+    emitSetterRowOps(t: StoreNextTarget, prevRows: any[], nextRows: any[]): void;
+    emitRowOpsOptimistic(t: StoreNextTarget, next: any[] | null, ops: RowOps | null): void;
+}
+export declare let patchHooks: PatchValueHooks | null;
+export declare let rowHooks: PatchRowHooks | null;
+export declare function installPatchHooks(hooks: PatchValueHooks): void;
+export declare function installRowHooks(hooks: PatchRowHooks): void;

package/dist/types-cjs/store/next/patch.d.cts

@@ -0,0 +1,91 @@
+import type { Owner } from "../../core/types.cjs";
+import { type StoreNextTarget } from "./target.cjs";
+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-cjs/store/next/projection.d.cts

@@ -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-cjs/store/next/reconcile.d.cts

@@ -1,3 +1,17 @@
+import type { RowOps } from "./patch.cjs";
+import { type StoreNextTarget } from "./target.cjs";
 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-cjs/store/next/store.d.cts

@@ -1,5 +1,7 @@
 import type { Signal } from "../../core/types.cjs";
-import { type StoreNextFamily, type StoreNextTarget } from "./target.cjs";
+import { type StoreNextFamily, type StoreNextTarget, type PatchChannel } from "./target.cjs";
+/** 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;
 /**