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

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

@@ -1,20 +1,51 @@
 /**
- * Ownership (first cut, decision 2026-08-16d): one WeakSet of store-owned
- * backings serving both the production identity-skip guard and the false
- * 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.
  */
-const ownedRaw = new WeakSet;
+const $OWNER = Symbol(0);
 
-/** raw → target. The only raw-keyed lookup; boundary mechanism (O8). */ const storeNextLookup = new WeakMap;
+/** raw → target for UNOWNED backings (user-ingested, adopted); owned
+ * backings resolve through their `$OWNER` stamp. Boundary mechanism (O8). */ const storeNextLookup = new WeakMap;
 
-function devAssertNeverUserMutation(o) {
+/** A backing the store allocated and may mutate in place. */ function isOwned(e) {
+    return e[$OWNER] !== undefined;
+}
+
+/** 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. */ function lookupTarget(e, o) {
+    const t = e[$OWNER];
+    return t !== undefined && t.fam === o ? t : (o?.map ?? storeNextLookup).get(e);
+}
+
+function devAssertNeverUserMutation(e) {
     return;
 }
 
 let optHooks = null;
 
-function setOptHooks(o) {
-    optHooks = o;
+function setOptHooks(e) {
+    optHooks = e;
+}
+
+/** Sticky descendants flag walk (§6d): reconcile's keyed pruning descends
+ * only where subscriptions exist at/below. Nodes AND patches count. */ function markDescendants(e) {
+    let o = e;
+    while (o && !o.d) {
+        o.d = true;
+        o = o.u;
+    }
 }
 
-export { devAssertNeverUserMutation, optHooks, ownedRaw, setOptHooks, storeNextLookup };
+export { $OWNER, devAssertNeverUserMutation, isOwned, lookupTarget, markDescendants, optHooks, setOptHooks, storeNextLookup };

package/dist/prod/store/store.js

@@ -8,14 +8,20 @@ import "../core/verdict.js";
 
 import "../core/effect.js";
 
-import { storeNextLookup } from "./next/target.js";
+import { $OWNER, lookupTarget as lookupTarget$1 } from "./next/target.js";
 
 /**
  * Brand symbols used internally by the store proxy / projection plumbing.
  * Cross-package wiring; not part of the user-facing API.
  *
  * @internal
- */ const $TRACK = Symbol(0), $TARGET = Symbol(0), $PROXY = Symbol(0), // Node-map slot carrying a record-level `affects()` mark: any read through
+ */ const $TRACK = Symbol(0), $TARGET = Symbol(0), $PROXY = Symbol(0), 
+// The view record behind a merge()/omit() proxy (a `MergeView` or an
+// `OmitView`, utils.ts); a store answers `undefined` on its symbol fast
+// path. One read classifies any `$PROXY`-marked object — store, view, or
+// foreign — where asking `$TARGET` first and then each view kind was two
+// to four trap hops (see `viewOf`).
+$RECORD = Symbol(0), // Node-map slot carrying a record-level `affects()` mark: any read through
 // the record witnesses it into the active isPending() probe.
 $AFFECTS = Symbol(0);
 
@@ -24,13 +30,9 @@ $AFFECTS = Symbol(0);
 const STORE_VALUE = "v", STORE_NODE = "n", STORE_HAS = "h";
 
 function lookupTarget(e, t) {
-    // Family maps (projections/optimistic) map raw -> target; the global next
-    // lookup maps raw -> target too. Proxies resolve through $TARGET directly.
-    if (t !== undefined) {
-        const o = t.get(e);
-        if (o !== undefined) return o[$TARGET] ?? o;
-    }
-    return storeNextLookup.get(e);
+    // Family registrations (projections/optimistic) first, then the global
+    // next lookup. Proxies resolve through $TARGET directly.
+    return (t ? lookupTarget$1(e, t) : undefined) ?? lookupTarget$1(e, null);
 }
 
 // Values marked raw never acquire a proxy identity: wrap() serves them as-is
@@ -138,7 +140,7 @@ function ownEnumerableKeys(e) {
  */ function inheritAffectsMarks(e, t, o) {
     // A live scope exists, so affects.ts already installed the mark engine.
     for (const [r, s] of affectsScopes) {
-        if (r.t && s.scope.has(t) && (s.key === undefined || s.key === o)) {
+        if (r.o?.t && s.scope.has(t) && (s.key === undefined || s.key === o)) {
             GlobalQueue.M(e);
             s.inherited.push(e);
         }
@@ -202,9 +204,9 @@ s) {
         // scope must mark them like any property node.
                 if (f.k) o.push(f.k);
         if (f.dk) o.push(f.dk);
-        // Carry the effective lookup into untouched descendants (family maps for
-        // projections/optimistic stores; the global next lookup otherwise).
-                r = f.fam?.map ?? r ?? storeNextLookup;
+        // Carry the effective family into untouched descendants (projections/
+        // optimistic stores register children under their family).
+                r = f.fam ?? r;
     }
     // Overlays are gone (next has no layer): raw enumeration; the optimistic
     // view composition above already folded armed-node membership/values in.
@@ -214,6 +216,7 @@ s) {
         }
         const e = Object.getOwnPropertySymbols(n);
         for (let f = 0, c = e.length; f < c; f++) {
+            if (e[f] === $OWNER) continue;
             const c = Object.getOwnPropertyDescriptor(n, e[f]);
             if (!c || c.get) continue;
             walkAffectsScope(c.value, t, o, r, s);
@@ -221,6 +224,7 @@ s) {
     } else {
         const e = Reflect.ownKeys(n);
         for (let f = 0, c = e.length; f < c; f++) {
+            if (e[f] === $OWNER) continue;
             const c = Object.getOwnPropertyDescriptor(n, e[f]);
             if (!c || c.get) continue;
             walkAffectsScope(c.value, t, o, r, s);
@@ -252,18 +256,18 @@ s) {
     // Callers guard on `pendingCheckActive`, which only flips inside
     // isPending() — the verdict layer is loaded and its hook installed.
     const o = e[STORE_NODE]?.[$AFFECTS];
-    if (o?.t) GlobalQueue.Lt(o);
+    if (o?.o?.t) GlobalQueue.Et(o);
     if (affectsScopes.size) {
         // Chained backings (§7b): a wrapper's STORE_VALUE can be another store's
         // proxy — marks cover by identity of the BASE raw, so resolve the chain
         // and check every identity along it.
         let r = e[STORE_VALUE];
         for (const [e, s] of affectsScopes) {
-            if (e !== o && e.t && (s.key === undefined || s.key === t)) {
+            if (e !== o && e.o?.t && (s.key === undefined || s.key === t)) {
                 let t = r;
                 for (;;) {
                     if (s.scope.has(t)) {
-                        GlobalQueue.Lt(e);
+                        GlobalQueue.Et(e);
                         break;
                     }
                     const o = t?.[$TARGET];
@@ -292,7 +296,7 @@ s) {
         const t = affectsScopes.get(e);
         if (!t) return;
         affectsScopes.delete(e);
-        for (let e = 0; e < t.inherited.length; e++) GlobalQueue.h(t.inherited[e]);
+        for (let e = 0; e < t.inherited.length; e++) GlobalQueue.N(t.inherited[e]);
     };
     if (t === undefined) {
         const t = nextAffectsNodeResolver(e, $AFFECTS);
@@ -302,7 +306,7 @@ s) {
             inherited: []
         });
         const r = [ t ];
-        walkAffectsScope(e[$PROXY], o, r, e.fam?.map, new Set);
+        walkAffectsScope(e[$PROXY], o, r, e.fam, new Set);
         return r;
     }
     const o = e.n?.[t] ?? nextAffectsNodeResolver(e, t);
@@ -322,4 +326,4 @@ s) {
     return [ o ];
 }
 
-export { $AFFECTS, $PROXY, $TARGET, $TRACK, STORE_HAS, STORE_NODE, STORE_VALUE, affectsScopesLive, getStoreAffectsNodes, getWriteOverride, inheritAffectsMarks, isRawValue, isWrappable, markRawIngest, markRawOne, nextAffectsNodeResolver, nextOptimisticViewResolver, ownEnumerableKeys, rawValuesUsed, setNextAffectsNodeResolver, setNextOptimisticViewResolver, setWriteOverride, witnessAffectsMark };
+export { $AFFECTS, $PROXY, $RECORD, $TARGET, $TRACK, STORE_HAS, STORE_NODE, STORE_VALUE, affectsScopesLive, getStoreAffectsNodes, getWriteOverride, inheritAffectsMarks, isRawValue, isWrappable, markRawIngest, markRawOne, nextAffectsNodeResolver, nextOptimisticViewResolver, ownEnumerableKeys, rawValuesUsed, setNextAffectsNodeResolver, setNextOptimisticViewResolver, setWriteOverride, witnessAffectsMark };