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

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

@@ -1,11 +1,33 @@
 /**
- * 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;
+
+/** 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;
@@ -19,11 +41,11 @@ function setOptHooks(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 t = e;
-    while (t && !t.d) {
-        t.d = true;
-        t = t.u;
+    let o = e;
+    while (o && !o.d) {
+        o.d = true;
+        o = o.u;
     }
 }
 
-export { devAssertNeverUserMutation, markDescendants, optHooks, ownedRaw, setOptHooks, storeNextLookup };
+export { $OWNER, devAssertNeverUserMutation, isOwned, lookupTarget, markDescendants, optHooks, setOptHooks, storeNextLookup };

package/dist/prod/store/store.js

@@ -8,7 +8,7 @@ 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.
@@ -24,13 +24,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
@@ -202,9 +198,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 +210,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 +218,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,7 +250,7 @@ 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?.o?.t) GlobalQueue.zt(o);
+    if (o?.o?.t) GlobalQueue.pn(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
@@ -263,7 +261,7 @@ s) {
                 let t = r;
                 for (;;) {
                     if (s.scope.has(t)) {
-                        GlobalQueue.zt(e);
+                        GlobalQueue.pn(e);
                         break;
                     }
                     const o = t?.[$TARGET];
@@ -302,7 +300,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);