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

package/dist/prod/core/optimistic.js

@@ -1,4 +1,4 @@
-import { NOT_PENDING, unwrapOverride, STATUS_UNINITIALIZED, CONFIG_HAS_LANE, OVERRIDE_UNDEFINED, STATUS_PENDING, REACTIVE_MANUAL_WRITE, REACTIVE_OPTIMISTIC_DIRTY, EFFECT_RENDER, EFFECT_USER } from "./constants.js";
+import { NOT_PENDING, unwrapOverride, STATUS_UNINITIALIZED, REACTIVE_DIRTY, REACTIVE_CHECK, CONFIG_HAS_LANE, OVERRIDE_UNDEFINED, STATUS_PENDING, REACTIVE_MANUAL_WRITE, REACTIVE_OPTIMISTIC_DIRTY, EFFECT_RENDER, EFFECT_USER } from "./constants.js";
 
 import { ext, latestReadActive, currentOptimisticLane, stale } from "./core.js";
 
@@ -27,7 +27,14 @@ import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule
     const t = e.o?.De !== NOT_PENDING;
     const i = t ? unwrapOverride(e.o?.De) : e.be;
     if (typeof n === "function") n = n(i);
-    const u = !!(e.S & STATUS_UNINITIALIZED) || !e.Ue || !e.Ue(i, n);
+    const u = !!(e.S & STATUS_UNINITIALIZED) || 
+    // A dirty node's _value is stale (its queued recompute hasn't run — e.g.
+    // a latest() shadow marked by the previous landing's companion snap), so
+    // equality against it must not swallow the write. Without this, a sync
+    // push returning the shadow to that stale value was dropped, the snap
+    // recompute then committed the parent's old value, and the banner showed
+    // the previous transition's target (#3041 follow-up).
+    !!((e.ie ?? 0) & (REACTIVE_DIRTY | REACTIVE_CHECK)) || !e.Ue || !e.Ue(i, n);
     if (!u) {
         // Same-value write with an active override still entangles the current
         // action's transition — the hold must outlast all overlapping actions.
@@ -166,16 +173,31 @@ function cleanupCompletedLanes(e) {
  * read()'s value selection under a lane: return the committed `_value` for
  * optimistic/lane-assigned signals, stale-mode reads, and pending owners.
  */ function laneReadsCommitted(e, n, t) {
-    if (e.o?.De !== undefined || !!e.o?.Be || !!(n.S & STATUS_PENDING)) return true;
+    if (e.o?.De !== undefined || !!e.o?.Be || !!(n.S & STATUS_PENDING)) {
+        // The committed view hides a staged in-flight value that will promote
+        // silently (commitPendingNode never re-notifies). gatedRead records plain
+        // signals for replay at commit; async memos are excluded from it by the
+        // `_fn` check and reach here instead — a lane-assigned source whose async
+        // already settled (laneAsyncSettled keeps _optimisticLane) served its
+        // committed value to a reader that never re-ran after the landing, so a
+        // pending-gated branch stayed one value behind permanently (#3041
+        // follow-up). Record the reader under the same replay contract.
+        if (e.Pe !== NOT_PENDING) (activeTransition ?? globalQueue.k).ln.add(t);
+        return true;
+    }
     if (n === e && stale && t.o?.It !== e) {
-        // The committed view can hide a same-tick ambient write (a lane member —
-        // even just an isPending companion flip — puts the reader "under a lane"
-        // against unrelated plain writes). With no transaction the write commits
-        // at THIS flush's end with no re-delivery, so record the reader for
-        // replay at commit — the same contract gatedRead provides when a
-        // transaction is active (#2963). If a transaction forms mid-flush,
-        // initTransition carries the recording over to it.
-        if (e.Pe !== NOT_PENDING && activeTransition === null) globalQueue.k.ln.add(t);
+        // The committed view can hide a staged write (a lane member — even just
+        // an isPending companion flip — puts the reader "under a lane"). The
+        // staged value commits with no re-delivery (commitPendingNode never
+        // re-notifies), so record the reader for replay at commit — the same
+        // contract gatedRead provides (#2963). gatedRead itself only covers
+        // signal reads where the reading computed differs from the source; the
+        // owner === el memo/self read lands here instead. With a transaction
+        // active the staged value promotes silently at ITS landing, so record
+        // into the transaction (#3041 follow-up: a pending-gated branch that
+        // first read its async source during the landing flush stayed one value
+        // behind permanently); with none, into the ambient batch.
+        if (e.Pe !== NOT_PENDING) (activeTransition ?? globalQueue.k).ln.add(t);
         return true;
     }
     return false;
@@ -250,16 +272,16 @@ function trackOptimisticStore(e) {
     if (GlobalQueue.vt !== null) return;
     GlobalQueue.vt = optimisticWrite;
     GlobalQueue.fn = resolveOptimisticNodes;
-    GlobalQueue.dn = transitionBlocked;
-    GlobalQueue.En = cleanupCompletedLanes;
-    GlobalQueue.Tn = runLaneEffects;
+    GlobalQueue.En = transitionBlocked;
+    GlobalQueue.Tn = cleanupCompletedLanes;
+    GlobalQueue.dn = runLaneEffects;
     GlobalQueue.Ft = gatedRead;
     GlobalQueue.ht = laneSuspends;
     GlobalQueue.gt = laneReadsCommitted;
     GlobalQueue.je = recomputeLane;
     GlobalQueue.$e = laneAsyncPending;
     GlobalQueue.ze = laneAsyncSettled;
-    GlobalQueue.Nn = trackOptimisticStore;
+    GlobalQueue.In = trackOptimisticStore;
 }
 
 export { installOptimisticEngine };

package/dist/prod/core/scheduler.js

@@ -329,16 +329,16 @@ class GlobalQueue extends Queue {
     // once the gate holds.
     static vt=null;
     static fn=null;
-    static dn=null;
     static En=null;
     static Tn=null;
+    static dn=null;
     static Ft=null;
     static ht=null;
     static gt=null;
     static je=null;
     static $e=null;
     static ze=null;
-    static Nn=null;
+    static In=null;
     flush() {
         if (this.sn) return;
         // Fast drain: nothing in flight but plain pending commits — no dirty
@@ -383,8 +383,8 @@ class GlobalQueue extends Queue {
                                         if (this.k === e) currentBatch = this.k = createBatch();
                     // Run lane effects immediately (before stashing) - lanes with no pending async
                                         if (activeLanes.size) {
-                        GlobalQueue.Tn(EFFECT_RENDER);
-                        GlobalQueue.Tn(EFFECT_USER);
+                        GlobalQueue.dn(EFFECT_RENDER);
+                        GlobalQueue.dn(EFFECT_USER);
                     }
                     this.stashQueues(e.bt);
                     clock++;
@@ -432,9 +432,9 @@ class GlobalQueue extends Queue {
             // Check if finalization added items to the heap (from optimistic reversion)
                         scheduled = dirtyQueue.EE >= dirtyQueue.xe;
             // Run lane effects first (for ready lanes), then regular effects
-                        activeLanes.size && GlobalQueue.Tn(EFFECT_RENDER);
+                        activeLanes.size && GlobalQueue.dn(EFFECT_RENDER);
             this.run(EFFECT_RENDER);
-            activeLanes.size && GlobalQueue.Tn(EFFECT_USER);
+            activeLanes.size && GlobalQueue.dn(EFFECT_USER);
             this.run(EFFECT_USER);
             if (false) ;
             if (false && !scheduled && !activeTransition && transitions.size === 0 && activeLanes.size === 0) ;
@@ -677,7 +677,7 @@ function finalizePureQueue(e = null, t = false) {
                 if (t.cn.size) GlobalQueue.Vt(t.cn, e);
         sweepTransientStoreNodes();
         // Lanes only enter activeLanes through the engine's getOrCreateLane.
-                if (activeLanes.size) GlobalQueue.En(e);
+                if (activeLanes.size) GlobalQueue.Tn(e);
     }
 }
 
@@ -783,7 +783,7 @@ function transitionComplete(e) {
     // Override blockage lives with the engine (absent hook = "no optimistic
     // blockage"); the hook's loops over _optimisticNodes/_optimisticStores are
     // no-ops when the transition holds neither, so no pre-check is needed.
-        if (t && GlobalQueue.dn?.(e)) t = false;
+        if (t && GlobalQueue.En?.(e)) t = false;
     t && (e.an = true);
     return t;
 }

package/dist/prod/core/verdict.js

@@ -273,6 +273,13 @@ function snapCompanionsToState(e) {
 
 function getLatestValueComputed(e) {
     let t = e.o?.ge;
+    // A shadow disposed while unobserved (its gated reader unmounted at a
+    // landing) is a corpse: sync writes into it equality-swallow against its
+    // frozen _value, and a later read revives it via recompute — clearing
+    // DISPOSED and re-deriving from the committed view, so the banner showed
+    // the previous transition's target (#3041 follow-up). Treat it as absent;
+    // recreation backfills from the in-flight write below.
+        if (t && t.ie & REACTIVE_DISPOSED) t = undefined;
     if (!t) {
         const n = latestReadActive;
         setLatestReadActive(false);

package/dist/prod/store/next/optimistic.js

@@ -56,8 +56,8 @@ function installNextBlockedHalf() {
             e.clear();
         };
     }
-    const e = GlobalQueue.dn;
-    GlobalQueue.dn = t => {
+    const e = GlobalQueue.En;
+    GlobalQueue.En = t => {
         for (const e of t.cn) {
             const t = e?.[$TARGET];
             const n = t?.fam?.node;
@@ -198,7 +198,7 @@ function createOptimisticStoreNext(e, t, n) {
     // and the target for landing consumption (RUL-2).
         e.pb = null;
     (e.fam.overlaid ??= new Set).add(e);
-    GlobalQueue.Nn?.(e.fam.px ?? e.px);
+    GlobalQueue.In?.(e.fam.px ?? e.px);
 }
 
 /**

package/dist/prod/store/next/projection.js

@@ -33,81 +33,143 @@ import { wrapNext, storeSetterNext } from "./store.js";
  * loading windows, handleAsync landings, commit-through-setter) on next
  * primitives; the generic draft write-traps are reused from the legacy
  * module unchanged.
- */ function createWriteTraps(e, t) {
-    // Save/restore, never hard-reset: the draft can be driven from inside an
-    // enclosing authoritative-write scope (next-store optimistic derives), and
-    // a hard `false` would clobber it mid-derive.
-    const r = {
-        get(e, t) {
-            let o;
-            const i = projectionWriteActive;
+ */
+/**
+ * Wrap a store proxy as a projection DRAFT: every operation carries the write
+ * override (the derive is the author — its ops must not hit the §6c firewall
+ * gate, even in a continuation after an `await`/`yield` where the sync write
+ * scope has closed).
+ *
+ * FAKE TARGET, not the store proxy itself (#3060): after a proxy trap
+ * returns, the engine runs spec invariant validation against the proxy's
+ * TARGET — [[OwnPropertyKeys]] after ownKeys, [[GetOwnProperty]] after
+ * set/getOwnPropertyDescriptor/defineProperty. With the store proxy as
+ * target those checks re-enter the store's traps OUTSIDE the override
+ * bracket (the trap's finally has already run), so `Object.keys(state)` in
+ * a derive continuation fired the firewall gate and re-threw the
+ * projection's own pending NotReadyError into the derive. A dummy of
+ * matching kind (array/object, same trick as the store's own TargetShape)
+ * keeps invariant validation away from the store entirely; the traps
+ * forward to the closed-over inner proxy inside the bracket.
+ *
+ * Save/restore projectionWriteActive, never hard-reset: the draft can be
+ * driven from inside an enclosing authoritative-write scope (next-store
+ * optimistic derives), and a hard `false` would clobber it mid-derive.
+ */ function wrapDraft(e, t, r) {
+    const i = {
+        get(i, o) {
+            let n;
+            const c = projectionWriteActive;
             setWriteOverride(true);
             setProjectionWriteActive(true);
             try {
-                o = e[t];
+                n = e[o];
             } finally {
                 setWriteOverride(false);
-                setProjectionWriteActive(i);
+                setProjectionWriteActive(c);
             }
-            if (t === $TARGET) return o;
-            return typeof o === "object" && o !== null ? new Proxy(o, r) : o;
+            if (o === $TARGET) return n;
+            return typeof n === "object" && n !== null ? wrapDraft(n, t, r) : n;
         },
-        has(e, t) {
-            let r;
+        has(t, r) {
+            let i;
             const o = projectionWriteActive;
             setWriteOverride(true);
             setProjectionWriteActive(true);
             try {
-                r = t in e;
+                i = r in e;
             } finally {
                 setWriteOverride(false);
                 setProjectionWriteActive(o);
             }
-            return r;
+            return i;
+        },
+        set(i, o, n) {
+            if (t && !t()) return true;
+            const c = projectionWriteActive;
+            setWriteOverride(true);
+            setProjectionWriteActive(true);
+            try {
+                e[o] = n;
+                r?.();
+            } finally {
+                setWriteOverride(false);
+                setProjectionWriteActive(c);
+            }
+            return true;
         },
-        set(r, o, i) {
-            if (e && !e()) return true;
+        deleteProperty(i, o) {
+            if (t && !t()) return true;
             const n = projectionWriteActive;
             setWriteOverride(true);
             setProjectionWriteActive(true);
             try {
-                r[o] = i;
-                t?.();
+                delete e[o];
+                r?.();
             } finally {
                 setWriteOverride(false);
                 setProjectionWriteActive(n);
             }
             return true;
         },
-        deleteProperty(r, o) {
-            if (e && !e()) return true;
-            const i = projectionWriteActive;
+        ownKeys() {
+            const t = projectionWriteActive;
+            setWriteOverride(true);
+            setProjectionWriteActive(true);
+            try {
+                return Reflect.ownKeys(e);
+            } finally {
+                setWriteOverride(false);
+                setProjectionWriteActive(t);
+            }
+        },
+        getOwnPropertyDescriptor(t, r) {
+            let i;
+            const o = projectionWriteActive;
+            setWriteOverride(true);
+            setProjectionWriteActive(true);
+            try {
+                i = Reflect.getOwnPropertyDescriptor(e, r);
+            } finally {
+                setWriteOverride(false);
+                setProjectionWriteActive(o);
+            }
+            // The dummy target doesn't hold the key, so a non-configurable report
+            // would violate the proxy invariant. Store descriptors are already
+            // normalized configurable; enforce it for raw leaves too.
+                        if (i) i.configurable = true;
+            return i;
+        },
+        defineProperty(i, o, n) {
+            if (t && !t()) return true;
+            const c = projectionWriteActive;
             setWriteOverride(true);
             setProjectionWriteActive(true);
             try {
-                delete r[o];
-                t?.();
+                Reflect.defineProperty(e, o, n);
+                r?.();
             } finally {
                 setWriteOverride(false);
-                setProjectionWriteActive(i);
+                setProjectionWriteActive(c);
             }
             return true;
         }
     };
-    return r;
+    // Matching-kind dummy so Array.isArray(draft) answers like the store.
+        return new Proxy(Array.isArray(e) ? [] : {}, i);
 }
 
 function createProjectionNextInternal(e, t, r) {
-    const o = {
+    const i = {
         map: new WeakMap,
         node: null,
         shallow: !!r?.shallow
     };
-    const i = wrapNext(t, null, null, o);
-    if (o.shallow) {
+    const o = wrapNext(t, null, null, i);
+    if (i.shallow) {
         // Shallow projection: the root is the only wrapped level — slot values
         // serve raw, ingests sticky raw-mark (same t.s machinery as plain).
-        i[$TARGET].s = true;
+        o[$TARGET].s = true;
         markRawIngest(t);
     }
     let n;
@@ -115,13 +177,13 @@ function createProjectionNextInternal(e, t, r) {
         loadingValue: undefined
     };
     const c = computed(() => {
-        if (!o.node) o.node = getOwner();
-        runProjectionComputedNext(i, e, r?.key === undefined ? "id" : r.key);
+        if (!i.node) i.node = getOwner();
+        runProjectionComputedNext(o, e, r?.key === undefined ? "id" : r.key);
     }, n);
     c.T &= ~CONFIG_AUTO_DISPOSE;
-    o.node = c;
+    i.node = c;
     return {
-        store: i,
+        store: o,
         node: c
     };
 }
@@ -133,15 +195,15 @@ function createProjectionNext(e, t, r) {
 /** 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). */ function createStoreDerivedNext(e, t, r) {
-    const {store: o, node: i} = createProjectionNextInternal(e, t, r);
-    return [ o, e => {
+    const {store: i, node: o} = createProjectionNextInternal(e, t, r);
+    return [ i, e => {
         // Mark the projection as manually written before notifying nodes.
-        suppressComputedRecompute(i);
-        storeSetterNext(o, e);
+        suppressComputedRecompute(o);
+        storeSetterNext(i, e);
     } ];
 }
 
-function runProjectionComputedNext(e, t, r, o, i) {
+function runProjectionComputedNext(e, t, r, i, o) {
     const n = getOwner();
     let c = false;
     let s;
@@ -150,18 +212,18 @@ function runProjectionComputedNext(e, t, r, o, i) {
     // seed so draft writes cannot tear through to readers (#2988). Every commit
     // point reconciles the shadow through the normal commit path.
         const u = n.Ie ? JSON.parse(JSON.stringify(e[$TARGET][STORE_VALUE])) : null;
-    const l = new Proxy(e, createWriteTraps(() => !c || n.o?.Ee === s, i));
-    storeSetterNext(l, i => {
-        s = t(u ?? i);
+    const l = wrapDraft(e, () => !c || n.o?.Ee === s, o);
+    storeSetterNext(l, o => {
+        s = t(u ?? o);
         c = true;
         const commit = t => {
             // Shadow run: commit a detached snapshot, never the shadow itself
             // (adoption takes the value by identity — handing it the live shadow
             // would fuse the draft to the observable store).
             if (u && (t === undefined || t === u)) t = JSON.parse(JSON.stringify(u));
-            if (t === i || t === undefined) return;
+            if (t === o || t === undefined) return;
             const write = () => storeSetterNext(e, e => reconcileNextState(t, e, r, true), false);
-            o ? o(write) : write();
+            i ? i(write) : write();
         };
         const l = handleAsync(n, s, commit);
         if (!n.Ie) commit(l);

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

@@ -2,7 +2,7 @@ import type { OptimisticLane } from "./lanes.js";
 import type { Computed, Signal } from "./types.js";
 /**
  * Test-mode invariant checks for the async/transition/lane machinery.
- * Catalog and rationale: packages/solid-signals/INTERNALS-ASYNC-STATE.md.
+ * Catalog and rationale: packages/signals/INTERNALS-ASYNC-STATE.md.
  *
  * These are implementation self-consistency checks, not semantic rules: a
  * violation means the reactive system contradicted itself.

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

@@ -2,7 +2,7 @@ import type { OptimisticLane } from "./lanes.cjs";
 import type { Computed, Signal } from "./types.cjs";
 /**
  * Test-mode invariant checks for the async/transition/lane machinery.
- * Catalog and rationale: packages/solid-signals/INTERNALS-ASYNC-STATE.md.
+ * Catalog and rationale: packages/signals/INTERNALS-ASYNC-STATE.md.
  *
  * These are implementation self-consistency checks, not semantic rules: a
  * violation means the reactive system contradicted itself.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/signals",
-  "version": "2.0.0-rc.2",
+  "version": "2.0.0-rc.3",
   "description": "Solid's reactive primitives: signals, memos, effects, stores, and async-aware computations.",
   "author": "Ryan Carniato",
   "license": "MIT",
@@ -8,7 +8,7 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/solidjs/solid.git",
-    "directory": "packages/solid-signals"
+    "directory": "packages/signals"
   },
   "publishConfig": {
     "access": "public"
@@ -39,6 +39,18 @@
     },
     "./package.json": "./package.json"
   },
+  "scripts": {
+    "build": "npm-run-all -nl build:* && pnpm types",
+    "build:clean": "rimraf dist/dev dist/prod dist/node dist/dev.js dist/prod.js dist/node.cjs",
+    "build:js": "rollup -c && node ./scripts/mangle-props.mjs dist/prod dist/node.cjs && node ./scripts/check-pure.mjs dist/prod",
+    "types": "tsc -p tsconfig.build.json && node ../../scripts/sync-dual-types.mjs ./dist/types ./dist/types-cjs",
+    "test": "vitest run",
+    "test:watch": "vitest watch tests",
+    "test:gc": "node --expose-gc ./vitest.js",
+    "test:gc:watch": "node --expose-gc ./vitest.js --watch",
+    "coverage": "vitest run --coverage",
+    "bench": "vitest bench --run"
+  },
   "devDependencies": {
     "@codspeed/vitest-plugin": "^5.4.0",
     "@ianvs/prettier-plugin-sort-imports": "^4.1.1",
@@ -53,17 +65,5 @@
     "typescript": "^6.0.3",
     "vite": "^7.0.0",
     "vitest": "^4.1.6"
-  },
-  "scripts": {
-    "build": "npm-run-all -nl build:* && pnpm types",
-    "build:clean": "rimraf dist/dev dist/prod dist/node dist/dev.js dist/prod.js dist/node.cjs",
-    "build:js": "rollup -c && node ./scripts/mangle-props.mjs dist/prod dist/node.cjs && node ./scripts/check-pure.mjs dist/prod",
-    "types": "tsc -p tsconfig.build.json && node ../../scripts/sync-dual-types.mjs ./dist/types ./dist/types-cjs",
-    "test": "vitest run",
-    "test:watch": "vitest watch tests",
-    "test:gc": "node --expose-gc ./vitest.js",
-    "test:gc:watch": "node --expose-gc ./vitest.js --watch",
-    "coverage": "vitest run --coverage",
-    "bench": "vitest bench --run"
   }
-}
+}

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

@@ -1,45 +0,0 @@
-import { type Refreshable } from "../core/index.js";
-import { type NoFn, type ProjectionOptions, type Store, type StoreSetter } from "./store.js";
-/**
- * The store equivalent of `createOptimistic`. Writes inside an `action`
- * transition are tentative — they show up immediately but auto-revert (or
- * reconcile to the action's resolved value) once the transition finishes.
- *
- * Use this for optimistic UI on collection-shaped data. For single-value
- * optimistic state, prefer `createOptimistic`.
- *
- * - Plain form: `createOptimisticStore(initialValue)`.
- * - Derived form: `createOptimisticStore(fn, seed, options?)` — a projection
- *   store whose authoritative value is recomputed by `fn` and whose
- *   optimistic overlay reverts after each transition.
- *
- * `options.key` defaults to `"id"`; specify it only when your data uses a
- * different identity field (e.g. `{ key: "uuid" }` or `{ key: t => t.slug }`),
- * or `null` to merge positionally. Restating the default just adds noise.
- *
- * @example
- * ```ts
- * const [todos, setTodos] = createOptimisticStore<Todo[]>([]);
- *
- * // Mutation: optimistic add, then in-place reconcile to the saved row.
- * const addTodo = action(function* (text: string) {
- *   const tempId = crypto.randomUUID();
- *   setTodos(t => { t.push({ id: tempId, text, pending: true }); });
- *   const saved = yield api.createTodo(text);
- *   setTodos(t => {
- *     const i = t.findIndex(x => x.id === tempId);
- *     if (i >= 0) t[i] = saved;
- *   });
- * });
- *
- * // Return form: filter is the natural shape for removal.
- * const removeTodo = action(function* (id: string) {
- *   setTodos(t => t.filter(x => x.id !== id));
- *   yield api.removeTodo(id);
- * });
- * ```
- *
- * @returns `[store: Store<T>, setStore: StoreSetter<T>]`
- */
-export declare function createOptimisticStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Store<T>, set: StoreSetter<T>];
-export declare function createOptimisticStore<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>];

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

@@ -1,70 +0,0 @@
-import { type Computed, type Refreshable } from "../core/index.js";
-import { type NoFn, type ProjectionOptions, type Store } from "./store.js";
-export declare function createProjectionInternal<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T>, options?: ProjectionOptions): {
-    store: Refreshable<Store<T>>;
-    node: Computed<void | T>;
-};
-/**
- * Creates a derived (projected) store. Like `createMemo` but for stores: the
- * derive function receives a mutable draft and either mutates it in place
- * (canonical) or returns a new value. Either way the result is reconciled
- * against the previous draft by `options.key` (default `"id"`), so surviving
- * items keep their proxy identity — only added/removed items are
- * created/disposed.
- *
- * If the derive returns a different entity than the one currently held (the
- * `/users/1` → `/users/2` shape), the store swaps to it rather than merging,
- * and nothing below it is treated as surviving.
- *
- * Returns the projected store directly (no setter — reads only).
- *
- * Use this when you want the structural-sharing / per-property tracking
- * behaviour of a store on top of a derived computation. For simple read-only
- * derivations, `createMemo` is lighter.
- *
- * @param fn receives the current draft; mutate it in place or return new
- *   data. Return is convenient for filter/derive shapes where mutation is
- *   awkward.
- * @param seed the backing store value to wrap and reconcile into
- * @param options `ProjectionOptions` — `name`, `key`. `key` defaults to
- *   `"id"`; specify it only when your data uses a different identity field
- *   (e.g. `{ key: "uuid" }` or `{ key: u => u.slug }`), or `null` to merge
- *   positionally with no keyed pass.
- *
- * @example
- * ```ts
- * // Mutation form — update individual fields on the draft.
- * const summary = createProjection<{ total: number; active: number }>(
- *   draft => {
- *     draft.total = users().length;
- *     draft.active = users().filter(u => u.active).length;
- *   },
- *   { total: 0, active: 0 }
- * );
- *
- * // Return form — produce a derived collection. Reconciled by `id` so each
- * // surviving user keeps the same store identity across recomputes.
- * const activeUsers = createProjection<User[]>(
- *   () => allUsers().filter(u => u.active),
- *   []
- * );
- * ```
- *
- * @see {@link https://github.com/solidjs/x-reactivity#createprojection}
- */
-export declare function createProjection<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>>;
-/**
- * Shared projection computed body used by both `createProjection` and the derived
- * form of `createOptimisticStore`. Encapsulates the write-trap draft, `storeSetter`
- * wrapping, the `handleAsync` subscription with a setter callback, and the commit
- * path (which must always go through `storeSetter` so the `writeOnly` guard is
- * engaged during `reconcile`'s property reads).
- *
- * `wrapCommit` is invoked for every commit (sync return and each async yield) and
- * lets callers layer extra context around the write — e.g. the optimistic store
- * re-enters `setProjectionWriteActive` so reconciles target `STORE_OVERRIDE`
- * instead of `STORE_OPTIMISTIC_OVERRIDE` even when an async yield fires outside
- * the outer `setProjectionWriteActive` scope.
- */
-export declare function runProjectionComputed<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 createWriteTraps(isActive?: () => boolean, onDraftWrite?: () => void): ProxyHandler<any>;

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

@@ -1,46 +0,0 @@
-/**
- * Shared body of `reconcile()` and the projection commit. `replace` is the
- * only difference: a projection commit is a value swap, not a merge — its root
- * proxy is a cell handed out by `createProjection` that can never change
- * reference, so a derive returning a different entity is not the slot mistake
- * `reconcile()` throws on. Nothing below the root survives that swap, which is
- * the rule the keyed diff already applies at a nested slot on a key mismatch.
- *
- * @internal
- */
-export declare function reconcileState(value: any, state: any, key: any, replace: boolean): void;
-/**
- * Returns a draft-mutating function that smart-merges `value` into a store,
- * preserving fine-grained reactivity: only changed leaves trigger updates.
- *
- * With a `key` (default `"id"`), array items whose key matches between old
- * and new states keep their identity (updated in place, moves and removals
- * update the corresponding signals) — the shape for keyed server payloads.
- * Items without the key field fall back to positional matching.
- *
- * With `key: null`, matching is purely positional: index N of the new array
- * merges into index N of the old, and object properties merge recursively —
- * the classic pattern for fixed-shape data that churns in place (dashboards,
- * monitors), where no keyed diff pass is needed or wanted.
- *
- * Merging into a slot that holds a *different* entity throws — the caller
- * picked the slot, so a key mismatch there is a bug.
- *
- * @param value the next state to merge in
- * @param key property name (string) or extractor function for stable
- * identity (default `"id"`); pass `null` for positional merging
- *
- * @example
- * ```ts
- * const [todos, setTodos] = createStore<Todo[]>([]);
- *
- * async function refresh() {
- *   const fresh = await api.getTodos();
- *   setTodos(reconcile(fresh)); // diff-merge by `id`
- * }
- *
- * // fixed-shape polling data — positional merge
- * setStats(reconcile(nextStats, null));
- * ```
- */
-export declare function reconcile<T extends U, U>(value: T, key?: string | ((item: NonNullable<any>) => any) | null): (state: U) => void;