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

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

@@ -1,5 +1,6 @@
+import { type Refreshable } from "../../core/index.cjs";
 import { type Transition } from "../../core/scheduler.cjs";
-import { type NoFn, type ProjectionOptions, type Store, type StoreSetter } from "../store.cjs";
+import { type NoFn, type ProjectionOptions, type Store, type StoreOptions, type StoreSetter } from "../store.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 —
@@ -8,7 +9,8 @@ import type { StoreNextTarget } from "./target.cjs";
  * 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>];
+export declare function createOptimisticStoreNext<T extends object = {}>(initialValue: NoFn<T> | Store<NoFn<T>>, options?: StoreOptions): [get: Store<T>, set: StoreSetter<T>];
+export declare function createOptimisticStoreNext<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Refreshable<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

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

@@ -1,17 +1,10 @@
-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;
+/** Setter-channel row ops (the fold site calls this for array targets with
+ * ops consumers): structural mutation through the setter — push/splice/index
 /** 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. */
+ * SameValueZero, matching the adoption window's Map-based matcher — NaN keys
+ * are equal to themselves, so aligned NaN rows stay aligned in the prefix
+ * walk instead of forever misaligning. */
 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,20 +1,14 @@
 import type { Signal } from "../../core/types.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;
+import { type StoreNextFamily, type StoreNextTarget } from "./target.cjs";
 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 getNode(target: StoreNextTarget, key: PropertyKey, current: any, accKnown?: -1 | 0 | 1): 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;
-/** 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
@@ -90,7 +84,7 @@ export type SetStoreNextFunction<T> = (fn: (draft: T) => T | void) => void;
  * 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>];
+export declare function createStoreNext<T extends Record<PropertyKey, any>>(initialValue: 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. */

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

@@ -12,7 +12,7 @@
  * entry per read-through object; zero layer slots; nodes, has-nodes, and the
  * key-set node are lazy, materialized only by subscription.
  */
-import type { Computed, Owner, Signal } from "../../core/types.cjs";
+import type { Computed, Signal } from "../../core/types.cjs";
 /** Projection family (§7b): children wrap into the family's own map (writes
  * land in the projection, never the source family), and every node created
  * under the family carries the projection computed as its firewall. */
@@ -34,6 +34,16 @@ export interface StoreNextFamily {
      * landing under an active override. Dead members prune lazily at each
      * landing (retainingTransition). */
     rt?: Set<any>;
+    /** Flight-owned transaction (#3146): declared when a truth-flight
+     * registers (the ask's transaction — created by the flight's own pending
+     * throw when none was ambient, the causing write's when one was), renewed
+     * per settle event once the previous reveal committed. Bare optimistic
+     * writes and landings route into it BY DECLARATION; the transitionBlocked
+     * store-half checks it for ownership instead of reconstructing it from
+     * `_optimisticStores` membership. null = no flight declared one (sync
+     * derive, or a loading-window flight — the loading rail is
+     * transaction-invisible, #2933). */
+    ft?: any;
     /** Normalized row-key fn (same resolution as the projection channels:
      * `options.key`, "id" default, null = unkeyed). The staged-landing walk
      * reads it: key-matched rows keep their proxy identity across a fold. */
@@ -43,40 +53,6 @@ export interface StoreNextFamily {
     node: Computed<any> | null;
     shallow?: boolean;
 }
-/** Write-side patch-channel state (stage 2), grouped off the target's named
- * fields — see the shape rule on `StoreNextTarget.pc`. One literal shape,
- * allocated by `pcOf` on first use. */
-export interface PatchChannel {
-    /** Slot-patch hooks for shallow arrays — the reconcile walk emits
-     * (i, next, prev) for key-aligned value-replaced slots through the patch
-     * apply queue (records are raw, no per-record targets exist).
-     * MULTI-CONSUMER (external audit): one array can drive several lists. */
-    sp: {
-        fn: (index: number, next: any, prev: any) => void;
-        owner: Owner | null;
-    }[] | null;
-    /** Patch-channel consumers (next/patch.ts): per-record compiled patch
-     * entries, multi-consumer. null when unpatched (the common case). */
-    p: object[] | null;
-    /** Same-batch coalescing stamp (re-audit 2/3): the container array this
-     * channel last pushed a non-forced SELF entry into, plus that entry. A
-     * later same-batch emission UPDATES the queued entry's `next` in place
-     * (latest state wins — adoption REPLACES the captured object, so dropping
-     * the later emission would apply stale state) while `prev` stays the
-     * batch's earliest. The drain clears both stamps so a quiet record
-     * retains nothing from its last batch. */
-    qa: unknown;
-    qe: unknown;
-    /** Row-ops consumers (next/patch.ts, PR-B): structural list ops —
-     * (nextRows, { prefix, sources, removed }) at apply timing. */
-    ro: object[] | null;
-    /** Keys written through the traps since the last fold commit. Bounds the
-     * setter notify/hold-check to O(written) instead of O(subscribed nodes) —
-     * a record with thousands of per-key subscriptions (selection maps) would
-     * otherwise pay a full node scan on every write. null = no trap writes
-     * this batch (bulk paths fall back to the full scan). */
-    wk: Set<PropertyKey> | null;
-}
 export interface StoreNextTarget {
     /** Committed backing: source object (shared) or owned clone. */
     v: Record<PropertyKey, any>;
@@ -92,15 +68,19 @@ export interface StoreNextTarget {
     h: Record<PropertyKey, Signal<boolean>> | null;
     /** Lazy key-set node: membership/iteration/$TRACK subscriptions (§6). */
     k: Signal<number> | null;
-    /** Patch-channel extension (lazily allocated on first use): groups the
-     * write-side stage-2 fields so they never widen the TARGET's own named
-     * field count. LOAD-BEARING SHAPE RULE: array proxy targets carry their
-     * fields as named properties on a real array, and V8 normalizes an array
-     * to dictionary properties as the named count grows (empirically at
-     * counts ≡ 0 mod 3 from 18 up on V8 13.x) — every trap field read then
-     * becomes a hash lookup (~15% uibench, tree suites worst). New
-     * patch-channel state MUST go inside this object, not on the target. */
-    pc: PatchChannel | null;
+    /** Keys written through the traps since the last fold commit. Bounds the
+     * setter notify/hold-check to O(written) instead of O(subscribed nodes) —
+     * a record with thousands of per-key subscriptions (selection maps) would
+     * otherwise pay a full node scan on every write. null = no trap writes
+     * this batch (bulk paths fall back to the full scan); WK_ALL = bound
+     * unusable (array length write). LOAD-BEARING SHAPE RULE: array proxy
+     * targets carry their fields as named properties on a real array, and V8
+     * normalizes an array to dictionary properties as the named count grows
+     * (empirically at counts ≡ 0 mod 3 from 18 up on V8 13.x) — every trap
+     * field read then becomes a hash lookup (~15% uibench, tree suites
+     * worst). Future write-side state MUST ride an extension object, not new
+     * named fields. */
+    wk: Set<PropertyKey> | null;
     /** Lazy deep-witness node: `deep()` subscribes ONE node per record instead
      * of one per path; write paths bump it only when it exists. Separate from
      * `k` so $TRACK/mapArray never rerun on leaf value changes (R9). */
@@ -120,8 +100,12 @@ export interface StoreNextTarget {
     /** Accessor scan performed (scan-once on first trap read; adopted data is
      * not rescanned — legacy-parity behavior). */
     sc: boolean;
-    /** Backing was swapped by adoption this batch (fold diff-notifies it). */
-    adopted: boolean;
+    /** Adoption diff base, non-null when the backing was swapped by adoption
+     * this batch: the view the nodes were LAST TOLD — the pre-batch committed
+     * backing, or the draft's pending backing when a draft preceded the
+     * adoption (its setter-exit notifications already moved the nodes, #3296).
+     * The deferred fold diffs incoming against this, never against committed. */
+    ab: Record<PropertyKey, any> | null;
     /** Pending backing is a prototype-chain OVERLAY of the committed backing
      * (`Object.create(v)` — own keys are this batch's writes, everything else
      * reads through). O(written) per flush instead of O(container) clones

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

@@ -1,7 +1,7 @@
 import { type Signal } from "../core/index.cjs";
 import type { Refreshable } from "../core/index.cjs";
-/** A read-only view of a store's value as seen by consumers. Mutate it via the paired `StoreSetter`. */
-export type Store<T> = Readonly<T>;
+/** A reactive view of a store's value. Update it through the paired `StoreSetter`. */
+export type Store<T> = T;
 /**
  * A store setter. The callback receives a writable **draft** of the store.
  *
@@ -14,25 +14,30 @@ export type Store<T> = Readonly<T>;
  *
  * The setter does **not** perform keyed reconciliation. If you need surviving
  * items to keep their store identity across full-array replacement, use the
- * projection form — `createStore(fn, seed, { key })` or `createProjection` —
- * whose derive function reconciles its return by `options.key`.
+ * projection form — `createStore(fn, seed, { key })` or
+ * `createProjection(fn, seed, { key })` — whose derive function reconciles
+ * its return by `options.key`.
  */
 export type StoreSetter<T> = (fn: (state: T) => T | void) => void;
-/** Tuple returned by the plain `createStore(initialValue)` form. */
+/** Tuple returned by the plain `createStore(initialValue, options?)` form. */
 export type StoreReturn<T> = [get: Store<T>, set: StoreSetter<T>];
 /** Tuple returned by the derived `createStore(fn, seed, options?)` form. */
 export type ProjectionStoreReturn<T> = [get: Refreshable<Store<T>>, set: StoreSetter<T>];
-/** Base options for store primitives. */
+/** Options shared by all store primitives. */
 export interface StoreOptions {
     /** Debug name (dev mode only) */
     name?: string;
+    /** Single-layer store: root keys reactive, values raw records replaced by reference */
+    shallow?: boolean;
 }
-/** Options for derived/projected stores created with `createStore(fn)`, `createProjection`, or `createOptimisticStore(fn)`. */
+/**
+ * Options for derived/projected stores created with
+ * `createStore(fn, seed, options?)`, `createProjection(fn, seed, options?)`,
+ * or `createOptimisticStore(fn, seed, options?)`.
+ */
 export interface ProjectionOptions extends StoreOptions {
     /** Key property name or function for reconciliation identity; `null` merges positionally */
     key?: string | ((item: NonNullable<any>) => any) | null;
-    /** Single-layer store: root keys reactive, values raw records replaced by reference */
-    shallow?: boolean;
     /**
      * Treat the seed as commit #0: the store is born committed with the seed's
      * contents, shown until the derive's first real answer lands. While that

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/signals",
-  "version": "2.0.0-rc.5",
+  "version": "2.0.0-rc.7",
   "description": "Solid's reactive primitives: signals, memos, effects, stores, and async-aware computations.",
   "author": "Ryan Carniato",
   "license": "MIT",
@@ -34,6 +34,7 @@
       },
       "require": {
         "types": "./dist/types-cjs/index.d.cts",
+        "development": "./dist/node.dev.cjs",
         "default": "./dist/node.cjs"
       }
     },
@@ -41,7 +42,7 @@
   },
   "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:clean": "rimraf dist/dev dist/prod dist/node dist/dev.js dist/prod.js dist/node.cjs dist/node.dev.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",

package/dist/prod/store/next/patch-hooks.js

@@ -1,13 +0,0 @@
-let patchHooks = null;
-
-let rowHooks = null;
-
-function installPatchHooks(o) {
-    patchHooks = o;
-}
-
-function installRowHooks(o) {
-    rowHooks = o;
-}
-
-export { installPatchHooks, installRowHooks, patchHooks, rowHooks };