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

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

@@ -1,8 +1,10 @@
 import { type OptimisticLane } from "./lanes.js";
+import type { Transition } from "./scheduler.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;
+export declare const ASYNC_STORE_SETTER_MESSAGE: string;
 export declare let tracking: boolean;
 /** @internal verdict-module glue */
 export declare function setPendingCheckActive(v: boolean): void;
@@ -60,6 +62,14 @@ export declare function signal<T>(v: T, options?: NodeOptions<T>, firewall?: Com
 export declare let slotUnobservedHook: (node: Signal<any>) => void;
 /** Install the shared slot-node unobserved handler (store module, once). */
 export declare function setSlotUnobserved(fn: (node: Signal<any>) => void): void;
+/** Release a firewall child the store no longer addresses (unobserved sweep
+ * dropped it from its target's cache): unlink it from the chain so the
+ * projection stops retaining it and its last value. The node keeps its own
+ * `_nextChild` so a walk that is mid-chain on it still terminates. It also
+ * leaves `_companionChildren` (#3503): the companions themselves are
+ * permanent on the node, but the node is unreachable through the store, so
+ * the set would only retain it and its last value. */
+export declare function unlinkFirewallChild(node: Signal<any>): void;
 export declare function slotSignal<T>(v: T, equals: (a: T, b: T) => boolean, host: object, key: PropertyKey, acc: boolean, firewall?: Computed<unknown> | null): Signal<T>;
 export declare function optimisticSignal<T>(v: T, options?: NodeOptions<T>): Signal<T>;
 export declare function optimisticComputed<T>(fn: (prev?: T) => T | PromiseLike<T> | AsyncIterable<T>, options?: NodeOptions<T>): Computed<T>;
@@ -93,6 +103,23 @@ export declare function setStrictRead(v: string | false): string | false;
  * ```
  */
 export declare function untrack<T>(fn: () => T, strictReadLabel?: string | false): T;
+/**
+ * Set while runtime bookkeeping evaluates a user accessor inside another
+ * node's pass (a loading boundary's `on` key, read from `notify` while the
+ * node that went pending is still recomputing). `context` is that node, but
+ * the read is nobody's: the value is compared, never derived from, so the
+ * untracked-pending re-run link (`read`, `!tracking`) must not be recorded on
+ * it — it made the key's source a dependency of an unrelated async memo
+ * (#3528: `isPending(m2)` through a memo in `on()` linked the memo into `m2`,
+ * a cycle that re-derived `m2` on every pending mark and never converged).
+ */
+export declare let spectating: boolean;
+/**
+ * Evaluates `fn` untracked and without recording a dependency for the
+ * untracked-pending re-run rule on the current `context`. For bookkeeping
+ * reads made mid-propagation on behalf of no node — see `spectating`.
+ */
+export declare function spectate<T>(fn: () => T): T;
 /**
  * Bring a computed to a readable state: lazy/disposed nodes are (re)computed;
  * an isPending() probe (`refresh`) additionally pulls the node fully up to
@@ -128,16 +155,177 @@ export declare function notifyAuthoritativeObservers(el: Signal<any> | Computed<
  * the gating bit is only ever set by such a read, so the `!` call sites are
  * safe once every setter installs, #3303). */
 export declare function installAuthoritativeRead(): void;
+/**
+ * Stale-reader term of the value selections below: a render effect reading a
+ * node some OTHER live transaction has staged sees the committed value. The
+ * commit is silent — the staging walk was the notification — so a reader
+ * that linked AFTER that walk (an effect created during the hold, a store
+ * key first read under it) would show the old value past the reveal: record
+ * it for the transaction's commit replay (the `_gatedSubs` contract lanes
+ * already use). An effect the transaction itself computed re-derives at its
+ * commit on its own (parked run, or the contested re-derive, #3322) and is
+ * not recorded — replaying it too would publish the frame twice.
+ *
+ * Flight twin (the pending-branch carve-out): the reader is served the
+ * node's committed, pre-flight value and now observes that flight — A15:
+ * async work observed by a reader settles as one unit with the writes that
+ * asked it — so it joins the transaction's reporters for the node. The
+ * reporter the transaction recorded when the flight started may be gone (a
+ * keyed remount disposed it, #3374); a completion check that found no live
+ * reporter committed the writes ahead of the answer, tearing the new
+ * reader's frame (`Count: 1` beside `Details: 0`). Joins an entry the
+ * transaction already holds; a flight nobody had observed yet has none (the
+ * reader is its first observer — a conditional that just revealed it, #3458)
+ * and is notified up the reader's own queue chain under that transaction,
+ * the one sanctioned registration site (INV-3): a collecting boundary above
+ * the reader consumes it as it would any pending, an unboundaried reader
+ * opens the entry — and the transaction, judged complete on its other
+ * flights, revealed the inputs beside the reader's pre-flight value
+ * otherwise (`Count: 1 | A: 1` beside `B: 0`). A staged signal or a settled
+ * node registers nothing. Every reporter dies with its reader
+ * (reporterBlocksSource: the read linked it as a dep). The node's own entry
+ * is the only one that can matter: a chain's intermediate memo is re-pulled
+ * by the read (updateIfNecessary's retry) and enters the transaction, so the
+ * reader holds through the normal path; a node with its own flight that is
+ * also pending on an upstream re-ask blocks through that flight until it
+ * lands, and its landing re-runs the reader into the normal path.
+ */
+/** The replay half of the stale-of-foreign clause (A15 / A26): a stale reader
+ * served the committed value because `txn` holds what it read re-runs at
+ * txn's commit, when the value it was denied becomes the frame — unless its
+ * own last value already came from that transaction. One registration for
+ * the node path (heldFromStale) and the store's backing paths, which have
+ * no node to carry the hold (heldFromReader, the adoption hold view). */
+export declare function recordStaleReplay(txn: Transition, c: Computed<any>): void;
+/**
+ * The ownership relation (DESIGN-CONSOLIDATION §6, ruled 2026-09-17): is
+ * `hold` part of the running pass's world? A plain reader's world is the
+ * transaction it runs under, through merges. A lane reader's world is its
+ * lane AND the transition that owns the lane — the one asymmetry between a
+ * lane and a separate transaction (a lane sees what lands from its parent as
+ * its own; a separate transaction would wait for the parent to settle) —
+ * see `ownsLane` in lanes.ts, built on this. One relation for the
+ * stale-of-foreign clause (heldFromStale), the lane arm (readsHeldCommitted)
+ * and the store's backing holds (foreignHold); `serve` has no lane arm of
+ * its own, the lane's extra visibility lives here.
+ */
+export declare function ownsHold(hold: Transition): boolean;
+export declare function enterStagedRead(el: Signal<any> | Computed<any> | null, t?: Transition | null | undefined): void;
+/**
+ * Rule 1 (value selection), the full arm: does this reader see a STAGED
+ * node's COMMITTED value? One implementation of the rule the fast paths
+ * (readNodeFast, read's fast block) carry as their trivial ternary and that
+ * every slow site — read's tail, the store's backing selection, the lane and
+ * verdict arms — used to restate by hand (docs/DESIGN-CONSOLIDATION.md, move 3b). In order:
+ * - no reader at all (an untracked read) — the committed frame;
+ * - a reader under an optimistic lane the engine says reads committed
+ *   (laneReadsCommitted: another lane's hold, #3460);
+ * - nothing staged;
+ * - a children-forbidden reader (createTrackedEffect / onSettled: the frame,
+ *   never the graph — A32);
+ * - a stale reader (render effect) of a FOREIGN transaction's staged write —
+ *   committed, no entanglement (heldFromStale registers the replay; a node
+ *   born held has no committed frame to fall back to, `noCommitted`);
+ * - A17 for HELD truth (#3164, CONFIG_HELD_TRUTH): staged confirming truth —
+ *   fold-staged onto an armed family, or entangle-stolen by an awaited
+ *   until() — is masked from ordinary readers until its transaction's
+ *   reveal, the retaining transaction's own speculative recomputes included
+ *   (partial override coverage would otherwise compose override + staged
+ *   truth into a state no timeline contains). Authoritative readers
+ *   (until()'s predicate) and latest() see the staged truth — the tunnel that
+ *   keeps the hold deadlock-free.
+ * False means the reader derives from the staged value and enters its
+ * transaction (enterStagedRead, A29).
+ */
+export declare function readerSeesCommitted(el: Signal<any> | Computed<any>, c: Computed<any> | null, owner: Signal<any> | Computed<any>, noCommitted: boolean): boolean;
+/** A28 — set when a node is staged (queuePendingNode) or a held node rewritten
+ * (stashHeldRewrite) OUTSIDE a flush; cleared when the next flush begins. The
+ * read sites test this one module boolean instead of `globalQueue._running`:
+ * inside a flush it is false and the A28 arm costs nothing; outside, only a
+ * tick with unflushed writes pays the staged-node check. */
+export declare let unflushedStaged: boolean;
+export declare function markUnflushedStaged(): void;
+/** A28 — a write becomes visible at flush. Outside a flush, a node holding an
+ * AMBIENT staged value (no transaction stamp) was written since the last
+ * flush: ambient staging commits at flush end, so nothing else leaves a node
+ * in this state; a stamped value is the flushed held world, which A28 says
+ * latest() serves. Inside a flush the rule does not apply (A28 (4): promoted
+ * within the round). Structural — no marker on the write path. */
+export declare function unflushed(el: Signal<any> | Computed<any>): boolean;
+/** The value an unflushed node serves — the committed value for an ambient
+ * write, the flushed staged value for a rewrite of a held node — or
+ * NOT_PENDING when nothing is unflushed. Exempt: owned-write nodes (A28 (4):
+ * a write issued inside a recompute is promoted at that recompute's end —
+ * boundary and loading machinery, until()'s internals, signals declared for
+ * in-computation writes) and engine companions (the isPending() verdict
+ * signal, the latest() shadow: the system's own writes, made at the source's
+ * write to mirror it, installing eagerly — A28, A8). */
+export declare function unflushedValue(el: Signal<any> | Computed<any>, committed?: any): unknown;
+/** A28 (5): an optimistic write becomes the ACTIVE override at the flush that
+ * carries it. `_overrideTime` is stamped with `clock` at the write and `clock`
+ * advances after every flush, so "this tick, outside a flush" is unflushed. */
+export declare function unflushedOverride(el: Signal<any> | Computed<any>): boolean;
+/** Active optimistic override on an armed node (an armed slot idles at
+ * NOT_PENDING; undefined = unarmed plain node). The writer's own channels —
+ * the draft, `in`/keys inside the setter — compose on this regardless of
+ * flush state. */
+export declare function hasActiveOverride(el: Signal<any> | Computed<any>): boolean;
+/** The override a READER sees: installed, and carried by a flush (A28 (5) —
+ * an optimistic write is a write; until its flush no reader sees it). One
+ * implementation for read()'s override arm, the verdict channels
+ * (latestRead, computePendingState) and the store's selection
+ * (docs/DESIGN-CONSOLIDATION.md, move 3b). */
+export declare function visibleOverride(el: Signal<any> | Computed<any>): boolean;
+/** A derivation served the committed value because of an unflushed write
+ * (A28) must run again in the flush that carries it — the late-linker case
+ * (#3337's reason to defer the walk): it linked after the write walked. */
+export declare function markLateLinker(c: Computed<any>): true;
+/** Companion-bearing nodes written outside a flush (setSignal); the flush
+ * that carries their writes re-syncs their companions (A28). */
+export declare const unflushedCompanions: Array<Signal<any> | Computed<any>>;
+export declare function resyncUnflushedCompanions(): void;
 export declare function readNodeFast<T>(el: Signal<T>): T | typeof READ_SLOW;
 export declare function read<T>(el: Signal<T> | Computed<T>): T;
+/**
+ * Rule 1, the one slow implementation (DESIGN-CONSOLIDATION move 3b, step
+ * 6c): the value a reader `c` (null = untracked, no pass) is served from
+ * `el`, whose committed value is `committed` — the node's own `_value` for
+ * a signal or memo, the BACKING for a store property node (single-home rule,
+ * O6: committed truth lives in the backing and a node's `_value` is never
+ * served for one). Called by read()'s slow tail and by the store's untracked
+ * node path (nodeValue); the fast paths (readNodeFast, read's fast block)
+ * keep their trivial ternary by design (perf, see the doc). Arms, in order:
+ * - the override (A17), routed through the engine for a tracked reader under
+ *   a lane or a supersession (A18), an authoritative reader marked instead;
+ * - the lane entanglement gate (committed, recorded for replay);
+ * - a node born held has nothing for an untracked reader (A19 exception 1);
+ * - an unflushed write serves committed and re-runs the reader in the
+ *   carrying flush (A28);
+ * - readerSeesCommitted, else the staged value and the transaction (A29).
+ */
+export declare function serve(el: Signal<any> | Computed<any>, c: Computed<any> | null, owner: Signal<any> | Computed<any>, committed: unknown): unknown;
 /**
  * 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
+ * fire at the setter entry instead. Exactly setSignal's guard condition
  * minus the node-specific exemptions (ownedWrite/firewall), which don't
- * apply to plain store setters.
+ * apply to plain store setters. Roots are NOT exempt (#3500): a root body is
+ * tree construction — every dev component body, every context Provider, the
+ * top of `render()`, and the whole SSR pass run directly under one — and a
+ * write there re-runs what already read the old value (or on the server,
+ * can't). Same rule as setSignal, which never exempted roots.
  */
 export declare function devGuardStoreSetterWrite(): void;
+/**
+ * Store setter result guard: the callback's return has one meaning — a
+ * replacement root to adopt — and a thenable can never be that. It is the
+ * signature of `setStore(async d => …)` (or a sync arrow whose helper is
+ * async): only the writes before the first `await` were in the transaction;
+ * the rest land on a closed draft and vanish. Setters are synchronous
+ * transactions; async orchestration is `action()`'s job. Store-specific —
+ * a signal may legitimately hold a promise, so its setter has no such rule.
+ */
+export declare function devGuardStoreSetterResult(result: unknown): 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

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

@@ -1,5 +1,6 @@
-import { type Attribution } from "./attribution.js";
-import type { Computed, Link, Owner, Signal } from "./types.js";
+import { type AttributionHooks, type InteractionRef, type OriginRef } from "./attribution-hooks.js";
+import type { ChangeOrigin, RerunEvent } from "./attribution.js";
+import type { Computed, Owner, Signal } from "./types.js";
 export interface DevHooks {
     onOwner?: (owner: Owner) => void;
     onGraph?: (value: any, owner: Owner | null) => void;
@@ -13,13 +14,19 @@ export interface DevHooks {
  * `warn`/`error` as failures unless they opt in to `info`.
  */
 export type DiagnosticSeverity = "info" | "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" | "SETTLE_WALK_UNINITIALIZED_SOURCE" | "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" | "ASYNC_WATERFALL" | "HOT_SCOPE_FANOUT" | "SILENT_HOLD" | "LONG_HOLD" | "EFFECT_WRITES_OWN_SOURCE" | "EFFECT_RELAY_TEAR" | "IMMUTABLE_UPDATE_IN_STORE" | "UNSTABLE_LIST_IDENTITY";
+export type DiagnosticCode = "STRICT_READ_UNTRACKED" | "PENDING_ASYNC_UNTRACKED_READ" | "PENDING_ASYNC_FORBIDDEN_SCOPE" | "REACTIVE_WRITE_IN_OWNED_SCOPE" | "ASYNC_STORE_SETTER" | "ACTION_CALLED_IN_OWNED_SCOPE" | "RUN_WITH_DISPOSED_OWNER" | "NO_OWNER_CLEANUP" | "CLEANUP_IN_FORBIDDEN_SCOPE" | "SETTLED_CLEANUP_UNOWNED" | "SETTLE_WALK_UNINITIALIZED_SOURCE" | "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" | "ASYNC_WATERFALL" | "HOT_SCOPE_FANOUT" | "SILENT_HOLD" | "LONG_HOLD" | "EFFECT_WRITES_OWN_SOURCE" | "EFFECT_RELAY_TEAR" | "IMMUTABLE_UPDATE_IN_STORE" | "UNSTABLE_LIST_IDENTITY" | "SSR_RENDER_ERROR_CONTAINED" | "SSR_SUBTREE_ABANDONED" | "SSR_STREAM_ABANDONED" | "SSR_CLIENT_CONTENT_MASKED" | "LATE_HEADER_WRITE" | "SERVER_FN_ERROR_SANITIZED" | "SSR_ERROR_SANITIZED" | "SERVER_WRITE" | "REVEAL_IN_RENDER_TO_STRING" | "LAZY_ASSET_UNMAPPED" | "PRELOAD_DESCRIPTOR_INVALID" | "HEAD_TAG_INVALID" | "UNRECOGNIZED_INSERT_VALUE" | "BEHAVIOR_CLAIM_DROPPED" | "FRAME_MARKER_CORRUPTED";
 export type DiagnosticKind = "strict-read" | "async" | "write" | "lifecycle" | "owner" | "error" | "perf" | "graph"
 /** Perceived responsiveness: the runtime behaved correctly but the user saw no feedback. */
- | "responsiveness";
-/** First warning when a node's live edge count reaches this size. */
+ | "responsiveness"
+/** Server rendering: boundaries, fragments, the stream, the server-function wire. */
+ | "ssr"
+/** The response head: `<head>` tags, preload descriptors, HTTP headers. */
+ | "head"
+/** The renderer's insert positions, on either platform: a value it has no rendering for. */
+ | "render";
+/** First warning when a change reaches (or a pass tracks) this many edges. */
 export declare const GRAPH_SIZE_WARN_AT = 2000;
-/** Repeat the warning at this interval after the first. */
+/** Re-warn once the count has grown by this much since the last warning. */
 export declare const GRAPH_SIZE_WARN_EVERY = 500;
 export interface DiagnosticEvent {
     sequence: number;
@@ -51,27 +58,218 @@ export interface Diagnostics {
     subscribe(listener: DiagnosticListener): () => void;
     capture(): DiagnosticCapture;
     /**
-     * Registers a console footer appended to the first console report of
-     * each diagnostic code — a discovery pointer to deeper guidance (e.g.
-     * solid-js registers its shipped repair skill). Reported events carry
-     * it as trailing lines of the same console entry; events that surface as
-     * a thrown error instead get it as a follow-up line. Returning undefined
-     * for an event suppresses the footer. Passing undefined unregisters and
-     * resets the once-per-code memory.
+     * Records an event on the channel from outside the reactive core — a host
+     * runtime reporting its own findings (hydration mismatches, server render
+     * faults) so consumers see one stream. `subject` locates it like the
+     * internal sites do; a host whose owners are not signals' owners passes
+     * `ownerPath` on the event instead and it is used as-is.
      */
-    setConsoleFooter(footer: ((event: DiagnosticEvent) => string | undefined) | undefined): void;
+    emit(event: Omit<DiagnosticEvent, "sequence">, subject?: DiagnosticSubject | null): DiagnosticEvent;
+}
+/**
+ * The core's side of attribution: the hook slot an engine installs into, and
+ * the interaction frame the rendering runtime opens around event dispatch.
+ * The engine itself — "why did this run", costs, holds, feedback — is
+ * `@solidjs/signals/attribution`, a separate entry so an observe build pays
+ * for it only when something imports it.
+ */
+export interface AttributionSlot {
+    /**
+     * Installs `hooks` as the engine the core reports facts to (`null`
+     * uninstalls). One engine at a time; the built-in engine's `enable()` calls
+     * this, and an external consumer (devtools) may install its own instead.
+     */
+    install(hooks: AttributionHooks | null): void;
+    /** The installed engine's hooks, or `null` when none is installed. */
+    readonly installed: AttributionHooks | null;
+    /**
+     * Run `fn` as a user interaction's handler: root writes inside stamp it as
+     * their origin, and actions/effects/flights it causes carry it. The web
+     * runtime wraps every event dispatch in this; custom renderers and test
+     * harnesses call it themselves. `fn()` when no engine is installed.
+     */
+    withInteraction<T>(ref: InteractionRef, fn: () => T): T;
+    /**
+     * Run `fn` as a declared unit of work — a router's navigation, described
+     * by the parametrized route it matched: root writes inside are attributed
+     * to it (under the enclosing interaction, if any), so the hold behind the
+     * route's data, the re-runs and the verdicts carry the route's name. Any
+     * router calls this around its location write; nothing else is
+     * router-specific. `fn()` when no engine is installed.
+     */
+    withOrigin<T>(ref: OriginRef, fn: () => T): T;
+    /**
+     * The provenance a root write performed now would be stamped with — the
+     * interaction whose handler is running, the navigation or effect or action
+     * frame open, or inside a recompute the origin of the change that caused
+     * it — as the installed engine sees it; `undefined` with no engine, or when
+     * nothing is in effect (external). For a runtime recording a fact of its
+     * own beside the engine's records: `@solidjs/web` stamps its `"call"`
+     * record with this, so a server-function call joins the interaction or
+     * navigation it ran for by the identity of the object, not by time.
+     */
+    currentOrigin(): ChangeOrigin | undefined;
+}
+/**
+ * The records the runtimes deliver on `OBSERVE.records`, by type — each
+ * entry `{ event, live }`: the serializable record and the live handles
+ * (a thrown error, a request) an in-process consumer may want beside it.
+ * The core emits none and declares none; the runtimes that emit declare
+ * theirs by augmentation, and the union of record types is whatever the
+ * loaded runtimes declared. `solid-js` augments THIS interface (its
+ * `"boundary"` record); the runtimes above it — `@solidjs/web`'s
+ * `"invocation"`, `"frame"` and `"call"`, a router's — augment
+ * `HostRecordTypes`, reached through the `solid-js` re-export, which this
+ * interface extends so the channel sees one catalogue.
+ *
+ * Two interfaces, one augmenter each, by design: TypeScript merges an
+ * augmentation into a re-exported interface by following the alias, and
+ * two augmentations reaching the same interface through DIFFERENT aliases
+ * (`"@solidjs/signals"` from solid-js, `"solid-js"` from web) merge
+ * order-dependently — one set is lost. So each layer augments an interface
+ * of its own, through one module name.
+ */
+export interface RecordTypes extends HostRecordTypes {
+}
+/** The record types host runtimes declare — see `RecordTypes`. */
+export interface HostRecordTypes {
+}
+export type RecordType = keyof RecordTypes & string;
+export type RecordEvent<K extends RecordType> = RecordTypes[K] extends {
+    event: infer E;
+} ? E : never;
+export type RecordLive<K extends RecordType> = RecordTypes[K] extends {
+    live: infer L;
+} ? L : never;
+export type RecordListener<K extends RecordType> = (event: RecordEvent<K>, live: RecordLive<K>) => void;
+/**
+ * The records channel — `OBSERVE.records`, on either platform: one place a
+ * consumer (an APM adapter's `init()`, devtools, the diagnostics harness)
+ * subscribes to the completed, serializable summaries of the things the
+ * runtimes did — a `<Loading>` boundary that waited on the server, a
+ * server-function execution or call, a frame stream produced or applied —
+ * each delivered synchronously the moment it is complete, with its live
+ * handles passed BESIDE it. Any number of listeners; none can alter what it
+ * observes; one that throws is reported and the rest run. (Reactive
+ * attribution — re-runs, holds, interactions — is the attribution engine's
+ * `subscribe`, a separate entry the observe build pays for only when
+ * imported.)
+ *
+ * The object is created once per PROCESS under a registered symbol, so a
+ * subscription made before the emitting runtime has loaded, or from a
+ * second bundled copy of the core, reaches the same listener set. Absent in
+ * prod with the rest of `OBSERVE`.
+ */
+export interface Records {
+    /** Deliver `type` records as they complete; returns the unsubscribe. */
+    subscribe<K extends RecordType>(type: K, listener: RecordListener<K>): () => void;
+    /**
+     * Whether anything is subscribed to `type` — an emitter's pre-check, so
+     * a record nobody will hear costs nothing to not build (no clock read).
+     */
+    observed(type: RecordType): boolean;
+    /**
+     * Delivers a completed record to `type`'s listeners, synchronously: how a
+     * runtime publishes. Snapshot iteration — a listener unsubscribing
+     * mid-delivery neither skips nor double-calls anyone this round.
+     */
+    emit<K extends RecordType>(type: K, event: RecordEvent<K>, live: RecordLive<K>): void;
+}
+/**
+ * The server runtime's observe surface — where a server-side consumer
+ * installs what only the server has: the trace-context provider slot.
+ * Declared EMPTY here and typed by the runtime that owns the surface:
+ * `solid-js`'s server entry augments this interface with `trace:
+ * ServerTrace`, an interface of its own that `@solidjs/web`'s server
+ * entries fill in (`provide`) — so the core never learns that shape and
+ * the consumer still finds it on the one `OBSERVE`. One augmenter per
+ * interface: see `RecordTypes` for why.
+ *
+ * The OBJECT behind it is not the core's either: the core has one artifact
+ * per tier for both platforms, and the client would carry it for nothing.
+ * `solid-js`'s server entry replaces this empty literal with the
+ * process-wide slot the moment it evaluates (see `serverSlots` in
+ * solid-js/src/server/observe.ts), so a consumer that imports only
+ * `solid-js` can provide before the web runtime that reads it has loaded,
+ * and from a second copy when a host bundles one. On the client this stays
+ * `{}`.
+ */
+export interface ServerObserve {
 }
+/**
+ * The observe tier: the structured channel and the attribution wiring —
+ * everything a production observability consumer needs, and nothing that
+ * assumes a developer at a console. Present in dev and observe builds
+ * (`__OBSERVE__`); `undefined` in prod.
+ */
+export interface Observe {
+    diagnostics: Diagnostics;
+    /** Completed records from the runtimes, by type — see `Records`. */
+    records: Records;
+    /** The attribution hook slot and interaction frame — see `AttributionSlot`. */
+    attribution: AttributionSlot;
+    /** The server runtime's surface — see `ServerObserve`. */
+    server: ServerObserve;
+    /**
+     * The live node an emitted record was about, when the emitter knew it.
+     * Records are serializable and never carry the node — a diagnostic event
+     * names its subject by `ownerPath`/`nodeName`, a re-run record by
+     * `nodeId` — so consumers that run in-process (devtools, the console
+     * reporter, `attribution.subscriptions(OBSERVE.subjectOf(run))`) look the
+     * node up here. Answers for `DiagnosticEvent`s and the attribution
+     * engine's `RerunEvent`s; `undefined` for anything else, and for a record
+     * that has left the process and come back.
+     */
+    subjectOf(record: DiagnosticEvent | RerunEvent): DiagnosticSubject | undefined;
+    /**
+     * Marks `owner`'s subtree as the observer's own. A consumer that renders
+     * inside the app it watches — an APM adapter's panel, devtools — would
+     * otherwise see its own effects, stores and holds reported as findings about
+     * the app. Under an excluded owner: diagnostics whose subject sits in the
+     * subtree are neither delivered nor reported (the entry is still built, so
+     * a site that throws its message still throws), and the attribution engine
+     * records no runs for its computations. Mark the root as it is created
+     * (`createRoot(() => { OBSERVE.exclude(getOwner()!); … })`); the signals
+     * and stores created under it are excluded subjects wherever their writes
+     * come from (a click handler, an adapter callback), so writes need no
+     * `runWithOwner` — and must not use one: a write under an owner is a write
+     * in an owned scope (REACTIVE_WRITE_IN_OWNED_SCOPE). Irrevocable for the
+     * owner's lifetime.
+     */
+    exclude(owner: Owner): void;
+    /** Whether `subject` sits under an excluded owner (itself included). */
+    isExcluded(subject: DiagnosticSubject | null | undefined): boolean;
+}
+/**
+ * The dev tier: devtools hooks, graph traversal, and the console face of the
+ * diagnostics channel. Present only in dev builds (`__DEV__`).
+ */
 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;
     getSources: typeof getSources;
     getObservers: typeof getObservers;
+    /** Console face of an emitted event — see `reportDiagnostic`. */
+    report(entry: DiagnosticEvent): void;
+    /**
+     * Registers a console footer appended to the first console report of
+     * each diagnostic code — a discovery pointer to deeper guidance (e.g.
+     * solid-js registers its shipped repair skill). Reported events carry
+     * it as trailing lines of the same console entry; events that surface as
+     * a thrown error instead get it as a follow-up line. Returning undefined
+     * for an event suppresses the footer. Passing undefined unregisters and
+     * resets the once-per-code memory.
+     */
+    setConsoleFooter(footer: ((event: DiagnosticEvent) => string | undefined) | undefined): void;
 }
+export declare const OBSERVE: Observe;
+export declare function isExcluded(subject: DiagnosticSubject | null | undefined): boolean;
+/** For engines that cache the verdict per node: is anything excluded at all? */
+export declare function anyExcluded(): boolean;
+/** Was `entry` built for an excluded subject? Once-per-key reporters must not spend their slot on it. */
+export declare function isSuppressed(entry: DiagnosticEvent): boolean;
 export declare const DEV: Dev;
 /**
  * Dev-mode internal consistency check. A failure means the reactive system
@@ -96,9 +294,15 @@ export declare function ownerPath(subject: DiagnosticSubject | null | undefined)
  * default (right for the synchronous rule checks — they fire inside the
  * scope that misbehaved); pass the node for scheduler-time findings whose
  * ambient context is the flush, or `null` for events that have no location
- * by nature. Console output is a separate step — see `reportDiagnostic`.
+ * by nature. An `ownerPath` already on the event wins over the subject walk
+ * (hosts whose owners are not signals' owners compute their own). Console
+ * output is a separate, dev-tier step — see `reportDiagnostic`.
  */
-export declare function emitDiagnostic(event: Omit<DiagnosticEvent, "sequence" | "ownerPath">, subject?: DiagnosticSubject | null | undefined): DiagnosticEvent;
+export declare function emitDiagnostic(event: Omit<DiagnosticEvent, "sequence">, subject?: DiagnosticSubject | null | undefined): DiagnosticEvent;
+/** Register `subject` as what `record` was about — see `Observe.subjectOf`. */
+export declare function recordSubject(record: object, subject: DiagnosticSubject): void;
+/** The live subject `record` was about, if its emitter registered one. */
+export declare function subjectOf(record: object): DiagnosticSubject | undefined;
 /**
  * The console face of a diagnostic — ONE entry per finding: the message, the
  * owner path (`in <App> › <TodoRow> › effect`) so a human can locate it, the
@@ -107,7 +311,9 @@ export declare function emitDiagnostic(event: Omit<DiagnosticEvent, "sequence" |
  * second console argument (hover highlights it, click jumps to Elements).
  * Severity picks the console method. Call sites report the entry
  * `emitDiagnostic` returned so the structured and console channels never
- * disagree.
+ * disagree. Dev-tier: in an observe build this is a no-op, so wiring paths
+ * that both emit and report (graph-size warnings) reach the channel only —
+ * production observability never writes to the console.
  */
 export declare function reportDiagnostic(entry: DiagnosticEvent): void;
 /**
@@ -117,6 +323,11 @@ export declare function reportDiagnostic(entry: DiagnosticEvent): void;
  */
 export declare function throwPendingUntrackedRead(strictReadLabel: string, fields?: Partial<Omit<DiagnosticEvent, "sequence" | "data" | "ownerPath">>): never;
 export declare function warnStrictReadUntracked(strictReadLabel: string, fields?: Partial<Omit<DiagnosticEvent, "sequence" | "ownerPath">>): void;
+/**
+ * Observe-tier: stamp a signal with its creating owner so `ownerPath` can
+ * locate signal subjects. The per-owner `_signals` list and the devtools
+ * `onGraph` hook are dev-tier — the observe build pays one property write.
+ */
 export declare function registerGraph(value: any, owner: Owner | null): void;
 export declare function clearSignals(node: Owner): void;
 export declare function getChildren(owner: Owner): Owner[];
@@ -125,12 +336,19 @@ 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.
+ * Observe-tier: a committed change on `node` is about to re-run `count`
+ * subscribers (the notify walk in `insertSubs` counted them as it went —
+ * fan-out costs exactly one local increment in a loop that already visits
+ * every edge, and nothing at link time). Fires from GRAPH_SIZE_WARN_AT up,
+ * on the write rather than the link: a fan-out that is never written costs
+ * nothing, and one that is re-runs every subscriber this flush. Always-on
+ * wherever the channel exists — unlike the opt-in attribution engine, a
+ * graph-size pathology should surface without asking.
+ */
+export declare function noteFanOut(node: Signal<any> | Computed<any>, count: number): void;
+/**
+ * Observe-tier: a recompute pass of `node` tracked `count` distinct sources
+ * (its trimmed dep list, walked once at the end of the pass — see recompute;
+ * no per-link work, no pass bracket). Fires from GRAPH_SIZE_WARN_AT up.
  */
-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;
+export declare function noteFanIn(node: Computed<any>, count: number): void;

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

@@ -1,3 +1,4 @@
+import { type Transition } from "./scheduler.js";
 import type { Computed, NodeOptions, Owner } from "./types.js";
 export interface Effect<T> extends Computed<T>, Owner {
     _effectFn: (val: T, prev: T | undefined) => void | (() => void);
@@ -5,7 +6,13 @@ export interface Effect<T> extends Computed<T>, Owner {
     _modified: boolean;
     _prevValue: T | undefined;
     _type: number;
-    _boundRunEffect?: () => void;
+    _boundRunEffect?: (type: number) => void;
+    /** The transaction whose staged view produced `_value` (null = committed
+     * view). Effects have one value slot and do not entangle transactions, so
+     * a second transaction recomputing the same effect overwrites a value the
+     * first one still owes a run for; see the contested-effect arm of recompute
+     * (#3322). */
+    _valueTransition: Transition | null;
 }
 /**
  * Effects are the leaf nodes of our reactive graph. When their sources change, they are