@solidjs/signals 2.0.0-rc.0 → 2.0.0-rc.2

package/dist/prod/store/utils.js

@@ -1,4 +1,4 @@
-import { pendingCheckActive } from "../core/core.js";
+import "../core/core.js";
 
 import { SUPPORTS_PROXY } from "../core/constants.js";
 
@@ -12,162 +12,29 @@ import "../core/effect.js";
 
 import { createMemo } from "../signals.js";
 
-import { ownEnumerableKeys, $PROXY, isWrappable, $TARGET, lookupTarget, trackSelf, witnessAffectsMark, mergedOverlay, STORE_VALUE, storeLookup, STORE_LOOKUP, $DELETED, wrap, getStoreSymbols, getPropertyDescriptor, getStoreKeys, getKeys, $TRACK, rawValuesUsed, isRawValue } from "./store.js";
-
-function snapshotImpl(e, t, r, n) {
-    let o, s, i, c, f, u;
-    if (!isWrappable(e)) return e;
-    if (r && r.has(e)) return r.get(e);
-    if (!r) r = new Map;
-    if (o = e[$TARGET] || lookupTarget(e, n)) {
-        if (t) {
-            trackSelf(o, $TRACK);
-            // A tracked walk reads THROUGH the record without touching the proxy
-            // traps — witness the record's affects() channel like a trap read would.
-                        if (pendingCheckActive) witnessAffectsMark(o);
-        }
-        i = mergedOverlay(o);
-        // A derived store's STORE_VALUE is the inner store's live proxy
-        // (store-in-store: createOptimisticStore/createProjection over a store).
-        // Without an overlay of its own, the fast path below would map to — and
-        // could return — that proxy verbatim. Recurse instead so the
-        // inner store's own target branch unwraps it (chains of any depth).
-        // With an overlay, a fresh `result` is always built, so the walk over the
-        // inner proxy already copies plain values.
-                if (!i && o[STORE_VALUE][$TARGET]) {
-            f = snapshotImpl(o[STORE_VALUE], t, r, n);
-            r.set(e, f);
-            return f;
-        }
-        s = Array.isArray(o[STORE_VALUE]);
-        r.set(e, i ? c = s ? [] : Object.create(Object.getPrototypeOf(o[STORE_VALUE])) : o[STORE_VALUE]);
-        e = o[STORE_VALUE];
-        n = o[STORE_LOOKUP] ?? storeLookup;
-    } else {
-        s = Array.isArray(e);
-        r.set(e, e);
-    }
-    if (s) {
-        const s = i?.length ?? e.length;
-        for (let a = 0; a < s; a++) {
-            u = i && a in i ? i[a] : e[a];
-            if (u === $DELETED) continue;
-            if (t && isWrappable(u) && !(rawValuesUsed && isRawValue(u))) wrap(u, o);
-            if ((f = snapshotImpl(u, t, r, n)) !== u || c) {
-                if (!c) r.set(e, c = [ ...e ]);
-                c[a] = f;
-            }
-        }
-        // Enumerate array symbols separately to avoid scanning indices twice.
-        // Spread copies omit symbols, so assign them after the numeric walk.
-                const a = n ? getStoreSymbols(e, i) : [];
-        for (let s = 0, l = a.length; s < l; s++) {
-            const l = a[s];
-            const p = getPropertyDescriptor(e, i, l);
-            if (!p || p.get) continue;
-            u = i && l in i ? i[l] : e[l];
-            if (t && isWrappable(u) && !(rawValuesUsed && isRawValue(u))) wrap(u, o);
-            f = snapshotImpl(u, t, r, n);
-            if (f !== u || c) {
-                if (!c) r.set(e, c = Object.assign([ ...e ], e));
-                c[l] = f;
-            }
-        }
-        // Deleted trailing slots are skipped above, so restore length to preserve
-        // holes instead of truncating the copy (#2846) — mirrors unwrapStoreValue.
-                if (c) c.length = s;
-    } else if (!i) {
-        // Specialized walk for the common no-overlay case (from #2756): the own
-        // descriptor gives the value directly, so each property is read once with
-        // no overlay membership checks.
-        // A lookup means this object belongs to an immutable store backing tree,
-        // even if that nested value has not needed its own proxy yet.
-        const s = n ? getStoreKeys(e, undefined) : getKeys(e, undefined);
-        for (let i = 0, a = s.length; i < a; i++) {
-            const a = s[i];
-            const l = Object.getOwnPropertyDescriptor(e, a);
-            if (l.get) continue;
-            u = l.value;
-            if (t && isWrappable(u) && !(rawValuesUsed && isRawValue(u))) wrap(u, o);
-            if ((f = snapshotImpl(u, t, r, n)) !== u || c) {
-                if (!c) {
-                    c = Object.create(Object.getPrototypeOf(e));
-                    Object.assign(c, e);
-                }
-                c[a] = f;
-            }
-        }
-    } else {
-        // An override only exists on a store record, and the target branch above
-        // always set `lookup` alongside it — so this branch is always store-keyed.
-        const s = getStoreKeys(e, i);
-        for (let a = 0, l = s.length; a < l; a++) {
-            let l = s[a];
-            const p = getPropertyDescriptor(e, i, l);
-            if (p.get) continue;
-            u = l in i ? i[l] : e[l];
-            if (t && isWrappable(u) && !(rawValuesUsed && isRawValue(u))) wrap(u, o);
-            if ((f = snapshotImpl(u, t, r, n)) !== e[l] || c) {
-                if (!c) {
-                    c = Object.create(Object.getPrototypeOf(e));
-                    Object.assign(c, e);
-                }
-                c[l] = f;
-            }
-        }
-    }
-    return c || e;
-}
-
-function snapshot(e, t, r) {
-    return snapshotImpl(e, false, t, r);
-}
-
-/**
- * Returns a plain (non-proxy) deep copy **and** subscribes the current
- * tracking scope to every nested change in the source store. Any write
- * anywhere in the subtree invalidates the consumer.
- *
- * Use this when you need plain data inside a reactive scope and want to
- * react to deep mutations (e.g. passing a snapshot to `reconcile()` or to a
- * memo that should rerun on any nested change). For most read paths, prefer
- * direct property access — Solid stores already track per-property reads
- * with no `deep()` wrapper needed.
- *
- * @example
- * ```ts
- * const [state] = createStore({ a: { b: { c: 1 } } });
- *
- * createEffect(
- *   () => deep(state),                  // reruns on any nested change
- *   plain => sendToWorker(plain)        // worker gets a non-proxy copy
- * );
- * ```
- */ function deep(e) {
-    return snapshotImpl(e, true);
-}
+import { ownEnumerableKeys, $PROXY } from "./store.js";
 
 function trueFn() {
     return true;
 }
 
 const propTraps = {
-    get(e, t, r) {
-        if (t === $PROXY) return r;
-        return e.get(t);
+    get(e, r, t) {
+        if (r === $PROXY) return t;
+        return e.get(r);
     },
-    has(e, t) {
-        if (t === $PROXY) return true;
-        return e.has(t);
+    has(e, r) {
+        if (r === $PROXY) return true;
+        return e.has(r);
     },
     set: trueFn,
     deleteProperty: trueFn,
-    getOwnPropertyDescriptor(e, t) {
+    getOwnPropertyDescriptor(e, r) {
         return {
             configurable: true,
             enumerable: true,
             get() {
-                return e.get(t);
+                return e.get(r);
             },
             set: trueFn,
             deleteProperty: trueFn
@@ -205,36 +72,36 @@ const $SOURCES = Symbol(0);
  * ```
  */ function merge(...e) {
     if (e.length === 1 && typeof e[0] !== "function") return e[0];
-    let t = false;
-    const r = [];
+    let r = false;
+    const t = [];
     for (let n = 0; n < e.length; n++) {
         const o = e[n];
-        t = t || !!o && $PROXY in o;
+        r = r || !!o && $PROXY in o;
         const s = !!o && o[$SOURCES];
         if (s) {
-            for (let e = 0; e < s.length; e++) r.push(s[e]);
-        } else r.push(typeof o === "function" ? (t = true, createMemo(o)) : o);
+            for (let e = 0; e < s.length; e++) t.push(s[e]);
+        } else t.push(typeof o === "function" ? (r = true, createMemo(o)) : o);
     }
-    if (SUPPORTS_PROXY && t) {
+    if (SUPPORTS_PROXY && r) {
         return new Proxy({
             get(e) {
-                if (e === $SOURCES) return r;
-                for (let t = r.length - 1; t >= 0; t--) {
-                    const n = resolveSource(r[t]);
+                if (e === $SOURCES) return t;
+                for (let r = t.length - 1; r >= 0; r--) {
+                    const n = resolveSource(t[r]);
                     if (e in n) return n[e];
                 }
             },
             has(e) {
-                for (let t = r.length - 1; t >= 0; t--) {
-                    if (e in resolveSource(r[t])) return true;
+                for (let r = t.length - 1; r >= 0; r--) {
+                    if (e in resolveSource(t[r])) return true;
                 }
                 return false;
             },
             keys() {
                 const e = new Set;
-                for (let t = 0; t < r.length; t++) {
-                    const n = ownEnumerableKeys(resolveSource(r[t]));
-                    for (let t = 0; t < n.length; t++) e.add(n[t]);
+                for (let r = 0; r < t.length; r++) {
+                    const n = ownEnumerableKeys(resolveSource(t[r]));
+                    for (let r = 0; r < n.length; r++) e.add(n[r]);
                 }
                 return [ ...e ];
             }
@@ -242,37 +109,37 @@ const $SOURCES = Symbol(0);
     }
     const n = Object.create(null);
     let o = false;
-    let s = r.length - 1;
+    let s = t.length - 1;
     for (let e = s; e >= 0; e--) {
-        const t = r[e];
-        if (!t) {
+        const r = t[e];
+        if (!r) {
             e === s && s--;
             continue;
         }
-        const i = Object.getOwnPropertyNames(t);
-        for (let r = i.length - 1; r >= 0; r--) {
-            const c = i[r];
+        const u = Object.getOwnPropertyNames(r);
+        for (let t = u.length - 1; t >= 0; t--) {
+            const c = u[t];
             if (c === "__proto__" || c === "constructor") continue;
             if (!n[c]) {
                 o = o || e !== s;
-                const r = Object.getOwnPropertyDescriptor(t, c);
-                n[c] = r.get ? {
+                const t = Object.getOwnPropertyDescriptor(r, c);
+                n[c] = t.get ? {
                     enumerable: true,
                     configurable: true,
-                    get: r.get.bind(t)
-                } : r;
+                    get: t.get.bind(r)
+                } : t;
             }
         }
     }
-    if (!o) return r[s];
-    const i = {};
+    if (!o) return t[s];
+    const u = {};
     const c = Object.keys(n);
     for (let e = c.length - 1; e >= 0; e--) {
-        const t = c[e], r = n[t];
-        if (r.get) Object.defineProperty(i, t, r); else i[t] = r.value;
+        const r = c[e], t = n[r];
+        if (t.get) Object.defineProperty(u, r, t); else u[r] = t.value;
     }
-    i[$SOURCES] = r;
-    return i;
+    u[$SOURCES] = t;
+    return u;
 }
 
 /**
@@ -299,30 +166,36 @@ const $SOURCES = Symbol(0);
  *   );
  * }
  * ```
- */ function omit(e, ...t) {
+ */ function omit(e, ...r) {
     if (SUPPORTS_PROXY && $PROXY in e) {
         return new Proxy({
-            get(r) {
-                return t.includes(r) ? undefined : e[r];
+            get(t) {
+                // $SOURCES must not tunnel through the filter: merge() flattens
+                // whatever answers it, so forwarding would hand a re-merge the
+                // UNFILTERED sources of an underlying merge proxy and the omitted
+                // keys leak back in (#3014 — the SSR element-spread path re-merges
+                // static attributes with the rest object). Opaque here: merge
+                // composes omit proxies through their traps instead.
+                return t === $SOURCES || r.includes(t) ? undefined : e[t];
             },
-            has(r) {
-                return !t.includes(r) && r in e;
+            has(t) {
+                return t !== $SOURCES && !r.includes(t) && t in e;
             },
             keys() {
-                return ownEnumerableKeys(e).filter(e => !t.includes(e));
+                return ownEnumerableKeys(e).filter(e => !r.includes(e));
             }
         }, propTraps);
     }
-    const r = {};
+    const t = {};
     const n = Object.getOwnPropertyNames(e);
-    const o = t.length > 4 && n.length > t.length ? new Set(t) : undefined;
+    const o = r.length > 4 && n.length > r.length ? new Set(r) : undefined;
     for (const s of n) {
-        if (o ? !o.has(s) : !t.includes(s)) {
-            const t = Object.getOwnPropertyDescriptor(e, s);
-            !t.get && !t.set && t.enumerable && t.writable && t.configurable ? r[s] = t.value : Object.defineProperty(r, s, t);
+        if (o ? !o.has(s) : !r.includes(s)) {
+            const r = Object.getOwnPropertyDescriptor(e, s);
+            !r.get && !r.set && r.enumerable && r.writable && r.configurable ? t[s] = r.value : Object.defineProperty(t, s, r);
         }
     }
-    return r;
+    return t;
 }
 
-export { deep, merge, omit, snapshot };
+export { merge, omit };

package/dist/types/core/attribution-hooks.d.ts

@@ -0,0 +1,52 @@
+import type { Computed, Signal } from "./types.js";
+/**
+ * Dev-only observability hook points for the reactive core.
+ *
+ * Core's obligation is to call these with true facts at the moments they
+ * happen; ALL attribution semantics (stamps, cause chains, timings, warnings)
+ * live in the engine that installs them (attribution.ts — same pattern as the
+ * GlobalQueue._* feature slots). `attrHooks` is null unless an engine is
+ * installed, so the disabled cost is one null check per site, and prod builds
+ * fold every site out behind __DEV__.
+ *
+ * IMPORTANT for implementers of call sites: a hook call must never sit inside
+ * a `try` block — rollup's tryCatchDeoptimization retains functions referenced
+ * inside `try` even behind a folded __DEV__ guard, which re-couples the dev
+ * engine into prod bundles (#2883 harness). Set a local flag inside the try
+ * and call the hook after the catch.
+ */
+export interface AttributionHooks {
+    /**
+     * A recompute is starting; `el._deps` still holds the previous run's links.
+     * Always paired with `recomputeEnd` (recompute has no early returns).
+     */
+    recomputeStart(el: Computed<any>, create: boolean): void;
+    /**
+     * The recompute finished. `changed` = committed a changed value (false for
+     * errored runs); `optimistic` = ran under an optimistic lane / lane-dirty
+     * posture; `transition` = a transition was active or owns this node;
+     * `held` = the value went to `_pendingValue` (a transition hold) rather
+     * than committing directly — its reveal happens later on the transition's
+     * own schedule.
+     */
+    recomputeEnd(el: Computed<any>, create: boolean, changed: boolean, optimistic: boolean, transition: boolean, held: boolean): void;
+    /** A non-effect computed committed a changed value during a re-run. */
+    derivedChanged(el: Computed<any>): void;
+    /** A signal write committed (value passed the equality gate). */
+    write(el: Signal<any> | Computed<any>, prev: unknown, value: unknown): void;
+    /** refresh() invalidated this node (self-invalidation, no dep changed). */
+    refreshed(el: Computed<any>): void;
+    /** An async landing is about to apply its value (before any branch). */
+    asyncStart(el: Computed<any>): void;
+    /**
+     * The async landing finished. `direct` = the landing applies the value
+     * itself (lane/override paths); false = it went through setSignal, whose
+     * own `write` hook already saw any committed change. Fired whether or not
+     * the landing committed — call sites cannot carry that fact out of their
+     * try blocks (see the try rule above), so the engine derives committed-ness
+     * from the node's state against its asyncStart snapshot.
+     */
+    asyncEnd(el: Computed<any>, prev: unknown, value: unknown, direct: boolean): void;
+}
+export declare let attrHooks: AttributionHooks | null;
+export declare function setAttributionHooks(hooks: AttributionHooks | null): void;

package/dist/types/core/attribution.d.ts

@@ -0,0 +1,186 @@
+import type { Computed } from "./types.js";
+/**
+ * Dev-mode "why did this run" attribution.
+ *
+ * The runtime already knows the full dependency set of every scope; this
+ * module surfaces it. Every value commit stamps its node with a ChangeRecord
+ * (a write, an async landing, a refresh() invalidation, or a derived change
+ * whose `causes` chain back to root writes). When a computation re-executes,
+ * the deps whose stamp is newer than the node's last run are its causes, so
+ * each re-run can be explained as a chain down to the originating write:
+ *
+ *   [why-run] effect "docTitle" ran (run 4)
+ *     ← memo "userLabel" changed (#6)
+ *       ← signal "notifications" write (#5) 2 → 3
+ *
+ * This module is the attribution ENGINE: all semantics live here, and it is
+ * decoupled from the core. `enable()` installs it into the core's narrow
+ * dev-only hook points (attribution-hooks.ts); core's only obligation is to
+ * call those hooks with true facts. Disabled cost is one null check per hook
+ * site; prod builds fold the sites out entirely. The same hook surface is the
+ * intended substrate for external consumers (devtools) — one mechanism, two
+ * front-ends.
+ */
+export type ChangeKind = "write" | "derived" | "async" | "refresh";
+export interface ChangeRecord {
+    /** Global monotonic change sequence — orders causes across the app. */
+    seq: number;
+    kind: ChangeKind;
+    name: string;
+    /** Short previews of the value transition (writes only). */
+    prev?: string;
+    value?: string;
+    /** First user frames of the triggering write's stack (opt-in). */
+    stack?: string[];
+    /** For derived changes: the upstream changes that produced this one. */
+    causes?: ChangeRecord[];
+}
+export interface RerunEvent {
+    /** Global monotonic run sequence. */
+    run: number;
+    /** How many times this node has re-run since attribution was enabled. */
+    nodeRuns: number;
+    nodeKind: "effect" | "memo";
+    nodeName: string;
+    node: Computed<any>;
+    /**
+     * The deps that changed since this node's previous run. Empty means the
+     * re-run was not triggered by a tracked value change (creation-adjacent
+     * pull, error retry, or a cause this prototype does not stamp yet).
+     */
+    causes: ChangeRecord[];
+    /** Dependency count after this run. */
+    depCount: number;
+    /** Names of deps this run subscribed to that the previous run did not. */
+    depsAdded: string[];
+    /** Names of deps the previous run had that this run dropped. */
+    depsRemoved: string[];
+    /** Wall time of this run excluding nested recomputes (ms). */
+    selfMs: number;
+    /** Wall time of this run including nested recomputes (ms). */
+    totalMs: number;
+    /**
+     * Whether the run committed a changed value. A PLAIN memo run with
+     * `changed: false` was pure waste — the equality cutoff stopped it from
+     * notifying anyone; an effect run with `changed: false` computed without
+     * firing its effect phase. Summed as `wastedMs` in costs() (plain,
+     * non-held runs only — see `phase`).
+     */
+    changed: boolean;
+    /**
+     * Which posture this run executed under. "optimistic" = under an
+     * optimistic lane (overlay recompute); "transition" = a transition was
+     * active or owns the node (the run may be replayed/settled later);
+     * "plain" = an ordinary committed run. Overlay runs are real work (they
+     * count toward time budgets) but are never blamed as waste, and costs()
+     * reports their time separately as `overlayMs`.
+     */
+    phase: "plain" | "transition" | "optimistic";
+    /**
+     * The changed value was held in `_pendingValue` (a transition hold) rather
+     * than committed directly; its reveal happens on the transition's own
+     * schedule. Held runs are excluded from waste accounting.
+     */
+    held: boolean;
+}
+export interface AttributionOptions {
+    /** Pretty-print each re-run to the console (default true). */
+    log?: boolean;
+    /** Capture the user stack frame of each write — slow (default false). */
+    stacks?: boolean;
+    /** Ring-buffer size for `history()` (default 200). */
+    historyLimit?: number;
+    /**
+     * Hot-scope warning: emit a diagnostic when one scope re-runs `count`
+     * times within `windowMs` (default 120 runs / 1000ms — deliberately above
+     * animation-frame cadence, so a legitimate rAF-driven scope at 60/s does
+     * not cry wolf). `false` disables.
+     */
+    hotRuns?: {
+        count: number;
+        windowMs: number;
+    } | false;
+    /**
+     * Wide-scope warning: emit a diagnostic when a scope's dependency count
+     * reaches this (default 30) — the coarse-read / helper-leak signature.
+     * Re-warns only if the count then grows by another 50%. `false` disables.
+     */
+    wideDeps?: number | false;
+    /**
+     * Time-budget warning: emit a diagnostic when one scope's summed self-time
+     * inside `windowMs` exceeds `budgetMs` (default 8ms / 1000ms — half a frame
+     * spent in one scope). Unlike `hotRuns` this catches the few-but-expensive
+     * scope that run counts miss. `false` disables.
+     */
+    hotTime?: {
+        budgetMs: number;
+        windowMs: number;
+    } | false;
+    /**
+     * Unstable-output warning: emit a diagnostic when a memo commits a
+     * referentially-new but shallowly-equivalent plain object/array on this
+     * many consecutive runs (default 4). Such a memo's equality gate never
+     * closes — every subscriber re-runs on every upstream change — which makes
+     * it a fan-out amplifier that is otherwise only findable by profiling.
+     * `false` disables.
+     */
+    unstableMemos?: number | false;
+    /**
+     * Written-fan-out warning: emit a diagnostic when a committed root
+     * invalidation (write, refresh, async landing) reaches a node with at
+     * least this many subscribers (default 250). Complements the always-on
+     * HUGE_FAN_OUT graph-size warning, specced against it deliberately:
+     * HUGE_FAN_OUT fires at LINK time from GRAPH_SIZE_WARN_AT (2000) up —
+     * static structure so large it warns even if never written — while this
+     * fires at WRITE time from a much lower bar, because fan-out only costs
+     * anything when the node actually changes. Once per node, re-warning only
+     * on 2x subscriber growth, so the two never spam the same node. `false`
+     * disables.
+     */
+    wideWrites?: number | false;
+}
+export interface ScopeCost {
+    name: string;
+    kind: "effect" | "memo";
+    runs: number;
+    selfMs: number;
+    /**
+     * Self-time of PLAIN, non-held runs that produced an unchanged value —
+     * the recoverable number. Overlay runs (optimistic/transition) are never
+     * counted here: an optimistic recompute landing back on the committed
+     * value is the mechanism working, not waste.
+     */
+    wastedMs: number;
+    /** Self-time spent in optimistic/transition (overlay) runs. */
+    overlayMs: number;
+}
+export interface WriteCost {
+    /** Root cause name (a signal write, async landing, or refresh target). */
+    name: string;
+    /** Number of downstream re-runs this root triggered. */
+    runs: number;
+    /** Summed self-time of every downstream re-run it caused. */
+    downstreamMs: number;
+}
+export declare function formatRerun(event: RerunEvent): string;
+export interface Attribution {
+    enable(opts?: AttributionOptions): void;
+    disable(): void;
+    subscribe(listener: (event: RerunEvent) => void): () => void;
+    history(): readonly RerunEvent[];
+    /** Re-run history for one node — pass a memo/effect accessor or raw node. */
+    why(target: unknown): RerunEvent[];
+    /** Current dependency names of one scope — the devtools subscription view. */
+    subscriptions(target: unknown): string[];
+    /**
+     * Aggregated cost tables since enable(): `scopes` ranked by self-time
+     * (with `wastedMs` = time spent on unchanged-value runs), `writes` ranked
+     * by total downstream re-run time each root write caused.
+     */
+    costs(): {
+        scopes: ScopeCost[];
+        writes: WriteCost[];
+    };
+    format: typeof formatRerun;
+}
+export declare const attribution: Attribution;

package/dist/types/core/constants.d.ts

@@ -18,6 +18,15 @@ export declare const REACTIVE_MANUAL_WRITE: number;
  * pending window does not read as pending (question-scoped pending model).
  */
 export declare const REACTIVE_REASK: number;
+/**
+ * A dependency write landed while this subscriber was mid-recompute — a
+ * nested pull committed beneath one of its reads (#3037). The heap refuses
+ * RECOMPUTING nodes, so recompute's tail consumes this latch and reschedules:
+ * values the pass read before the nested commit are stale. Only set for
+ * links validated this pass (gen-current): a write to an untouched link is
+ * either re-read later in the pass (fresh) or trimmed with it (not a dep).
+ */
+export declare const REACTIVE_MISSED_WAKE: number;
 export declare const CONFIG_OWNED_WRITE: number;
 export declare const CONFIG_NO_SNAPSHOT: number;
 export declare const CONFIG_TRANSPARENT: number;
@@ -25,6 +34,23 @@ export declare const CONFIG_IN_SNAPSHOT_SCOPE: number;
 export declare const CONFIG_CHILDREN_FORBIDDEN: number;
 export declare const CONFIG_AUTO_DISPOSE: number;
 export declare const CONFIG_SYNC: number;
+export declare const CONFIG_OPTIMISTIC: number;
+export declare const CONFIG_HAS_COMPANIONS: number;
+export declare const CONFIG_HAS_SNAPSHOT: number;
+export declare const CONFIG_HAS_LANE: number;
+/** Set on a FIREWALL computed when any of its child signals creates an
+ * isPending()/latest() companion. Gates the post-recompute child-companion
+ * walk (#3038): a store computed's `_child` chain holds one node per
+ * materialized leaf, so walking it unconditionally makes every update cost
+ * O(all leaves ever read). Sticky — set at companion creation, never
+ * cleared; sync-only apps never set it and never pay the walk. */
+export declare const CONFIG_CHILD_COMPANIONS: number;
+/** Set on a computed when its first firewall child signal is installed
+ * (projection machinery). Gates markNode's firewall-children walk with one
+ * masked read of the always-present _config — the walk's old `_child` read
+ * moved into the cold extension (§12), and an unconditional `_x` deref per
+ * marked node measurably taxed the propagation hot path (diamond -22%). */
+export declare const CONFIG_FW_CHILDREN: number;
 export declare const STATUS_NONE = 0;
 export declare const STATUS_PENDING: number;
 export declare const STATUS_ERROR: number;

package/dist/types/core/core.d.ts

@@ -1,6 +1,6 @@
 import { type Refreshable } from "./constants.js";
 import { type OptimisticLane } from "./lanes.js";
-import type { Computed, FirewallSignal, NodeOptions, Owner, Signal } from "./types.js";
+import type { Computed, FirewallSignal, NodeExtension, NodeOptions, Owner, Signal } from "./types.js";
 export declare const PRIMITIVE_IN_FORBIDDEN_SCOPE_MESSAGE = "[PRIMITIVE_IN_FORBIDDEN_SCOPE] Cannot create reactive primitives inside createTrackedEffect or owner-backed onSettled";
 export declare const REACTIVE_WRITE_IN_OWNED_SCOPE_SIGNAL_MESSAGE: string;
 export declare const REACTIVE_WRITE_IN_OWNED_SCOPE_REFRESH_MESSAGE: string;
@@ -25,6 +25,13 @@ export declare function clearSnapshots(): void;
 export declare function recompute(el: Computed<any>, create?: boolean): void;
 export declare function computed<T>(fn: (prev?: T) => T | PromiseLike<T> | AsyncIterable<T>): Computed<T>;
 export declare function computed<T>(fn: (prev: T) => T | PromiseLike<T> | AsyncIterable<T>, options?: NodeOptions<T>): Computed<T>;
+/** Lazily allocate a node's cold extension (ONE shape for signals and
+ * computeds — `_x` access stays monomorphic). Installers write through
+ * this; hot paths read `el._x?._field` gated by the _config presence bits.
+ * Never call ext() just to store a field's default. */
+export declare function ext(el: {
+    _x: NodeExtension | null;
+}): NodeExtension;
 /**
  * Build an Effect node with all effect-specific fields baked into a single object literal,
  * so V8 sees the full hidden class shape at construction time. Effects always run in lazy
@@ -88,6 +95,14 @@ export declare const READ_SLOW: unique symbol;
  */
 export declare function readNodeFast<T>(el: Signal<T>): T | typeof READ_SLOW;
 export declare function read<T>(el: Signal<T> | Computed<T>): T;
+/**
+ * Store-rewrite setter guard: the rewrite parks writes in a pending backing
+ * (no setSignal at write time), so the owned-scope write protection must
+ * fire at the setter entry instead. Mirrors setSignal's guard condition
+ * minus the node-specific exemptions (ownedWrite/firewall), which don't
+ * apply to plain store setters.
+ */
+export declare function devGuardStoreSetterWrite(): void;
 export declare function setSignal<T>(el: Signal<T> | Computed<T>, v: T | ((prev: T) => T)): T;
 /**
  * Suppresses automatic recomputation of `el` until the scheduler drains. Used