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

package/dist/observe/store/storePath.js

@@ -1,4 +1,4 @@
-import { isWrappable, ownEnumerableKeys } from "./store.js";
+import { isWrappable, ownEnumerableKeys } from "./types.js";
 
 const DELETE = Symbol(0);
 

package/dist/{prod/store/next → observe/store}/target.js

@@ -14,33 +14,29 @@
  */
 const $OWNER = Symbol(0);
 
-/** raw → target for UNOWNED backings (user-ingested, adopted); owned
- * backings resolve through their `$OWNER` stamp. Boundary mechanism (O8). */ const storeNextLookup = new WeakMap;
+/** raw → target for plain (family-less) stores. Family stores use their own
+ * map so one raw can wrap once per family (§7b). */ const storeLookup = new WeakMap;
 
-/** A backing the store allocated and may mutate in place. */ function isOwned(e) {
+function setLookup(e, o) {
+    (o.fam?.map ?? storeLookup).set(e, o);
+}
+
+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);
+/** The target wrapping `raw` in `fam` (or the plain lookup). An owned raw
+ * answers from its stamp; a user raw from the map. */ function lookupTarget(e, o) {
+    const n = e[$OWNER];
+    return n !== undefined && n.fam === o ? n : (o?.map ?? storeLookup).get(e);
 }
 
 function devAssertNeverUserMutation(e) {
     return;
 }
 
-let optHooks = null;
-
-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) {
+/** Sticky descendants flag up the parent chain (§6d): adoption descends
+ * into a changed child pair only where a target with nodes exists below. */ function markDescendants(e) {
     let o = e;
     while (o && !o.d) {
         o.d = true;
@@ -48,4 +44,7 @@ function setOptHooks(e) {
     }
 }
 
-export { $OWNER, devAssertNeverUserMutation, isOwned, lookupTarget, markDescendants, optHooks, setOptHooks, storeNextLookup };
+/** Observe tier: the owner in scope at `createStore` (attribution names and
+ * owner paths); the `_owner` write never reaches the proxy. */ const storeOwners = new WeakMap;
+
+export { $OWNER, devAssertNeverUserMutation, isOwned, lookupTarget, markDescendants, setLookup, storeLookup, storeOwners };

package/dist/observe/store/types.js

@@ -0,0 +1,73 @@
+/** Brand keys the proxy answers directly (never user data). */
+const $TRACK = Symbol(0), $TARGET = Symbol(0), $PROXY = Symbol(0), $RECORD = Symbol(0);
+
+// ---------------------------------------------------------------------------
+// raw marking (R42 / RUL-12: a value is never both wrapped and raw)
+const rawValues = new WeakSet;
+
+let rawValuesUsed = false;
+
+function isRawValue(e) {
+    return rawValuesUsed && rawValues.has(e);
+}
+
+/** Mark a value so no store ever wraps it (sticky; it reads as a leaf). */ function markRaw(e) {
+    if (isWrappable(e)) {
+        rawValuesUsed = true;
+        rawValues.add(e);
+    }
+    return e;
+}
+
+/** A shallow store's ingested record: raw by contract (values served
+ * verbatim, slots replaced by reference). */ function markRawOne(e) {
+    if (isWrappable(e)) {
+        if (e[$TARGET] !== undefined) return;
+        rawValuesUsed = true;
+        rawValues.add(e);
+    }
+}
+
+function markRawIngest(e) {
+    if (Array.isArray(e)) {
+        for (let r = 0, a = e.length; r < a; r++) markRawOne(e[r]);
+    } else {
+        for (const r in e) markRawOne(e[r]);
+    }
+}
+
+// ---------------------------------------------------------------------------
+// wrappability
+const OBJECT_PROTO = Object.prototype;
+
+const wrappableProtos = new WeakMap;
+
+function isWrappable(e) {
+    if (e == null || typeof e !== "object" || Object.isFrozen(e)) return false;
+    const r = Object.getPrototypeOf(e);
+    if (r === OBJECT_PROTO || r === null) return true;
+    if (Array.isArray(e)) return true;
+    let a = wrappableProtos.get(r);
+    if (a === undefined) {
+        a = Object.prototype.toString.call(e) === "[object Object]" && (typeof Node === "undefined" || !(e instanceof Node));
+        wrappableProtos.set(r, a);
+    }
+    return a;
+}
+
+function ownEnumerableKeys(e) {
+    return Reflect.ownKeys(e).filter(r => Object.prototype.propertyIsEnumerable.call(e, r));
+}
+
+// ---------------------------------------------------------------------------
+// write override: a projection's draft ops carry it (the derive is the
+// author — its writes must land outside the sync setter scope too, in a
+// continuation after an `await`/`yield`). Projections return in S3; the
+// traps already honour it.
+let writeOverride = false;
+
+function setWriteOverride(e) {
+    writeOverride = e;
+}
+
+export { $PROXY, $RECORD, $TARGET, $TRACK, isRawValue, isWrappable, markRaw, markRawIngest, markRawOne, ownEnumerableKeys, rawValuesUsed, setWriteOverride, writeOverride };

package/dist/observe/store/utils.js

@@ -1,20 +1,8 @@
-import "../core/core.js";
-
 import { SUPPORTS_PROXY } from "../core/constants.js";
 
-import "../core/dev.js";
-
-import "../core/scheduler.js";
-
-import "../core/invariants.js";
-
-import "../core/verdict.js";
-
-import "../core/effect.js";
-
 import { createMemo } from "../signals.js";
 
-import { $PROXY, $RECORD, $TARGET, ownEnumerableKeys } from "./store.js";
+import { $PROXY, $RECORD, $TARGET, ownEnumerableKeys } from "./types.js";
 
 function trueFn() {
     return true;

package/dist/prod/affects.js

@@ -1,127 +1,148 @@
-import { forEachDependent } from "./core/async.js";
-
-import { ext, statusNotifierOf } from "./core/core.js";
-
-import { $REFRESH, STATUS_PENDING } from "./core/constants.js";
-
-import { NotReadyError } from "./core/error.js";
-
-import { GlobalQueue, globalQueue, schedule, shiftAffectsMarks } from "./core/scheduler.js";
-
-import "./core/verdict.js";
-
-import "./core/effect.js";
-
-import "./core/invariants.js";
-
-import { $TARGET, getStoreAffectsNodes } from "./store/store.js";
+import { $REFRESH, CONFIG_VERDICT, STATUS_PENDING, CONFIG_SLOT_NODE, STATUS_ERROR, REACTIVE_RECOMPUTING_DEPS } from "./core/constants.js";
+
+import { ext } from "./core/core.js";
+
+import { enqueueSub } from "./core/heap.js";
+
+import { GlobalQueue, schedule, resolveTx, flushTransaction } from "./core/scheduler.js";
+
+import { $TARGET } from "./store/types.js";
+
+// `affects()` — the declaration verb of the pending model (A24 (4), ruled
+// 2026-07-13; the #2893 audit corollaries; rebuilt on L2 2026-10-02 as ruled:
+// transaction-inert).
+// A mark is a declared in-flight change: the marked node — and everything
+// derived from it — reads pending (`isPending` → true) from the declaration
+// until the surrounding transaction lands (an ambient mark, declared outside
+// one, releases at the next seam). The marked values stay readable: no reader
+// suspends on a mark, a mark holds nothing and entangles nothing — it is not
+// a node of its transaction (`blocked` never sees it), and a reader of marked
+// data joins nothing through it. A mark is never a re-ask, so a declared
+// reload's own `refresh()` cannot silence it; a real error outranks it.
+// Representation: a count on the marked node (`_x._marks`), listed with its
+// scope (the transaction's `_marks`, or the ambient list). Coverage of the
+// derivations is pull-derived at probe time — `isPending`'s read walks the
+// probed node's dependencies for a marked one (verdict.ts → `_marked`) — so
+// nothing is stored downstream and a mid-window recompute strands nothing.
+// The push half is the verdict readers' re-derivation at registration and at
+// release (`repoll`): the only notification a mark makes.
+// Installed on `GlobalQueue` when imported: a program that never declares a
+// mark carries none of this.
+/** Live marks, every scope — the gate on the probe's walk. */
+let active = 0;
+
+/** Marks declared outside a transaction: released at the next seam. */ const ambient = [];
+
+/** The verdict readers downstream of `node` — through derivations, stopping
+ * at effects — re-derive: the mark's one notification (a probe's answer
+ * changed with no value notifying anyone). */ function repoll(e, t = new Set) {
+    for (let n = e.t; n !== null; n = n.l) {
+        const e = n.o;
+        if (t.has(e)) continue;
+        t.add(e);
+        if (e.u & CONFIG_VERDICT) enqueueSub(e);
+        if (!e.i) repoll(e, t);
+    }
+}
 
-/**
- * The counting half of a mark, shared by direct registration and store-scope
- * inheritance (a node created inside a live keyless mark's identity scope).
- * A mark is ONLY this count: coverage of everything derived from the node is
- * pull-derived by the verdict layer's `markWalk` (dep-graph reachability), so
- * nothing is stored downstream and nothing can be stranded or stripped by
- * mid-window recomputes.
- */ function markAffects(e) {
-    ext(e).t = (e.o?.t || 0) + 1;
-    shiftAffectsMarks(1);
+/** A node is covered by a live mark iff it carries one, or derives — through
+ * its current dependencies — from one that does. A real error outranks an
+ * inherited mark (A24 (c)): coverage does not flow through an errored node
+ * (a direct mark on one still reads pending). Mid-recompute, only the
+ * validated prefix of the dependency list is this pass's. */ function marked(e, t) {
+    if (e.m !== null && e.m.T !== 0) return true;
+    const n = e;
+    if (n.G & STATUS_ERROR || t.has(e)) return false;
+    t.add(e);
+    const r = n.R & REACTIVE_RECOMPUTING_DEPS ? n.S : undefined;
+    if (r !== null) for (let e = n._ ?? null; e !== null; e = e.p) {
+        if (marked(e.I, t)) return true;
+        if (e === r) break;
+    }
+    return false;
 }
 
-/**
- * Boundary visual channel: within a transaction, a live mark holds Loading
- * fallbacks / reveal ordering the way real in-flight async would — but the
- * notification is tagged visibility-only at the source (`_markVisual`), so
- * the root queue never registers reporters from it: marks are invisible to
- * ALL completion and settlement accounting by construction. Boundaries hold
- * the marked node in `_sources` while `_affectsCount` is live; the release
- * sweep (finalizePureQueue re-checks boundary children after mark release)
- * is the display-state update point. Ambient marks release inside the same
- * flush that would surface them, before effects run — verdict-only, netting
- * no visual change.
- */ function notifyMarkBoundaries(e) {
-    if (!e.u && !e.o?.i) return;
-    const r = new NotReadyError(e);
-    r.l = true;
-    const t = new Set;
-    const visit = e => {
-        if (t.has(e)) return;
-        t.add(e);
-        // Display consumers (render effects, boundary computeds) act on the
-        // notification; descent stops there, exactly like the status rails.
-                const o = statusNotifierOf(e);
-        if (o) {
-            o.call(e, STATUS_PENDING, r);
-            return;
+/** Releases one scope's marks (a landed transaction's, the ambient list at
+ * the seam): a node whose last mark drops re-derives its verdict readers. */ function release(e) {
+    for (let t = 0; t < e.length; t++) {
+        const n = e[t];
+        active--;
+        if (--n.m.T === 0) {
+            repoll(n);
+            // A store mark's carrier: its scope (and the marks the nodes born in
+            // its window inherited) goes with it.
+                        GlobalQueue.N?.(n);
         }
-        forEachDependent(e, visit);
-    };
-    forEachDependent(e, visit);
+    }
+    e.length = 0;
 }
 
-/**
- * Registers one `affects()` mark on a node: counts it, records the
- * registration with the current transaction (after initTransition the queue's
- * batch IS the active transition, mirroring `_optimisticNodes`), re-derives
- * every downstream verdict companion (the mark channel's only push — verdict
- * pokes, not state), and notifies boundary display state. Both walks run on
- * every registration (not just the first): subscribers gained since an
- * earlier overlapping registration get covered, and dedup stops re-descent.
- */ function registerAffectsMark(e) {
-    markAffects(e);
-    globalQueue.m.A.push(e);
-    // Companions only exist once the verdict layer (isPending/latest) loaded;
-    // without them there is no materialized verdict to poke.
-        GlobalQueue.k !== null && GlobalQueue.k(e);
-    notifyMarkBoundaries(e);
-    schedule();
+/** One registration: a count on the node, listed with the scope — the
+ * flush's transaction, or the ambient list (released at the seam). */ function register(e) {
+    mark(e);
+    const t = flushTransaction;
+    if (t === null) ambient.push(e); else {
+        const n = resolveTx(t);
+        (n.T ??= []).push(e);
+    }
+    repoll(e);
 }
 
-/**
- * Releases one registration. When the node's last mark drops, re-derives
- * every downstream verdict through the settlement snap (committed, not
- * transition-scoped — release runs inside queue finalization, where a
- * setSignal would open a fresh override window that nothing settles).
- */ function releaseAffectsMark(e) {
-    shiftAffectsMarks(-1);
-    e.o.t--;
-    if (!e.o.t) {
-        GlobalQueue.k !== null && GlobalQueue.k(e, true);
-        GlobalQueue.p?.(e);
-    }
+function mark(e) {
+    ext(e).T++;
+    active++;
 }
 
-/**
- * Releases one batch of affects marks (a settling transaction's, or the
- * ambient batch at a plain flush end).
- */ function releaseAffectsMarks(e) {
-    for (let r = 0; r < e.length; r++) releaseAffectsMark(e[r]);
-    e.length = 0;
+function affects(e, t) {
+    // A store (the store half, store/affects.ts): the slot's leaf, or the
+    // record's carrier and every live node under it.
+    const n = e?.[$TARGET];
+    if (n !== undefined) {
+        const e = GlobalQueue.O(n, t);
+        for (let t = 0; t < e.length; t++) register(e[t]);
+        schedule();
+        return;
+    }
+    const r = e?.[$REFRESH];
+    if (!r) {
+        return;
+    }
+    register(r);
+    schedule();
 }
 
-// Late installation (same pattern as `GlobalQueue._update`): the mark engine
-// lives with the feature so graphs that never declare a mark never ship it.
-// Each call site is gated by state only this module creates (a non-empty
-// `_affectsNodes` batch, a live scope in the store's `affectsScopes`), so the
-// hooks are installed before the first time any of them can fire.
-GlobalQueue.G = releaseAffectsMarks;
+GlobalQueue.C = e => active !== 0 && marked(e, new Set);
 
-GlobalQueue.M = markAffects;
+GlobalQueue.h = mark;
 
-GlobalQueue.N = releaseAffectsMark;
+GlobalQueue.A = release;
 
-function affects(e, r) {
-    const t = e?.[$TARGET];
-    if (t) {
-        const e = getStoreAffectsNodes(t, r);
-        for (let r = 0; r < e.length; r++) registerAffectsMark(e[r]);
+GlobalQueue.D = e => {
+    if (ambient.length === 0) return;
+    // The flush parked: the declaration's window is the frame's — the marks
+    // are its transaction's ("nothing async below ⇒ no window").
+        if (e !== null) {
+        const t = e.T ??= [];
+        for (let e = 0; e < ambient.length; e++) t.push(ambient[e]);
+        ambient.length = 0;
         return;
     }
-    const o = e?.[$REFRESH];
-    if (o) {
-        registerAffectsMark(o);
-        return;
+    // Nothing parked, but a marked node's own flight is up (a declared
+    // reload's quiet re-ask — the node's, or a store leaf's family derive):
+    // the window is the flight's; the mark stays to the seam after the
+    // landing. The rest release: verdict-only, nothing to show.
+        let t = 0;
+    const n = [];
+    for (let e = 0; e < ambient.length; e++) {
+        const r = ambient[e];
+        if (inFlight(r)) ambient[t++] = r; else n.push(r);
     }
+    ambient.length = t;
+    if (n.length !== 0) release(n);
+};
+
+function inFlight(e) {
+    return (e.G & STATUS_PENDING) !== 0 || (e.u & CONFIG_SLOT_NODE) !== 0 && GlobalQueue.F?.(e) === true;
 }
 
 export { affects };