@solidjs/signals 2.0.0-rc.6 → 2.0.0-rc.8

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

@@ -1,26 +1,25 @@
 import type { Signal } from "../../core/types.js";
-import { type StoreNextFamily, type StoreNextTarget, type PatchChannel } from "./target.js";
-/** Lazily allocate the patch-channel extension (one literal shape). */
-export declare function pcOf(t: StoreNextTarget): PatchChannel;
+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 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
  * the clone path. Consumers that need a complete container (reconcile's
  * diff walks, drafts escaping into other storage) call this. */
 export declare function materializePB(target: StoreNextTarget): void;
+/** Resolve the held committed view (#3074): answers the masked old backing
+ * while the hold is live, and lazily clears a hold whose transition has
+ * committed (transitions merge — resolve through currentTransition, same as
+ * foldHeld's node stamps). */
+export declare function heldMaskView(t: StoreNextTarget): Record<PropertyKey, any> | null;
 /**
  * Adoption (2026-08-16c): the incoming object becomes the committed backing
  * IMMEDIATELY — reconcile is eagerly visible to every reader (shipped
@@ -90,7 +89,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/store/next/target.d.ts

@@ -12,7 +12,7 @@
  * entry per read-through object; zero layer slots; nodes, has-nodes, and the
  * key-set node are lazy, materialized only by subscription.
  */
-import type { Computed, Owner, Signal } from "../../core/types.js";
+import type { Computed, Signal } from "../../core/types.js";
 /** Projection family (§7b): children wrap into the family's own map (writes
  * land in the projection, never the source family), and every node created
  * under the family carries the projection computed as its firewall. */
@@ -53,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>;
@@ -102,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). */
@@ -127,16 +97,30 @@ export interface StoreNextTarget {
      * this target (first-read scan, defineProperty, or clone scan). Gates the
      * fold diff's descriptor-safe path and the get trap's descriptor path. */
     a: boolean;
-    /** 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;
+    /** Accessor scan grade: 0 = not yet scanned (adoption resets — adopted data
+     * is not rescanned until the next draft), 1 = scanned, 2 = scanned and
+     * PLAIN DATA — `Object.prototype` with every own key an enumerable data
+     * property. Grade 2 unlocks the spread clone (cloneRaw), bare-assignment
+     * overlay writes and flatten (#3360); a non-plain defineProperty through
+     * the draft downgrades it to 1. */
+    sc: 0 | 1 | 2;
+    /** Own-key count: exact at scan, then bumped by set-trap writes of keys new
+     * to the container (never decremented — an estimate for the overlay/clone
+     * choice only, #3360). */
+    kc: number;
+    /** 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
      * (#3044); commit flattens own keys onto an owned committed backing in
-     * place. Only plain-data non-array non-family containers qualify;
+     * place. Plain-data non-array containers qualify, including projection
+     * and derived-store families (#3352); optimistic families, chained
+     * backings, and accessor containers keep the descriptor clone.
      * `materializePB` downgrades to the clone path when a consumer needs a
      * real container (reconcile, draft escape). */
     ovl: boolean;
@@ -160,13 +144,30 @@ export interface StoreNextTarget {
     ht: any;
 }
 /**
- * Ownership (first cut, decision 2026-08-16d): one WeakSet of store-owned
- * backings serving both the production identity-skip guard and the __TEST__
- * no-mutation oracle.
+ * Ownership stamp (#3360): every backing the store ALLOCATES (CoW clones,
+ * privatized committed backings) carries its owning target under this
+ * enumerable symbol. One property write replaces the two weak-collection
+ * registrations (ownership set + raw→target map) a fresh object used to pay
+ * per draft — V8's identity-hash + ephemeron cost dominated the one-key
+ * write floor. Enumerable so a spread copy (the plain-data clone path) stays
+ * on the fast path and carries the stamp along.
+ *
+ * Owned backings are never user-reachable (`snapshot` copies them, the traps
+ * hide the key), so every raw key walk in the store must skip `$OWNER`, and
+ * ownership is answered by `isOwned` — a user object never carries it.
+ * Overlay drafts (`Object.create(v)` over an owned `v`) inherit the stamp.
  */
-export declare const ownedRaw: WeakSet<object>;
-/** raw → target. The only raw-keyed lookup; boundary mechanism (O8). */
+export declare const $OWNER: unique symbol;
+/** raw → target for UNOWNED backings (user-ingested, adopted); owned
+ * backings resolve through their `$OWNER` stamp. Boundary mechanism (O8). */
 export declare const storeNextLookup: WeakMap<object, StoreNextTarget>;
+/** A backing the store allocated and may mutate in place. */
+export declare function isOwned(raw: object): boolean;
+/** raw → target within a family (`null` = plain stores / the global map).
+ * The stamp answers for backings owned by a target OF THAT FAMILY; anything
+ * else (user objects, adoptees, another family's backings the family
+ * re-registered for its own wrapper) resolves through the family's map. */
+export declare function lookupTarget(raw: object, fam: StoreNextFamily | null): StoreNextTarget | undefined;
 /** __TEST__ oracle: every object ingested from a user (never mutate). */
 export declare const ingestedRaw: WeakSet<object> | null;
 export declare function devAssertNeverUserMutation(target: object): void;

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

@@ -1,7 +1,7 @@
 import { type Signal } from "../core/index.js";
 import type { Refreshable } from "../core/index.js";
-/** 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/dist/types/store/utils.d.ts

@@ -21,6 +21,13 @@ type _Merge<T extends unknown[], Curr = {}> = T extends [
     ...infer Rest
 ] ? _Merge<Rest, Override<Curr, Next>> : T extends [...infer Rest, infer Next | (() => infer Next)] ? Override<_Merge<Rest, Curr>, Next> : T extends [] ? Curr : T extends (infer I | (() => infer I))[] ? OverrideSpread<Curr, I> : Curr;
 export type Merge<T extends unknown[]> = Simplify<_Merge<T>>;
+/** @internal The flattened sources behind a `merge()` PROXY, or undefined.
+ * Only the proxy form: its writes are no-ops, so the sources are the whole
+ * truth. merge()'s plain-object form also records `$SOURCES` (so nested
+ * merges flatten), but it is a real object callers may mutate afterwards
+ * (html's tagged templates assign props after spreading) — those own writes
+ * live on the object, not in the sources, so it must be read directly. */
+export declare function mergeSources(o: any): any[] | undefined;
 /**
  * Merges multiple props-like objects into a single proxy that *preserves
  * reactivity*. Reads are forwarded to the right-most source that defines the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/signals",
-  "version": "2.0.0-rc.6",
+  "version": "2.0.0-rc.8",
   "description": "Solid's reactive primitives: signals, memos, effects, stores, and async-aware computations.",
   "author": "Ryan Carniato",
   "license": "MIT",
@@ -13,12 +13,15 @@
   "publishConfig": {
     "access": "public"
   },
-  "main": "./dist/node.cjs",
+  "main": "./dist/prod/index.js",
   "module": "./dist/prod/index.js",
   "unpkg": "./dist/prod/index.js",
   "jsdelivr": "./dist/prod/index.js",
   "types": "./dist/types/index.d.ts",
   "type": "module",
+  "engines": {
+    "node": ">=22.12.0"
+  },
   "sideEffects": false,
   "files": [
     "dist",
@@ -26,24 +29,26 @@
   ],
   "exports": {
     ".": {
-      "import": {
-        "types": "./dist/types/index.d.ts",
-        "test": "./dist/dev.js",
-        "development": "./dist/dev.js",
-        "default": "./dist/prod/index.js"
-      },
-      "require": {
-        "types": "./dist/types-cjs/index.d.cts",
-        "default": "./dist/node.cjs"
-      }
+      "types": "./dist/types/index.d.ts",
+      "test": "./dist/dev.js",
+      "development": "./dist/dev.js",
+      "observe": "./dist/observe/index.js",
+      "default": "./dist/prod/index.js"
+    },
+    "./attribution": {
+      "types": "./dist/types/attribution.d.ts",
+      "test": "./dist/dev.attribution.js",
+      "development": "./dist/dev.attribution.js",
+      "observe": "./dist/observe/attribution.js",
+      "default": "./dist/prod/attribution.js"
     },
     "./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",
+    "build:clean": "rimraf dist/dev dist/prod dist/observe dist/*.js",
+    "build:js": "rollup -c && node ./scripts/mangle-props.mjs dist/prod dist/observe && node ./scripts/check-pure.mjs dist/prod && node ./scripts/check-pure.mjs dist/observe",
+    "types": "tsc -p tsconfig.build.json",
     "test": "vitest run",
     "test:watch": "vitest watch tests",
     "test:gc": "node --expose-gc ./vitest.js",
@@ -66,4 +71,4 @@
     "vite": "^7.0.0",
     "vitest": "^4.1.6"
   }
-}
+}