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

package/dist/prod/store/utils.js

@@ -1,4 +1,4 @@
-import { pendingCheckActive } from "../core/core.js";
+import "../core/core.js";
 
 import { SUPPORTS_PROXY } from "../core/constants.js";
 
@@ -12,162 +12,29 @@ import "../core/effect.js";
 
 import { createMemo } from "../signals.js";
 
-import { ownEnumerableKeys, $PROXY, isWrappable, $TARGET, lookupTarget, trackSelf, witnessAffectsMark, mergedOverlay, STORE_VALUE, storeLookup, STORE_LOOKUP, $DELETED, wrap, getStoreSymbols, getPropertyDescriptor, getStoreKeys, getKeys, $TRACK, rawValuesUsed, isRawValue } from "./store.js";
-
-function snapshotImpl(e, t, r, n) {
-    let o, s, i, c, f, u;
-    if (!isWrappable(e)) return e;
-    if (r && r.has(e)) return r.get(e);
-    if (!r) r = new Map;
-    if (o = e[$TARGET] || lookupTarget(e, n)) {
-        if (t) {
-            trackSelf(o, $TRACK);
-            // A tracked walk reads THROUGH the record without touching the proxy
-            // traps — witness the record's affects() channel like a trap read would.
-                        if (pendingCheckActive) witnessAffectsMark(o);
-        }
-        i = mergedOverlay(o);
-        // A derived store's STORE_VALUE is the inner store's live proxy
-        // (store-in-store: createOptimisticStore/createProjection over a store).
-        // Without an overlay of its own, the fast path below would map to — and
-        // could return — that proxy verbatim. Recurse instead so the
-        // inner store's own target branch unwraps it (chains of any depth).
-        // With an overlay, a fresh `result` is always built, so the walk over the
-        // inner proxy already copies plain values.
-                if (!i && o[STORE_VALUE][$TARGET]) {
-            f = snapshotImpl(o[STORE_VALUE], t, r, n);
-            r.set(e, f);
-            return f;
-        }
-        s = Array.isArray(o[STORE_VALUE]);
-        r.set(e, i ? c = s ? [] : Object.create(Object.getPrototypeOf(o[STORE_VALUE])) : o[STORE_VALUE]);
-        e = o[STORE_VALUE];
-        n = o[STORE_LOOKUP] ?? storeLookup;
-    } else {
-        s = Array.isArray(e);
-        r.set(e, e);
-    }
-    if (s) {
-        const s = i?.length ?? e.length;
-        for (let a = 0; a < s; a++) {
-            u = i && a in i ? i[a] : e[a];
-            if (u === $DELETED) continue;
-            if (t && isWrappable(u) && !(rawValuesUsed && isRawValue(u))) wrap(u, o);
-            if ((f = snapshotImpl(u, t, r, n)) !== u || c) {
-                if (!c) r.set(e, c = [ ...e ]);
-                c[a] = f;
-            }
-        }
-        // Enumerate array symbols separately to avoid scanning indices twice.
-        // Spread copies omit symbols, so assign them after the numeric walk.
-                const a = n ? getStoreSymbols(e, i) : [];
-        for (let s = 0, l = a.length; s < l; s++) {
-            const l = a[s];
-            const p = getPropertyDescriptor(e, i, l);
-            if (!p || p.get) continue;
-            u = i && l in i ? i[l] : e[l];
-            if (t && isWrappable(u) && !(rawValuesUsed && isRawValue(u))) wrap(u, o);
-            f = snapshotImpl(u, t, r, n);
-            if (f !== u || c) {
-                if (!c) r.set(e, c = Object.assign([ ...e ], e));
-                c[l] = f;
-            }
-        }
-        // Deleted trailing slots are skipped above, so restore length to preserve
-        // holes instead of truncating the copy (#2846) — mirrors unwrapStoreValue.
-                if (c) c.length = s;
-    } else if (!i) {
-        // Specialized walk for the common no-overlay case (from #2756): the own
-        // descriptor gives the value directly, so each property is read once with
-        // no overlay membership checks.
-        // A lookup means this object belongs to an immutable store backing tree,
-        // even if that nested value has not needed its own proxy yet.
-        const s = n ? getStoreKeys(e, undefined) : getKeys(e, undefined);
-        for (let i = 0, a = s.length; i < a; i++) {
-            const a = s[i];
-            const l = Object.getOwnPropertyDescriptor(e, a);
-            if (l.get) continue;
-            u = l.value;
-            if (t && isWrappable(u) && !(rawValuesUsed && isRawValue(u))) wrap(u, o);
-            if ((f = snapshotImpl(u, t, r, n)) !== u || c) {
-                if (!c) {
-                    c = Object.create(Object.getPrototypeOf(e));
-                    Object.assign(c, e);
-                }
-                c[a] = f;
-            }
-        }
-    } else {
-        // An override only exists on a store record, and the target branch above
-        // always set `lookup` alongside it — so this branch is always store-keyed.
-        const s = getStoreKeys(e, i);
-        for (let a = 0, l = s.length; a < l; a++) {
-            let l = s[a];
-            const p = getPropertyDescriptor(e, i, l);
-            if (p.get) continue;
-            u = l in i ? i[l] : e[l];
-            if (t && isWrappable(u) && !(rawValuesUsed && isRawValue(u))) wrap(u, o);
-            if ((f = snapshotImpl(u, t, r, n)) !== e[l] || c) {
-                if (!c) {
-                    c = Object.create(Object.getPrototypeOf(e));
-                    Object.assign(c, e);
-                }
-                c[l] = f;
-            }
-        }
-    }
-    return c || e;
-}
-
-function snapshot(e, t, r) {
-    return snapshotImpl(e, false, t, r);
-}
-
-/**
- * Returns a plain (non-proxy) deep copy **and** subscribes the current
- * tracking scope to every nested change in the source store. Any write
- * anywhere in the subtree invalidates the consumer.
- *
- * Use this when you need plain data inside a reactive scope and want to
- * react to deep mutations (e.g. passing a snapshot to `reconcile()` or to a
- * memo that should rerun on any nested change). For most read paths, prefer
- * direct property access — Solid stores already track per-property reads
- * with no `deep()` wrapper needed.
- *
- * @example
- * ```ts
- * const [state] = createStore({ a: { b: { c: 1 } } });
- *
- * createEffect(
- *   () => deep(state),                  // reruns on any nested change
- *   plain => sendToWorker(plain)        // worker gets a non-proxy copy
- * );
- * ```
- */ function deep(e) {
-    return snapshotImpl(e, true);
-}
+import { ownEnumerableKeys, $PROXY } from "./store.js";
 
 function trueFn() {
     return true;
 }
 
 const propTraps = {
-    get(e, t, r) {
-        if (t === $PROXY) return r;
-        return e.get(t);
+    get(e, r, t) {
+        if (r === $PROXY) return t;
+        return e.get(r);
     },
-    has(e, t) {
-        if (t === $PROXY) return true;
-        return e.has(t);
+    has(e, r) {
+        if (r === $PROXY) return true;
+        return e.has(r);
     },
     set: trueFn,
     deleteProperty: trueFn,
-    getOwnPropertyDescriptor(e, t) {
+    getOwnPropertyDescriptor(e, r) {
         return {
             configurable: true,
             enumerable: true,
             get() {
-                return e.get(t);
+                return e.get(r);
             },
             set: trueFn,
             deleteProperty: trueFn
@@ -205,36 +72,36 @@ const $SOURCES = Symbol(0);
  * ```
  */ function merge(...e) {
     if (e.length === 1 && typeof e[0] !== "function") return e[0];
-    let t = false;
-    const r = [];
+    let r = false;
+    const t = [];
     for (let n = 0; n < e.length; n++) {
         const o = e[n];
-        t = t || !!o && $PROXY in o;
+        r = r || !!o && $PROXY in o;
         const s = !!o && o[$SOURCES];
         if (s) {
-            for (let e = 0; e < s.length; e++) r.push(s[e]);
-        } else r.push(typeof o === "function" ? (t = true, createMemo(o)) : o);
+            for (let e = 0; e < s.length; e++) t.push(s[e]);
+        } else t.push(typeof o === "function" ? (r = true, createMemo(o)) : o);
     }
-    if (SUPPORTS_PROXY && t) {
+    if (SUPPORTS_PROXY && r) {
         return new Proxy({
             get(e) {
-                if (e === $SOURCES) return r;
-                for (let t = r.length - 1; t >= 0; t--) {
-                    const n = resolveSource(r[t]);
+                if (e === $SOURCES) return t;
+                for (let r = t.length - 1; r >= 0; r--) {
+                    const n = resolveSource(t[r]);
                     if (e in n) return n[e];
                 }
             },
             has(e) {
-                for (let t = r.length - 1; t >= 0; t--) {
-                    if (e in resolveSource(r[t])) return true;
+                for (let r = t.length - 1; r >= 0; r--) {
+                    if (e in resolveSource(t[r])) return true;
                 }
                 return false;
             },
             keys() {
                 const e = new Set;
-                for (let t = 0; t < r.length; t++) {
-                    const n = ownEnumerableKeys(resolveSource(r[t]));
-                    for (let t = 0; t < n.length; t++) e.add(n[t]);
+                for (let r = 0; r < t.length; r++) {
+                    const n = ownEnumerableKeys(resolveSource(t[r]));
+                    for (let r = 0; r < n.length; r++) e.add(n[r]);
                 }
                 return [ ...e ];
             }
@@ -242,37 +109,37 @@ const $SOURCES = Symbol(0);
     }
     const n = Object.create(null);
     let o = false;
-    let s = r.length - 1;
+    let s = t.length - 1;
     for (let e = s; e >= 0; e--) {
-        const t = r[e];
-        if (!t) {
+        const r = t[e];
+        if (!r) {
             e === s && s--;
             continue;
         }
-        const i = Object.getOwnPropertyNames(t);
-        for (let r = i.length - 1; r >= 0; r--) {
-            const c = i[r];
+        const u = Object.getOwnPropertyNames(r);
+        for (let t = u.length - 1; t >= 0; t--) {
+            const c = u[t];
             if (c === "__proto__" || c === "constructor") continue;
             if (!n[c]) {
                 o = o || e !== s;
-                const r = Object.getOwnPropertyDescriptor(t, c);
-                n[c] = r.get ? {
+                const t = Object.getOwnPropertyDescriptor(r, c);
+                n[c] = t.get ? {
                     enumerable: true,
                     configurable: true,
-                    get: r.get.bind(t)
-                } : r;
+                    get: t.get.bind(r)
+                } : t;
             }
         }
     }
-    if (!o) return r[s];
-    const i = {};
+    if (!o) return t[s];
+    const u = {};
     const c = Object.keys(n);
     for (let e = c.length - 1; e >= 0; e--) {
-        const t = c[e], r = n[t];
-        if (r.get) Object.defineProperty(i, t, r); else i[t] = r.value;
+        const r = c[e], t = n[r];
+        if (t.get) Object.defineProperty(u, r, t); else u[r] = t.value;
     }
-    i[$SOURCES] = r;
-    return i;
+    u[$SOURCES] = t;
+    return u;
 }
 
 /**
@@ -299,30 +166,36 @@ const $SOURCES = Symbol(0);
  *   );
  * }
  * ```
- */ function omit(e, ...t) {
+ */ function omit(e, ...r) {
     if (SUPPORTS_PROXY && $PROXY in e) {
         return new Proxy({
-            get(r) {
-                return t.includes(r) ? undefined : e[r];
+            get(t) {
+                // $SOURCES must not tunnel through the filter: merge() flattens
+                // whatever answers it, so forwarding would hand a re-merge the
+                // UNFILTERED sources of an underlying merge proxy and the omitted
+                // keys leak back in (#3014 — the SSR element-spread path re-merges
+                // static attributes with the rest object). Opaque here: merge
+                // composes omit proxies through their traps instead.
+                return t === $SOURCES || r.includes(t) ? undefined : e[t];
             },
-            has(r) {
-                return !t.includes(r) && r in e;
+            has(t) {
+                return t !== $SOURCES && !r.includes(t) && t in e;
             },
             keys() {
-                return ownEnumerableKeys(e).filter(e => !t.includes(e));
+                return ownEnumerableKeys(e).filter(e => !r.includes(e));
             }
         }, propTraps);
     }
-    const r = {};
+    const t = {};
     const n = Object.getOwnPropertyNames(e);
-    const o = t.length > 4 && n.length > t.length ? new Set(t) : undefined;
+    const o = r.length > 4 && n.length > r.length ? new Set(r) : undefined;
     for (const s of n) {
-        if (o ? !o.has(s) : !t.includes(s)) {
-            const t = Object.getOwnPropertyDescriptor(e, s);
-            !t.get && !t.set && t.enumerable && t.writable && t.configurable ? r[s] = t.value : Object.defineProperty(r, s, t);
+        if (o ? !o.has(s) : !r.includes(s)) {
+            const r = Object.getOwnPropertyDescriptor(e, s);
+            !r.get && !r.set && r.enumerable && r.writable && r.configurable ? t[s] = r.value : Object.defineProperty(t, s, r);
         }
     }
-    return r;
+    return t;
 }
 
-export { deep, merge, omit, snapshot };
+export { merge, omit };

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

@@ -88,6 +88,14 @@ export declare const READ_SLOW: unique symbol;
  */
 export declare function readNodeFast<T>(el: Signal<T>): T | typeof READ_SLOW;
 export declare function read<T>(el: Signal<T> | Computed<T>): T;
+/**
+ * Store-rewrite setter guard: the rewrite parks writes in a pending backing
+ * (no setSignal at write time), so the owned-scope write protection must
+ * fire at the setter entry instead. Mirrors setSignal's guard condition
+ * minus the node-specific exemptions (ownedWrite/firewall), which don't
+ * apply to plain store setters.
+ */
+export declare function devGuardStoreSetterWrite(): void;
 export declare function setSignal<T>(el: Signal<T> | Computed<T>, v: T | ((prev: T) => T)): T;
 /**
  * Suppresses automatic recomputation of `el` until the scheduler drains. Used

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

@@ -6,7 +6,7 @@ export interface DevHooks {
     onStoreNodeUpdate?: (state: any, property: PropertyKey, value: any, prev: any) => void;
 }
 export type DiagnosticSeverity = "warn" | "error";
-export type DiagnosticCode = "STRICT_READ_UNTRACKED" | "PENDING_ASYNC_UNTRACKED_READ" | "PENDING_ASYNC_FORBIDDEN_SCOPE" | "REACTIVE_WRITE_IN_OWNED_SCOPE" | "ACTION_CALLED_IN_OWNED_SCOPE" | "RUN_WITH_DISPOSED_OWNER" | "NO_OWNER_CLEANUP" | "CLEANUP_IN_FORBIDDEN_SCOPE" | "SETTLED_CLEANUP_UNOWNED" | "PRIMITIVE_IN_FORBIDDEN_SCOPE" | "NO_OWNER_EFFECT" | "NO_OWNER_BOUNDARY" | "ASYNC_OUTSIDE_LOADING_BOUNDARY" | "INVALID_REFRESH_TARGET" | "INVALID_AFFECTS_TARGET" | "MISSING_EFFECT_FN" | "SYNC_NODE_RECEIVED_ASYNC" | "REACTIVITY_HALTED" | "INVARIANT_VIOLATION";
+export type DiagnosticCode = "STRICT_READ_UNTRACKED" | "PENDING_ASYNC_UNTRACKED_READ" | "PENDING_ASYNC_FORBIDDEN_SCOPE" | "REACTIVE_WRITE_IN_OWNED_SCOPE" | "ACTION_CALLED_IN_OWNED_SCOPE" | "RUN_WITH_DISPOSED_OWNER" | "NO_OWNER_CLEANUP" | "CLEANUP_IN_FORBIDDEN_SCOPE" | "SETTLED_CLEANUP_UNOWNED" | "FLUSH_IN_EFFECT_CALLBACK" | "PRIMITIVE_IN_FORBIDDEN_SCOPE" | "NO_OWNER_EFFECT" | "NO_OWNER_BOUNDARY" | "ASYNC_OUTSIDE_LOADING_BOUNDARY" | "INVALID_REFRESH_TARGET" | "INVALID_AFFECTS_TARGET" | "MISSING_EFFECT_FN" | "SYNC_NODE_RECEIVED_ASYNC" | "REACTIVITY_HALTED" | "INVARIANT_VIOLATION";
 export type DiagnosticKind = "strict-read" | "async" | "write" | "lifecycle" | "owner" | "error";
 export interface DiagnosticEvent {
     sequence: number;

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

@@ -9,7 +9,6 @@ export declare let clock: number;
 export declare let activeTransition: Transition | null;
 export declare let projectionWriteActive: boolean;
 export declare let _hitUnhandledAsync: boolean;
-export declare function registerTransientStoreNode(node: Signal<any>): void;
 export declare function resetUnhandledAsync(): void;
 /**
  * Toggles the dev-mode "must be inside a `<Loading>` boundary" enforcement
@@ -22,6 +21,7 @@ export declare function resetUnhandledAsync(): void;
 export declare function enforceLoadingBoundary(enabled: boolean): void;
 export declare function setProjectionWriteActive(value: boolean): void;
 export declare function setTrackedQueueCallback(value: boolean): void;
+export declare function setEffectCallback(value: boolean): void;
 export type QueueCallback = (type: number) => void;
 type QueueStub = {
     _queues: [QueueCallback[], QueueCallback[]];
@@ -105,7 +105,7 @@ export declare class GlobalQueue extends Queue {
     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) | null;
+    static _recomputeLane: ((el: Computed<any>, own: boolean) => OptimisticLane | null | false) | null;
     static _laneAsyncPending: ((el: Computed<any>) => void) | null;
     static _laneAsyncSettled: ((el: Computed<any>) => void) | null;
     static _trackOptimisticStore: ((store: any) => void) | null;
@@ -116,6 +116,8 @@ export declare class GlobalQueue extends Queue {
 export declare function queuePendingNode(node: Signal<any>): void;
 export declare function armReaskClear(): void;
 export declare function insertSubs(node: Signal<any> | Computed<any>, optimistic?: boolean): void;
+export declare let storeCommitHook: (() => void) | null;
+export declare function setStoreCommitHook(fn: () => void): void;
 export declare function finalizePureQueue(completingTransition?: Transition | null, incomplete?: boolean): void;
 /**
  * Count of live `affects()` registrations across the system (including

package/dist/types/signals.d.ts

@@ -414,6 +414,12 @@ export declare function createRenderEffect<T>(compute: ComputeFunction<undefined
  * may run multiple times for a single change or show tearing (reading inconsistent
  * state). Use only when dynamic subscription patterns require same-scope tracking.
  *
+ * The callback runs during the flush itself: writes made inside it are queued
+ * into the same flush's continuation and are never visible to the callback's
+ * own reads (reads return settled values, as in every effect-phase scope), and
+ * `flush()` cannot be called from inside it (dev throws; production is a
+ * no-op) — defer with `queueMicrotask(() => flush())` if needed.
+ *
  * ```typescript
  * createTrackedEffect(compute, options?: { name?: string });
  * ```
@@ -542,6 +548,19 @@ export declare function createOptimistic<T>(fn: ComputeFunction<T>, options?: Si
  * Reactive reads inside the callback are *not* tracked — to react to
  * subsequent settles, register a new `onSettled` each time.
  *
+ * The callback runs during the settle flush itself, which gives it the same
+ * write semantics as every other effect-phase scope (the effect half of
+ * `createEffect`, event handlers):
+ *
+ * - **Writes** are queued into the same flush's continuation — dependent memos
+ *   and effects update before the flush returns — but reads inside the
+ *   callback keep returning the settled (pre-write) values. A callback never
+ *   observes its own unsettled write. Functional setters still compose:
+ *   `set(v => v + 1)` twice increments twice.
+ * - **`flush()` cannot be called** from inside the callback — the flush is
+ *   already running (dev throws; production is a no-op). To force a drain
+ *   after this settle, defer it: `queueMicrotask(() => flush())`.
+ *
  * `onCleanup` is **not** allowed inside the callback — return a cleanup
  * function instead. The returned cleanup runs on owner disposal.
  *

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

@@ -1,9 +1,19 @@
 export type { Store, StoreReturn, ProjectionStoreReturn, StoreSetter, StoreNode, StoreOptions, ProjectionOptions, NotWrappable, SolidStore } from "./store.js";
 export type { Merge, Omit } from "./utils.js";
-export { isWrappable, createStore, $TRACK, $PROXY, $TARGET } from "./store.js";
-export { createProjection } from "./projection.js";
-export { createOptimisticStore } from "./optimistic.js";
-export { reconcile } from "./reconcile.js";
+export { isWrappable, $TRACK, $PROXY, $TARGET } from "./store.js";
+import type { NoFn, ProjectionOptions, Store, StoreOptions, StoreSetter } from "./store.js";
+import type { Refreshable } from "../core/index.js";
+export { createProjectionNext as createProjection } from "./next/projection.js";
+export { createOptimisticStoreNext as createOptimisticStore } from "./next/optimistic.js";
+/** Public createStore: plain form `(init, options?)` and derived writable
+ * form `(fn, seed, options?)`. */
+export declare function createStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>, options?: StoreOptions & {
+    shallow?: boolean;
+}): [get: Store<T>, set: StoreSetter<T>];
+export declare function createStore<T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Refreshable<Store<T>>, set: StoreSetter<T>];
+export declare function reconcile<T extends U, U>(value: T, key?: string | ((item: NonNullable<any>) => any) | null): (state: U) => T;
+export declare function snapshot<T>(value: T): T;
+export declare function deep<T>(value: T): T;
 export { storePath } from "./storePath.js";
 export type { PathSetter, Part, StorePathRange, ArrayFilterFn, CustomPartial } from "./storePath.js";
-export { snapshot, deep, merge, omit } from "./utils.js";
+export { merge, omit } from "./utils.js";

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

@@ -0,0 +1,20 @@
+import { type NoFn, type ProjectionOptions, type Store, type StoreSetter } from "../store.js";
+import type { StoreNextFamily, StoreNextTarget } from "./target.js";
+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`. */
+export declare function optimisticView(t: StoreNextTarget, src: Record<PropertyKey, any>): Record<PropertyKey, any>;

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

@@ -0,0 +1,24 @@
+/**
+ * Store rewrite — projections (§7/§7b): a projection is a computed store.
+ * The derive runs inside a computed whose recompute merges its output into
+ * the projection's backing through the adoption channel (replace-mode root:
+ * entity changes merge in place, the root proxy is stable for life). Children
+ * wrap into the projection's own FAMILY (writes land here, never in a source
+ * family), and every family node carries the projection computed as its
+ * firewall — reads link the derive's status and lifecycle natively. The §6c
+ * status gate in the traps makes an uninitialized async derive's seed
+ * unobservable through every read surface.
+ *
+ * Mirrors the legacy runProjectionComputed shape (shadow runs for open
+ * loading windows, handleAsync landings, commit-through-setter) on next
+ * primitives; the generic draft write-traps are reused from the legacy
+ * module unchanged.
+ */
+import { type Computed, type Refreshable } from "../../core/index.js";
+import { type NoFn, type ProjectionOptions, type Store } from "../store.js";
+export declare function createProjectionNext<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>>;
+/** Derived writable store (legacy parity): a projection whose public setter
+ * 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>;

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

@@ -0,0 +1,3 @@
+type KeyFn = (item: any) => any;
+export declare function reconcileNextState(value: any, state: any, key: string | KeyFn | null | undefined, replace?: boolean): void;
+export {};

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

@@ -0,0 +1,71 @@
+import type { Signal } from "../../core/types.js";
+import { type StoreNextFamily, type StoreNextTarget } from "./target.js";
+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;
+export declare function getNode(target: StoreNextTarget, key: PropertyKey, current: any): Signal<any>;
+export declare function getHasNode(target: StoreNextTarget, key: PropertyKey, present: boolean): Signal<boolean>;
+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;
+/**
+ * Adoption (2026-08-16c): the incoming object becomes the committed backing
+ * IMMEDIATELY — reconcile is eagerly visible to every reader (shipped
+ * contract; only its notifications batch), unlike setter writes which stay
+ * pending until flush. Ownership resets (incoming is unowned/user data). Any
+ * staged draft clone folds into the diff and is discarded — next is the
+ * authoritative base (R21/R32).
+ */
+export declare function adoptPB(target: StoreNextTarget, incoming: Record<PropertyKey, any>, eager?: boolean): void;
+/** 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;
+/**
+ * The fold diff walks SUBSCRIPTION KEYS ONLY (legacy parity: `for key in
+ * nodes`): nodes exist exactly where something tracked, so unobserved data
+ * costs nothing here regardless of object size. Accessor safety rides the
+ * sticky `t.a` flag — a node's key was necessarily read, so the get trap has
+ * already seen whether it is an accessor.
+ */
+/** One node's fold notification (shared by notifyFold's walk and the fused
+ * adoption walk): accessor-aware compare + equality/identity-gated setSignal. */
+export declare function notifyKeyDiff(node: Signal<any>, key: PropertyKey, old: Record<PropertyKey, any>, neu: Record<PropertyKey, any>, probe?: boolean): void;
+/** Accessor-flag probe for the fused walk's early-continue (accessor keys
+ * can never identity-skip: their VALUE is the descriptor's product). */
+export declare function hasAccessorFlag(node: Signal<any>): boolean;
+/** Fused-walk per-key notification with values already in hand: the caller
+ * fetched both sides and handled the identity skip; this applies the
+ * accessor branch (cached flag only — reconcile channel) or the plain
+ * equality/identity-gated write. */
+export declare function notifyKeyValue(node: Signal<any>, key: PropertyKey, ov: any, nv: any, old: Record<PropertyKey, any>, neu: Record<PropertyKey, any>): void;
+/** Presence + membership halves of a fold notification (shared tail). */
+export declare function notifyFoldTail(t: StoreNextTarget, old: Record<PropertyKey, any>, neu: Record<PropertyKey, any>): void;
+export declare function notifyFold(t: StoreNextTarget, old: Record<PropertyKey, any>, neu: Record<PropertyKey, any>): void;
+/** Authoritative-write wrapper exported for the optimistic module: sets the
+ * scheduler's projectionWriteActive through THIS module's binding (proven to
+ * share the instance core reads — cross-module live-binding writes from other
+ * store modules were observed not to propagate under the test transform). */
+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;
+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
+ * replacements as adoptions. `guard=false` skips the owned-scope dev guard —
+ * 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>];
+/** Tracking deep snapshot (`deep()` for next targets): subscribes to the
+ * key-set and every property 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;
+/**
+ * Snapshot with per-object registration resolution (RUL-12 DAG ruling): every
+ * reachable wrappable resolves through its target's CURRENT backing, so
+ * privatized subtrees are seen through any parent path. Identity-preserving:
+ * a subtree with no substitutions below returns its own object (zero copy for
+ * settled, never-diverged graphs).
+ */
+export declare function snapshotNext<T>(value: T): T;