@solidjs/signals 2.0.0-rc.14 → 2.0.0-rc.16

package/dist/prod/store/affects.js

@@ -1,10 +1,10 @@
-import { GlobalQueue } from "../core/scheduler.js";
+import { GlobalQueue, releaseMarksHook } from "../core/scheduler.js";
 
-import { installAffectsHooks, getNode, optHooks } from "./store.js";
+import { optHooks, installAffectsHooks } from "./hooks.js";
 
 import { lookupTarget, $OWNER } from "./target.js";
 
-import { isWrappable, $TARGET } from "./types.js";
+import { $TARGET } from "./types.js";
 
 /**
  * Store — the store half of `affects()` (plan sec. 29, plan sec. 37; A24 (4), #2882,
@@ -23,113 +23,120 @@ import { isWrappable, $TARGET } from "./types.js";
  * the verdict. A mark declared on a draft (inside a setter) or over an
  * optimistic family walks the view the writer sees.
  *
- * Installed by `store/index.ts`: a program with stores carries it; one
- * without pays nothing (affects.ts asks `GlobalQueue._storeMarks`).
+ * Imported by `affects()`, which installs it on its first store target
+ * (#3891, after #3912): a program with stores that never declares a mark
+ * carries none of it. It never imports store.ts — the engine's top level —
+ * so a program declaring marks without stores carries this module alone:
+ * the store's nodes and its wrappability test come through `GlobalQueue`
+ * (`_storeNode`, `_storeWrappable`), and node birth and the untracked traps
+ * reach back through `affectsHooks` (hooks.ts).
  */
 /** The keyless mark's carrier key: a leaf of the record no read serves. */ const $AFFECTS = Symbol(0);
 
 const scopes = new Map;
 
+function scopeOf(e, o) {
+    let n = scopes.get(e);
+    if (n === undefined) scopes.set(e, n = {
+        eo: new Set,
+        oo: [],
+        ze: o
+    });
+    return n;
+}
+
 /** The nodes an `affects(store[, key])` declaration marks (affects.ts
- * registers each). */ function storeMarks(e, n) {
-    if (n === undefined) {
-        const n = getNode(e, $AFFECTS);
-        let o = scopes.get(n);
-        if (o === undefined) scopes.set(n, o = {
-            scope: new Set,
-            inherited: []
-        });
-        const t = [ n ];
-        walk(e.px, o, t, e.fam, new Set);
-        return t;
+ * registers each). */ function storeMarks(e, o) {
+    const n = GlobalQueue.no(e, o === undefined ? $AFFECTS : o);
+    const t = scopeOf(n, o);
+    if (o === undefined) {
+        const o = [ n ];
+        walk(e.px, t, o, e.fam, new Set);
+        return o;
     }
-    const o = e.n?.[n] ?? getNode(e, n);
-    let t = scopes.get(o);
-    if (t === undefined) scopes.set(o, t = {
-        scope: new Set,
-        inherited: [],
-        key: n
-    });
-    t.scope.add(e.v);
-    if (e.pb !== null) t.scope.add(e.pb);
-    return [ o ];
+    t.eo.add(e.v);
+    if (e.pb !== null) t.eo.add(e.pb);
+    return [ n ];
 }
 
 /** The identities reachable from `value` into the scope (the draft's and
  * the committed backing both, when a draft is open; an optimistic family's
  * view), every live node under each record into `found`. Untracked by
- * construction: raws, never traps. */ function walk(e, n, o, t, s) {
-    if (!isWrappable(e)) return;
+ * construction: raws, never traps. */ function walk(e, o, n, t, s) {
+    if (!GlobalQueue.so(e)) return;
     const f = e[$TARGET] ?? lookupTarget(e, t);
-    let i = f !== undefined ? f.pb ?? f.v : e;
-    if (s.has(i)) return;
-    s.add(i);
-    n.scope.add(i);
+    let r = f !== undefined ? f.pb ?? f.v : e;
+    if (s.has(r)) return;
+    s.add(r);
+    o.eo.add(r);
     if (f !== undefined) {
-        if (f.pb !== null) n.scope.add(f.v);
+        if (f.pb !== null) o.eo.add(f.v);
         // The writer's view: the tick's own unflushed guesses are in motion too.
-                if (f.fam?.opt === true) i = optHooks.view(f, i, true);
+                if (f.fam?.opt === true) r = optHooks.view(f, r, true);
         const e = f.n;
-        if (e !== null) for (const n of Reflect.ownKeys(e)) 
+        if (e !== null) for (const o of Reflect.ownKeys(e)) 
         // Another mark's carrier is its own channel: counting it here would
         // extend that scope's lifetime to this declaration's.
-        if (n !== $AFFECTS) o.push(e[n]);
+        if (o !== $AFFECTS) n.push(e[o]);
         const s = f.h;
-        if (s !== null) for (const e of Reflect.ownKeys(s)) o.push(s[e]);
-        if (f.k !== null) o.push(f.k);
-        if (f.dk !== null) o.push(f.dk);
+        if (s !== null) for (const e of Reflect.ownKeys(s)) n.push(s[e]);
+        if (f.k !== null) n.push(f.k);
+        if (f.dk !== null) n.push(f.dk);
         t = f.fam ?? t;
     }
-    for (const e of Reflect.ownKeys(i)) {
-        if (e === $OWNER) continue;
-        const f = Object.getOwnPropertyDescriptor(i, e);
-        if (f === undefined || f.get !== undefined) continue;
-        walk(f.value, n, o, t, s);
+    for (const e of Reflect.ownKeys(r)) if (e !== $OWNER) {
+        const f = Object.getOwnPropertyDescriptor(r, e);
+        if (f.get === undefined) walk(f.value, o, n, t, s);
     }
 }
 
 /** A live scope covering `t`'s identity (keyed: for `key`). Chained
  * backings (§7b): a view's backing is another store's proxy — marks cover
- * the BASE raw, so every identity along the chain is checked. */ function covering(e, n, o) {
+ * the BASE raw, so every identity along the chain is checked. */ function covering(e, o, n) {
     for (const [t, s] of scopes) {
-        if (t === o || s.key !== undefined && s.key !== n) continue;
-        for (let n = e.v; ;) {
-            if (s.scope.has(n)) return t;
-            const e = n?.[$TARGET];
+        if (t === n || s.ze !== undefined && s.ze !== o) continue;
+        for (let o = e.v; ;) {
+            if (s.eo.has(o)) return t;
+            const e = o?.[$TARGET];
             if (e === undefined) break;
-            const o = e.pb ?? e.v;
-            if (o === n) break;
-            n = o;
+            const n = e.pb ?? e.v;
+            if (n === o) break;
+            o = n;
         }
     }
     return null;
 }
 
-installAffectsHooks({
+/** The store's side: node birth and the untracked traps call it (store.ts,
+ * through `affectsHooks`) — with no live mark too: an empty scope map is
+ * no work. */ const hooks = {
     // A node born on a record a live mark covers inherits it (released with
     // the carrier's last registration).
-    born(e, n, o) {
-        if (o === $AFFECTS) return;
-        const t = covering(e, o, n);
-        if (t === null) return;
-        GlobalQueue.h(n);
-        scopes.get(t).inherited.push(n);
+    fo(e, o, n) {
+        if (scopes.size === 0 || n === $AFFECTS) return;
+        const t = covering(e, n, o);
+        if (!t) return;
+        GlobalQueue.N(o);
+        scopes.get(t).oo.push(o);
     },
     // An untracked probe (`isPending(() => s.x)` with no observer) reading a
     // record a live mark covers: no node carries the mark for it — the
     // verdict is told directly.
-    witness(e, n) {
-        const o = e.n?.[$AFFECTS];
-        if (o !== undefined && o.m !== null && o.m.T !== 0 || covering(e, n) !== null) GlobalQueue.dt();
+    ro(e, o) {
+        if (e.n?.[$AFFECTS]?.T?.I || covering(e, o)) GlobalQueue.rt();
     }
-});
+};
 
-GlobalQueue.O = storeMarks;
+/** `affects()` calls it before a store-targeted declaration (idempotent). */ function installStoreAffects() {
+    installAffectsHooks(hooks);
+}
 
 /** The carrier's last mark released (affects.ts): its scope dies, and the
- * nodes that inherited the mark release theirs. */ GlobalQueue.N = e => {
-    const n = scopes.get(e);
-    if (n === undefined) return;
+ * nodes that inherited the mark release theirs. */ function releaseMarkScope(e) {
+    const o = scopes.get(e);
+    if (o === undefined) return;
     scopes.delete(e);
-    GlobalQueue.A(n.inherited);
-};
+    releaseMarksHook(o.oo);
+}
+
+export { installStoreAffects, releaseMarkScope, storeMarks };

package/dist/prod/store/edges.js

@@ -0,0 +1,39 @@
+import { CONFIG_SLOT_NODE } from "../core/constants.js";
+
+import { signalName } from "../core/identities.js";
+
+import { $TARGET } from "./types.js";
+
+/**
+ * Deferred hydration, dependency edges for stores. Only the frames client
+ * imports this module, so nothing here ships without it.
+ *
+ * A plain store root (`createStore` over an object) is named like a plain
+ * signal (core/identities.ts: `<owner id>~<n>`, on the same count), and the
+ * whole store goes by that one name: the server records it for any read of
+ * the store, at any depth, and a setter call on the store — on its root or
+ * on a proxy nested in it — is a write to it. Its readers mount at the
+ * setter's entry, before the draft runs, as a plain signal's do.
+ */
+/**
+ * @internal The name of the store `x` belongs to — `x` a store proxy (a
+ * setter's entry) or one of its property nodes (the setter notifying it) —
+ * or undefined when it has none or it cannot be placed: a projection or
+ * optimistic family, a store chained over another store's proxy, a root
+ * named twice, or a proxy reached through a store other than the one it
+ * was named as the root of.
+ */ function storeName(e) {
+    if (e === undefined) return undefined;
+    let n = e.l & CONFIG_SLOT_NODE ? e.O : e[$TARGET];
+    if (n === undefined) return undefined;
+    // Up to the root; a target on the way named as a root of its own is one
+    // object in two stores.
+        while (n.u !== null) {
+        if (n.fam !== null || n.ch || signalName(n) !== undefined) return undefined;
+        n = n.u;
+    }
+    if (n.fam !== null || n.ch) return undefined;
+    return signalName(n) || undefined;
+}
+
+export { storeName };

package/dist/prod/store/hooks.js

@@ -0,0 +1,13 @@
+let optHooks = null;
+
+function installOptHooks(o) {
+    optHooks = o;
+}
+
+let affectsHooks = null;
+
+function installAffectsHooks(o) {
+    affectsHooks = o;
+}
+
+export { affectsHooks, installAffectsHooks, installOptHooks, optHooks };

package/dist/prod/store/index.js

@@ -2,8 +2,6 @@ import { createStore as createStore$1, deep as deep$1, snapshot as snapshot$1 }
 
 export { storeHasFamily, storeHasOptimisticFamily, storeIsShallow } from "./store.js";
 
-import "./affects.js";
-
 export { createOptimisticStore } from "./optimistic.js";
 
 import { createStoreDerived } from "./projection.js";