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

package/dist/prod/store/store.js

@@ -138,8 +138,8 @@ 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)) {
-            GlobalQueue.M(e);
+        if (r.o?.t && s.scope.has(t) && (s.key === undefined || s.key === o)) {
+            GlobalQueue.h(e);
             s.inherited.push(e);
         }
     }
@@ -252,18 +252,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.Bt(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.Bt(e);
                         break;
                     }
                     const o = t?.[$TARGET];
@@ -288,11 +288,11 @@ s) {
  *
  * @internal
  */ function getStoreAffectsNodes(e, t) {
-    GlobalQueue.p ||= e => {
+    GlobalQueue.G ||= e => {
         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.j(t.inherited[e]);
     };
     if (t === undefined) {
         const t = nextAffectsNodeResolver(e, $AFFECTS);

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

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

@@ -1,4 +1,5 @@
-import type { Computed, Owner, Signal } from "./types.js";
+import { type Attribution } from "./attribution.js";
+import type { Computed, Link, Owner, Signal } from "./types.js";
 export interface DevHooks {
     onOwner?: (owner: Owner) => void;
     onGraph?: (value: any, owner: Owner | null) => void;
@@ -6,8 +7,12 @@ export interface DevHooks {
     onStoreNodeUpdate?: (state: any, property: PropertyKey, value: any, prev: any) => void;
 }
 export type DiagnosticSeverity = "warn" | "error";
-export type DiagnosticCode = "STRICT_READ_UNTRACKED" | "PENDING_ASYNC_UNTRACKED_READ" | "PENDING_ASYNC_FORBIDDEN_SCOPE" | "REACTIVE_WRITE_IN_OWNED_SCOPE" | "ACTION_CALLED_IN_OWNED_SCOPE" | "RUN_WITH_DISPOSED_OWNER" | "NO_OWNER_CLEANUP" | "CLEANUP_IN_FORBIDDEN_SCOPE" | "SETTLED_CLEANUP_UNOWNED" | "FLUSH_IN_EFFECT_CALLBACK" | "PRIMITIVE_IN_FORBIDDEN_SCOPE" | "NO_OWNER_EFFECT" | "NO_OWNER_BOUNDARY" | "ASYNC_OUTSIDE_LOADING_BOUNDARY" | "INVALID_REFRESH_TARGET" | "INVALID_AFFECTS_TARGET" | "MISSING_EFFECT_FN" | "SYNC_NODE_RECEIVED_ASYNC" | "REACTIVITY_HALTED" | "INVARIANT_VIOLATION";
-export type DiagnosticKind = "strict-read" | "async" | "write" | "lifecycle" | "owner" | "error";
+export type DiagnosticCode = "STRICT_READ_UNTRACKED" | "PENDING_ASYNC_UNTRACKED_READ" | "PENDING_ASYNC_FORBIDDEN_SCOPE" | "REACTIVE_WRITE_IN_OWNED_SCOPE" | "ACTION_CALLED_IN_OWNED_SCOPE" | "RUN_WITH_DISPOSED_OWNER" | "NO_OWNER_CLEANUP" | "CLEANUP_IN_FORBIDDEN_SCOPE" | "SETTLED_CLEANUP_UNOWNED" | "FLUSH_IN_EFFECT_CALLBACK" | "PRIMITIVE_IN_FORBIDDEN_SCOPE" | "NO_OWNER_EFFECT" | "NO_OWNER_BOUNDARY" | "ASYNC_OUTSIDE_LOADING_BOUNDARY" | "INVALID_REFRESH_TARGET" | "INVALID_AFFECTS_TARGET" | "MISSING_EFFECT_FN" | "SYNC_NODE_RECEIVED_ASYNC" | "REACTIVITY_HALTED" | "INVARIANT_VIOLATION" | "HUGE_FAN_OUT" | "HUGE_FAN_IN" | "HOT_SCOPE_RERUNS" | "HOT_SCOPE_TIME" | "WIDE_SCOPE_DEPS" | "UNSTABLE_MEMO_OUTPUT" | "WIDE_WRITE";
+export type DiagnosticKind = "strict-read" | "async" | "write" | "lifecycle" | "owner" | "error" | "perf" | "graph";
+/** First warning when a node's live edge count reaches this size. */
+export declare const GRAPH_SIZE_WARN_AT = 2000;
+/** Repeat the warning at this interval after the first. */
+export declare const GRAPH_SIZE_WARN_EVERY = 500;
 export interface DiagnosticEvent {
     sequence: number;
     code: DiagnosticCode;
@@ -32,6 +37,8 @@ export interface Diagnostics {
 export interface Dev {
     hooks: DevHooks;
     diagnostics: Diagnostics;
+    /** "Why did this run" re-run attribution — see attribution.ts. */
+    attribution: Attribution;
     getChildren: typeof getChildren;
     getSignals: typeof getSignals;
     getParent: typeof getParent;
@@ -62,3 +69,13 @@ export declare function getSignals(owner: Owner): any[];
 export declare function getParent(owner: Owner): Owner | null;
 export declare function getSources(computation: Computed<any>): (Signal<any> | Computed<any>)[];
 export declare function getObservers(node: Signal<any> | Computed<any>): Computed<any>[];
+/**
+ * DEV-only: bump live edge counts after a new graph link and warn when a
+ * node grows an unusually large fan-out (many subscribers on one source) or
+ * fan-in (many sources on one computation). Repeat-reads that `link()`
+ * dedupes never reach here. Always-on in dev — unlike the opt-in attribution
+ * engine, a graph-size pathology should surface without asking.
+ */
+export declare function noteGraphLink(dep: Signal<any> | Computed<any>, sub: Computed<any>): void;
+/** DEV-only: drop live edge counts when a link is removed. */
+export declare function unnoteGraphLink(link: Link): void;

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

@@ -1,5 +1,6 @@
 import type { Computed, Link, Signal } from "./types.js";
 export declare function unlinkSubs(link: Link): Link | null;
 export declare function trimStaleDeps(el: Computed<any>): void;
+export declare function clearDeps(el: Computed<unknown>): void;
 export declare function unobserved(el: Computed<unknown>): void;
 export declare function link(dep: Signal<any> | Computed<any>, sub: Computed<any>, pendingObserver?: boolean): void;

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

@@ -31,26 +31,14 @@ export declare function mergeLanes(lane1: OptimisticLane, lane2: OptimisticLane)
 /**
  * Resolve a node's lane: follow union-find chain, verify active, clear if stale.
  */
-export declare function resolveLane(el: {
-    _optimisticLane?: OptimisticLane;
-}): OptimisticLane | undefined;
-export declare function resolveTransition(el: {
-    _optimisticLane?: OptimisticLane;
-    _transition?: Transition | null;
-    _overrideValue?: any;
-    _overrideOwner?: Transition | null;
-}): Transition | null | undefined;
+export declare function resolveLane(el: Signal<any> | Computed<any>): OptimisticLane | undefined;
+export declare function resolveTransition(el: Signal<any> | Computed<any>): Transition | null | undefined;
 /**
  * Check if a node has an active optimistic override.
  */
-export declare function hasActiveOverride(el: {
-    _overrideValue?: any;
-}): boolean;
+export declare function hasActiveOverride(el: Signal<any> | Computed<any>): boolean;
 /**
  * Assign or merge a lane onto a node. At convergence points (node already has
  * a different active lane), merge unless the node has an active override.
  */
-export declare function assignOrMergeLane(el: {
-    _optimisticLane?: OptimisticLane;
-    _overrideValue?: any;
-}, sourceLane: OptimisticLane): void;
+export declare function assignOrMergeLane(el: Signal<any> | Computed<any>, sourceLane: OptimisticLane): void;

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

@@ -97,6 +97,7 @@ export declare class GlobalQueue extends Queue {
     static _applyReask: ((el: Computed<any>, hadReask: boolean) => boolean) | null;
     static _repollVerdicts: ((el: Computed<any>, snap?: boolean) => void) | null;
     static _witnessAffects: ((node: OptimisticNode) => void) | null;
+    static _wakeSuppressedProbes: ((transition: Transition) => void) | null;
     static _optimisticWrite: (<T>(el: Signal<T> | Computed<T>, v: T | ((prev: T) => T)) => T) | null;
     static _resolveOptimistic: ((nodes: OptimisticNode[]) => void) | null;
     static _transitionBlocked: ((transition: Transition) => boolean) | null;
@@ -114,6 +115,13 @@ export declare class GlobalQueue extends Queue {
     initTransition(transition?: Transition | null): void;
 }
 export declare function queuePendingNode(node: Signal<any>): void;
+export declare let reaskArmed: boolean;
+/** §12d: bumped by every recompute and every new subscriber edge. A node's
+ * staged-rewrite skip is sound only while NOTHING recomputed or linked since
+ * its last notify — a mid-batch pull can clean a marked subscriber, and a
+ * skipped re-write would leave it stale. */
+export declare let notifyEpoch: number;
+export declare function bumpNotifyEpoch(): void;
 export declare function armReaskClear(): void;
 export declare function insertSubs(node: Signal<any> | Computed<any>, optimistic?: boolean): void;
 export declare let storeCommitHook: (() => void) | null;

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

@@ -41,19 +41,19 @@ export interface NodeOptions<T> {
      */
     loadingValue?: T;
 }
-export interface RawSignal<T> {
-    _subs: Link | null;
-    _subsTail: Link | null;
-    _value: T;
-    _snapshotValue?: any;
-    _name?: string;
-    _equals: false | ((a: T, b: T) => boolean);
-    _config: number;
-    _unobserved?: () => void;
-    _time: number;
-    _transition: Transition | null;
-    _pendingValue: T | typeof NOT_PENDING;
-    _overrideValue?: T | typeof NOT_PENDING;
+/**
+ * Cold node extension (stage-3 §12): optional machinery that most nodes
+ * never touch lives one hop away so the CORE node literal stays under V8's
+ * in-object property boundary (~39 fields measured: past it, every literal
+ * allocation spills to an out-of-object backing store and creation cost
+ * roughly quadruples — the create0to1 cliff). Allocated lazily by `ext()`
+ * on first installer write; ONE shape shared by signals and computeds so
+ * `_x` access stays monomorphic. Presence bits on `_config`
+ * (CONFIG_OPTIMISTIC / HAS_COMPANIONS / HAS_LANE / HAS_SNAPSHOT) remain the
+ * hot-path gates — a bit says "consult _x", never the reverse.
+ */
+export interface NodeExtension {
+    _overrideValue: unknown | typeof NOT_PENDING;
     /**
      * The transaction that owns the active override (stamped at optimistic
      * write, cleared at settle). Ownership must live on the node: a lane's
@@ -62,21 +62,66 @@ export interface RawSignal<T> {
      * revert another action's live override. Node-level sibling of the store
      * layer's STORE_OPTIMISTIC_OWNERS stamps (#2899). `null` = ambient write.
      */
-    _overrideOwner?: Transition | null;
-    _optimisticLane?: OptimisticLane;
-    _pendingSignal?: Signal<boolean>;
-    _latestValueComputed?: Computed<T>;
-    _parentSource?: Signal<any> | Computed<any>;
+    _overrideOwner: Transition | null | undefined;
+    _optimisticLane: OptimisticLane | undefined;
+    _pendingSignal: Signal<boolean> | undefined;
+    _latestValueComputed: Computed<any> | undefined;
+    _parentSource: Signal<any> | Computed<any> | undefined;
     /**
      * Live `affects()` marks on this node (refcount). Non-zero is declared
-     * motion: the node — and, via the verdict layer's dep-graph coverage walk,
-     * everything derived from it — reads pending regardless of graph state,
-     * until every declaring transaction settles/reverts and releases its mark.
-     * This count is the mark's ONLY graph state: the dedicated channel stores
-     * nothing downstream and never touches status flags, errors, or pending
-     * sources.
+     * motion — see affects(); the count is the mark's only graph state.
      */
-    _affectsCount?: number;
+    _affectsCount: number;
+    _inFlight: PromiseLike<any> | AsyncIterable<any> | null;
+    _error: unknown;
+    _blocked: boolean | undefined;
+    _pendingSources: Set<Computed<any>> | undefined;
+    _notifyStatus: ((status?: number, error?: any) => void) | undefined;
+    /** Question-scoped re-ask classification of the current pending window
+     * (see the former Computed._x?._reask doc): set by recompute from
+     * REACTIVE_REASK, cleared on landing; meaningless while not pending. */
+    _reask: boolean;
+    _child: FirewallSignal<any> | null;
+    _unobserved: (() => void) | undefined;
+    _snapshotValue: any;
+    /** Zombie staging (staged disposal): a recompute of an owner that HAS
+     * children/disposal parks them here until the flush commits (or a
+     * transition reverts). Childless nodes — the common case — never write
+     * these. */
+    _pendingDisposal: Disposable | Disposable[] | null;
+    _pendingFirstChild: Owner | null;
+    /** #3038: the firewall children that actually carry isPending()/latest()
+     * companions. The post-recompute companion snap iterates THIS set —
+     * O(companions asked for) — never the full `_child` chain (one entry per
+     * materialized leaf). Populated at companion creation; entries live as
+     * long as their companions (which are permanent once created). */
+    _companionChildren: Set<FirewallSignal<any>> | undefined;
+}
+export interface RawSignal<T> {
+    _subs: Link | null;
+    _subsTail: Link | null;
+    /**
+     * DEV-only live subscriber count. Maintained by `link`/`unlinkSubs` for
+     * graph-size diagnostics; undefined in production.
+     */
+    _subCount?: number;
+    _value: T;
+    _name?: string;
+    _equals: false | ((a: T, b: T) => boolean);
+    _config: number;
+    _time: number;
+    /** IN CORE, not the extension (stage-3 §12c): consulted on EVERY write
+     * (setSignal's transition-init check) and on recompute scheduling — the
+     * per-write extension chase measurably taxed propagation chains. */
+    _transition: Transition | null;
+    /** Notify-epoch stamp of the last subscriber walk (§12d). A re-write to an
+     * already-staged node whose stamp still equals the global epoch skips the
+     * whole walk — marking is idempotent, and the epoch bumps on every
+     * recompute and new subscriber edge (either can invalidate the skip). */
+    _notifiedAt: number;
+    _pendingValue: T | typeof NOT_PENDING;
+    /** Cold extension — see NodeExtension. */
+    _x: NodeExtension | null;
 }
 export interface FirewallSignal<T> extends RawSignal<T> {
     _firewall: Computed<any>;
@@ -97,35 +142,33 @@ export interface Owner {
     _firstChild: Owner | null;
     _nextSibling: Owner | null;
     _prevSibling: Owner | null;
-    _pendingDisposal: Disposable | Disposable[] | null;
-    _pendingFirstChild: Owner | null;
+    /** Cold extension — see NodeExtension (owners use the zombie-pair slots). */
+    _x: NodeExtension | null;
 }
 export interface Computed<T> extends RawSignal<T>, Owner {
     _deps: Link | null;
     _depsTail: Link | null;
+    /**
+     * DEV-only live source count. Maintained by `link`/`unlinkSubs` for
+     * graph-size diagnostics; undefined in production.
+     */
+    _depCount?: number;
     /** Recompute-pass counter; bumped when dep revalidation starts. */
     _depGen: number;
     _flags: number;
-    _blocked?: boolean;
-    _pendingSources?: Set<Computed<any>>;
-    _error?: unknown;
     _statusFlags: number;
     _height: number;
     _nextHeap: Computed<any> | undefined;
     _prevHeap: Computed<any>;
     _fn: (prev?: T) => T;
-    _inFlight: PromiseLike<T> | AsyncIterable<T> | null;
-    _child: FirewallSignal<any> | null;
-    _notifyStatus?: (status?: number, error?: any) => void;
     /**
-     * Question-scoped pending classification of the node's CURRENT pending
-     * window: `true` means the in-flight recompute is a re-ask of the same
-     * question (refresh/poll/confirm — no tracked input changed value), so the
-     * shown answer still answers the question and the node reads NOT pending.
-     * Set by `recompute` from `REACTIVE_REASK`, cleared on landing
-     * (`clearStatus`). Meaningless while not STATUS_PENDING.
+     * Clock tick at which REACTIVE_MANUAL_WRITE was last applied
+     * (`suppressComputedRecompute`). Lets `refresh()` distinguish a same-tick
+     * manual write (which wins over the refresh, #2692) from a mask carried
+     * across ticks by a transaction (which an explicit refresh lifts, #3026).
+     * Only meaningful while REACTIVE_MANUAL_WRITE is set.
      */
-    _reask: boolean;
+    _manualWriteTime?: number;
     /**
      * True while a `loadingValue` node's first real answer hasn't landed: the
      * node was born committed (commit #0 = the loading value) and `handleAsync`
@@ -137,7 +180,8 @@ export interface Computed<T> extends RawSignal<T>, Owner {
      * return, sync-resolved promise, first iterator yield, async settle); a
      * real error leaves it set — errors answer reads but don't enter the value
      * lineage, so a retry serves the loading value again. Once cleared, normal
-     * pending/refetch semantics apply forever.
+     * pending/refetch semantics apply forever. (Stays in CORE: written
+     * unconditionally by recompute and every commit.)
      */
     _loading: boolean;
 }

package/dist/types/store/next/projection.d.ts

@@ -1,19 +1,3 @@
-/**
- * Store rewrite — projections (§7/§7b): a projection is a computed store.
- * The derive runs inside a computed whose recompute merges its output into
- * the projection's backing through the adoption channel (replace-mode root:
- * entity changes merge in place, the root proxy is stable for life). Children
- * wrap into the projection's own FAMILY (writes land here, never in a source
- * family), and every family node carries the projection computed as its
- * firewall — reads link the derive's status and lifecycle natively. The §6c
- * status gate in the traps makes an uninitialized async derive's seed
- * unobservable through every read surface.
- *
- * Mirrors the legacy runProjectionComputed shape (shadow runs for open
- * loading windows, handleAsync landings, commit-through-setter) on next
- * primitives; the generic draft write-traps are reused from the legacy
- * module unchanged.
- */
 import { type Computed, type Refreshable } from "../../core/index.js";
 import { type NoFn, type ProjectionOptions, type Store } from "../store.js";
 export declare function createProjectionNext<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): Refreshable<Store<T>>;