@solidjs/signals 2.0.0-rc.6 → 2.0.0-rc.8

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

@@ -1,5 +1,5 @@
-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 { Computed, Owner, Signal } from "./types.js";
 export interface DevHooks {
     onOwner?: (owner: Owner) => void;
     onGraph?: (value: any, owner: Owner | null) => void;
@@ -13,11 +13,13 @@ 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";
-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 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 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 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;
@@ -28,6 +30,15 @@ export interface DiagnosticEvent {
     ownerId?: string;
     ownerName?: string;
     nodeName?: string;
+    /**
+     * Root-first chain of named owners enclosing the subject of the event —
+     * component roots as `<Name>`, computations by their `name` option (or
+     * the `effect`/`computed` default) — e.g. `["<App>", "<TodoRow>", "effect"]`.
+     * Unnamed owners (plain roots) are skipped. Absent when the subject has no
+     * named owner at all (a top-level scope, or an unowned primitive — which
+     * is usually the finding itself).
+     */
+    ownerPath?: string[];
     data?: Record<string, unknown>;
 }
 export type DiagnosticListener = (event: DiagnosticEvent) => void;
@@ -40,25 +51,109 @@ export interface Diagnostics {
     subscribe(listener: DiagnosticListener): () => void;
     capture(): DiagnosticCapture;
     /**
-     * Registers a console footer printed after the first console report of
-     * each diagnostic code — a discovery pointer to deeper guidance (e.g.
-     * solid-js registers its shipped repair skill). 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 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;
+    /** The attribution hook slot and interaction frame — see `AttributionSlot`. */
+    attribution: AttributionSlot;
+    /**
+     * The live node an emitted event was about, when the emitter knew it.
+     * Events are serializable records and never carry the node; consumers that
+     * run in-process (devtools, the console reporter) look it up here.
+     */
+    subjectOf(event: DiagnosticEvent): 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()!); … })`) and perform
+     * writes from outside the graph under it (`runWithOwner`), so the writer's
+     * context is excluded too. 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
@@ -68,14 +163,51 @@ export declare const DEV: Dev;
  * dev builds so user apps degrade instead of crashing.
  */
 export declare function assertInvariant(condition: boolean, name: string, message: string): void;
-export declare function emitDiagnostic(event: Omit<DiagnosticEvent, "sequence">): DiagnosticEvent;
+/** Anything a diagnostic can be about: an owner (root, computed, effect) or a signal. */
+export type DiagnosticSubject = Owner | Signal<any> | Computed<any>;
+/**
+ * Root-first names of the owners enclosing `subject` (inclusive when the
+ * subject is itself a named owner). Signals hop to their registering owner
+ * (`_owner`, set by registerGraph). Unnamed owners are skipped so the path
+ * reads as the component tree plus the scope: `<App> › <TodoRow> › effect`.
+ */
+export declare function ownerPath(subject: DiagnosticSubject | null | undefined): string[] | undefined;
+/**
+ * Records a diagnostic on the structured channel (listeners, captures) and
+ * returns the entry. `subject` locates it: the current reactive `context` by
+ * 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. 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">, subject?: DiagnosticSubject | null | undefined): DiagnosticEvent;
+/**
+ * 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
+ * once-per-code footer as trailing lines, and — when the subject is a
+ * binding effect the rendering runtime tagged — the element it writes, as a
+ * 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. 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;
 /**
  * Shared strict-read diagnostics for core read() and the store proxy traps.
  * Single source for the message text — the #2897 safeguard parity between
  * memos and stores is exactly these firing identically from both paths.
  */
-export declare function throwPendingUntrackedRead(strictReadLabel: string, fields?: Partial<Omit<DiagnosticEvent, "sequence" | "data">>): never;
-export declare function warnStrictReadUntracked(strictReadLabel: string, fields?: Partial<Omit<DiagnosticEvent, "sequence">>): 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[];
@@ -84,12 +216,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

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

@@ -2,9 +2,11 @@ import type { Computed } from "./types.js";
 /** The queue a node belongs to, picked from its own zombie flag. */
 export declare function queueFor(n: Computed<any>): Heap;
 /**
- * Schedule one subscriber to re-run on the next flush: tracked effects bypass
- * the heap and go directly to their effect queue; everything else is inserted
- * into its own (zombie-flag-routed) heap with the `_min` cursor pulled down.
+ * Schedule one subscriber to re-run on the next flush: inserted into its own
+ * (zombie-flag-routed) heap with the `_min` cursor pulled down. Tracked
+ * effects ride the heap too — the heap visit is their (empty) compute phase,
+ * which hands the callback to the user queue once the pass has committed
+ * (see GlobalQueue._update, #3291).
  */
 export declare function enqueueSub(node: Computed<any>): void;
 export interface Heap {

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

@@ -9,5 +9,6 @@ export type { Computed, Disposable, FirewallSignal, Link, Owner, Root, Signal, N
 export { effect, trackedEffect, type Effect, type TrackedEffect } from "./effect.js";
 export { action } from "./action.js";
 export { flush, Queue, GlobalQueue, enforceLoadingBoundary, resetErrorHalt, type IQueue, type QueueCallback } from "./scheduler.js";
-export { DEV, type Dev, type DevHooks, type DiagnosticCapture, type DiagnosticCode, type DiagnosticEvent, type DiagnosticKind, type Diagnostics, type DiagnosticSeverity } from "./dev.js";
+export type { AttributionHooks, InteractionRef, NavigationRef, OriginRef } from "./attribution-hooks.js";
+export { DEV, OBSERVE, type AttributionSlot, type Dev, type Observe, type DevHooks, type DiagnosticCapture, type DiagnosticCode, type DiagnosticEvent, type DiagnosticKind, type DiagnosticListener, type Diagnostics, type DiagnosticSeverity, type DiagnosticSubject } from "./dev.js";
 export * from "./constants.js";

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

@@ -2,7 +2,7 @@ import type { OptimisticLane } from "./lanes.js";
 import type { Computed, Signal } from "./types.js";
 /**
  * Test-mode invariant checks for the async/transition/lane machinery.
- * Catalog and rationale: packages/signals/INTERNALS-ASYNC-STATE.md.
+ * Catalog and rationale: packages/signals/docs/INTERNALS-ASYNC-STATE.md.
  *
  * These are implementation self-consistency checks, not semantic rules: a
  * violation means the reactive system contradicted itself.

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

@@ -24,6 +24,23 @@ export declare function getOrCreateLane(signal: Signal<any>): OptimisticLane;
  * Union-find: find the root lane.
  */
 export declare function findLane(lane: OptimisticLane): OptimisticLane;
+/**
+ * Is the lane held? `_pendingAsync` records the async the lane OWNS (derived
+ * under it); a transaction's reporter map records the async a render effect
+ * OBSERVED pending with no boundary taking it (INV-3, the one registration
+ * site). A hold needs both — the same rule the transaction itself uses, so a
+ * memo nobody renders, or one a fallback-showing boundary caught, cannot tear
+ * a frame and holds nothing (#3289). An orphan lane has no observation record
+ * and never holds.
+ *
+ * The observation is looked up per NODE, in whichever live transaction
+ * recorded it — not in this lane's transaction. Lanes merge across
+ * transactions (#2912: ownership never travels through lanes), so after a
+ * merge the root's transaction holds the observations of only one member;
+ * the async the other member's transaction observed must hold the merged
+ * reveal just the same (A15 for lanes, #3335).
+ */
+export declare function laneHeld(lane: OptimisticLane): boolean;
 /**
  * Merge two lanes when their dependency graphs overlap.
  */

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

@@ -8,8 +8,17 @@ export declare const zombieQueue: Heap;
 export declare let clock: number;
 export declare let activeTransition: Transition | null;
 export declare let projectionWriteActive: boolean;
+/** > 0 while an action's generator body is on the stack (the synchronous
+ * slice between yields). Maintained by action.ts around `it.next()`. */
+export declare let actionStepDepth: number;
+export declare function enterActionStep(): void;
+export declare function exitActionStep(): void;
 export declare let _hitUnhandledAsync: boolean;
-export declare function resetUnhandledAsync(): void;
+/**
+ * Consume the unhandled-async hit. Returns whether this is the first report
+ * of the current enforcement window — the caller warns only then.
+ */
+export declare function resetUnhandledAsync(): boolean;
 /**
  * Toggles the dev-mode "must be inside a `<Loading>` boundary" enforcement
  * window. Only `render()` calls this — wrapping the initial mount so that a
@@ -39,6 +48,11 @@ export interface Transition {
     _queueStash: QueueStub;
     _done: boolean | Transition;
     _gatedSubs: Set<Computed<any>>;
+    /** Effects whose single value slot was written under this transaction AND
+     * another live one (#3322). Re-dirtied at commit, ahead of the effect
+     * phase, so the run publishes a value derived from the committed world
+     * rather than whichever transaction's staged view wrote last. */
+    _contested: Computed<any>[] | null;
 }
 /**
  * Flip-entanglement (#3164 follow-up): `until()` is a declaration of
@@ -127,14 +141,40 @@ export declare class GlobalQueue extends Queue {
     static _drainPatchOptimistic: (() => void) | null;
     static _gatedRead: ((el: Signal<any>, owner: OptimisticNode, c: Computed<any>) => boolean) | null;
     static _laneSuspends: ((owner: OptimisticNode) => boolean) | null;
+    /** Is the node routed through a LIVE lane (`resolveLane`)? read()'s reveal
+     * carve-out asks before showing a foreign-held pending node's committed
+     * value: a lane-derived flight's inputs are already revealed through the
+     * lane (#3334). Gated on CONFIG_HAS_LANE, which only the engine sets. */
+    static _laneLive: ((el: Computed<any>) => boolean) | null;
     static _laneReadsCommitted: ((el: OptimisticNode, owner: OptimisticNode, c: Computed<any>) => boolean) | null;
     static _recomputeLane: ((el: Computed<any>, own: boolean) => OptimisticLane | null | false) | null;
     static _laneAsyncPending: ((el: Computed<any>) => void) | null;
-    /** Authoritative-view reader wakeup (until()): installed at first until() call.
-     * Call sites are gated by CONFIG_AUTHORITATIVE_OBSERVED, which only until()'s
-     * carve-out read can set, so `!` invocations are safe once the gate holds. */
+    /** Authoritative-view reader wakeup: installed by until() and refresh() before
+     * their first read. Call sites are gated by CONFIG_AUTHORITATIVE_OBSERVED, which
+     * only such a reader's carve-out read can set, so `!` invocations are safe once
+     * the gate holds (#3303). */
     static _notifyAuthoritativeObservers: ((el: Signal<any> | Computed<any>) => void) | null;
     static _laneAsyncSettled: ((el: Computed<any>) => void) | null;
+    /** A18 supersession (#3331): own-source truth `value` landed under an active
+     * override. The engine decides whether the graph re-derives — the value
+     * differs from the override and is not a stale (older-action) answer (mark
+     * the node, demote its lane cascade, notify), or returns to it after an
+     * earlier differing arrival (clear the mark, notify) — and owns the
+     * authoritative-observer wake for a silent confirm. Installed with the
+     * optimistic engine; only reachable on a node that has an override. */
+    static _supersedeOverride: ((el: Signal<any> | Computed<any>, value: unknown) => void) | null;
+    /** read()'s value for a TRACKED reader of a superseded node (#3331): the
+     * staged truth, unless the reader is a stale (render) reader of another
+     * transaction — then the displayed override, as it keeps a foreign
+     * transaction's committed value over its staged write. */
+    static _supersededRead: ((el: Signal<any> | Computed<any>) => unknown) | null;
+    /** setSignal's authoritative (projection-write) landing on an override-
+     * covered node (#3331 store twin): stage the truth for its transaction's
+     * commit whatever its relation to the committed value — a landing equal to
+     * committed still differs from the override — then _supersedeOverride
+     * decides. Installed with the optimistic engine; only reachable on a node
+     * that has an override. */
+    static _landOnOverride: (<T>(el: Signal<T> | Computed<T>, v: T | ((prev: T) => T)) => T) | null;
     static _trackOptimisticStore: ((store: any) => void) | null;
     flush(): void;
     notify(node: Computed<any>, mask: number, flags: number, error?: any): boolean;
@@ -149,6 +189,21 @@ export declare let reaskArmed: boolean;
 export declare let notifyEpoch: number;
 export declare function bumpNotifyEpoch(): void;
 export declare function armReaskClear(): void;
+/** Provenance of the work currently running (A18 supersession, #3331): the
+ * invocation sequence of the action whose ambient window this is — set by
+ * action() for each slice; the flush that ends the window clears it — or,
+ * inside an async landing, the sequence captured when that flight was
+ * registered (asyncWrite sets it for the landing's synchronous propagation,
+ * so a sync recompute downstream of the landing — an optimistic wrapper over
+ * the async source — derives under the flight's provenance, and flights it
+ * registers inherit it). 0 is mainline: no action, always the current
+ * question. An override stamps this at its write (`_overrideStamp`); an
+ * answer whose flight an OLDER action issued is a stale question the user
+ * has since changed — it holds silently to commit instead of superseding. A
+ * slow source must not leak back in over a newer intent. Transactions merge,
+ * so the transition object cannot say WHICH action asked; this can. */
+export declare let origin: number;
+export declare function setOrigin(seq: number): number;
 export declare function insertSubs(node: Signal<any> | Computed<any>, optimistic?: boolean): void;
 export declare let storeCommitHook: (() => void) | null;
 export declare function setStoreCommitHook(fn: () => void): void;
@@ -215,6 +270,16 @@ export declare function flush<T>(fn: () => T): T;
  * initTransition; it is a plain batch until then. */
 export declare function createTransition(): Transition;
 export declare function currentTransition(transition: Transition): Transition;
+/**
+ * The live transition blocked on `source` — the one whose render reader
+ * observed it pending (INV-3 records the observation in whichever transaction
+ * was active when the reader was notified). The observation is a fact about
+ * the node, so a hold check must not assume it was recorded in the transaction
+ * it happens to hold — lanes merge across transactions (#2912), and a merged
+ * root's transaction knows nothing of the async its members' transactions
+ * observed (#3335). Null when nobody is waiting.
+ */
+export declare function waitingTransition(source: Computed<any>): Transition | null;
 export declare function setActiveTransition(transition: Transition | null): void;
 export declare function runInTransition<T>(transition: Transition, fn: () => T): T;
 /** Run `fn` with `transition` as BOTH the ambient transaction and the

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

@@ -68,6 +68,16 @@ export interface NodeExtension {
      * layer's STORE_OPTIMISTIC_OWNERS stamps (#2899). `null` = ambient write.
      */
     _overrideOwner: Transition | null | undefined;
+    /** `clock` at the active override's write. A sync recompute in the same
+     * tick derives from inputs that predate the override and does not
+     * supersede it (A18 supersession ordering, #3331). */
+    _overrideTime: number;
+    /** Provenance of the active override's write: the scheduler's `origin` (the
+     * asking action's invocation sequence; 0 = mainline). An arriving answer
+     * whose flight an older action issued asked a question the override has
+     * since changed: it holds to commit instead of superseding (A18
+     * supersession provenance, #3331). */
+    _overrideStamp: number;
     _optimisticLane: OptimisticLane | undefined;
     _pendingSignal: Signal<boolean> | undefined;
     _latestValueComputed: Computed<any> | undefined;
@@ -112,13 +122,19 @@ export interface NodeExtension {
 export interface RawSignal<T> {
     _subs: Link | null;
     _subsTail: Link | null;
+    _value: T;
     /**
-     * DEV-only live subscriber count. Maintained by `link`/`unlinkSubs` for
-     * graph-size diagnostics; undefined in production.
+     * Observe-tier label (`name` option, or the node kind: `signal`,
+     * `computed`, `effect`…). A slot in the observe/dev literals — never a
+     * post-construction write — and absent from the prod literals entirely.
      */
-    _subCount?: number;
-    _value: T;
     _name?: string;
+    /**
+     * Observe-tier: the owner in scope when a user-facing signal was created
+     * (`registerGraph`), so diagnostics about the signal get an owner path.
+     * A slot in the observe/dev `signal()` literal; absent from prod.
+     */
+    _owner?: Owner | null;
     _equals: false | ((a: T, b: T) => boolean);
     _config: number;
     _time: number;
@@ -137,7 +153,10 @@ export interface RawSignal<T> {
 }
 export interface FirewallSignal<T> extends RawSignal<T> {
     _firewall: Computed<any>;
+    /** Doubly-linked child chain on the firewall's extension (`_x._child` is
+     * the head): released leaves unlink in O(1) (#3351). */
     _nextChild: FirewallSignal<unknown> | null;
+    _prevChild: FirewallSignal<unknown> | null;
 }
 export type Signal<T> = RawSignal<T> | FirewallSignal<T>;
 export interface Owner {
@@ -156,15 +175,16 @@ export interface Owner {
     _prevSibling: Owner | null;
     /** Cold extension — see NodeExtension (owners use the zombie-pair slots). */
     _x: NodeExtension | null;
+    /**
+     * Observe-tier label: the `name` option, the node kind (`computed`,
+     * `effect`…), or the component label the rendering layer writes on a root
+     * (`<App>`). A slot in the observe/dev literals; absent from prod.
+     */
+    _name?: string;
 }
 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;

package/dist/types/index.d.ts

@@ -1,7 +1,14 @@
 export { $REFRESH, ContextNotFoundError, NoOwnerError, NotReadyError, TimeoutError, action, createContext, createOwner, createRoot, runWithOwner, flush, getNextChildId, peekNextChildId, getContext, setContext, getOwner, isDisposed, getObserver, isEqual, untrack, isPending, latest, SUPPORTS_PROXY, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots, enforceLoadingBoundary, enableExternalSource, resetErrorHalt } from "./core/index.js";
-import { type Dev } from "./core/index.js";
+import { type Dev, type Observe } from "./core/index.js";
+/**
+ * Observe tier (diagnostics channel, attribution hook slot + interaction
+ * frame): dev and observe builds. The attribution engine itself is the
+ * `@solidjs/signals/attribution` entry.
+ */
+export declare const OBSERVE: Observe | undefined;
+/** Dev tier (devtools hooks, graph traversal, console reporting): dev builds only. */
 export declare const DEV: Dev | undefined;
-export type { Owner, Context, ContextRecord, IQueue, ExternalSourceFactory, ExternalSource, ExternalSourceConfig, Refreshable, Dev, DevHooks, DiagnosticCapture, DiagnosticCode, DiagnosticEvent, DiagnosticKind, Diagnostics, DiagnosticSeverity } from "./core/index.js";
+export type { Owner, Context, ContextRecord, IQueue, ExternalSourceFactory, ExternalSource, ExternalSourceConfig, Refreshable, AttributionHooks, AttributionSlot, InteractionRef, NavigationRef, OriginRef, Dev, Observe, DevHooks, DiagnosticCapture, DiagnosticCode, DiagnosticEvent, DiagnosticKind, DiagnosticListener, Diagnostics, DiagnosticSeverity, DiagnosticSubject } from "./core/index.js";
 export { createSignal, createMemo, createEffect, createRenderEffect, createTrackedEffect, createReaction, createOptimistic, refresh, resolve, until, onSettled, onCleanup } from "./signals.js";
 export type { Truthy, UntilOptions, Accessor, SourceAccessor, Setter, Signal, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, SignalOptions, MemoOptions, NoInfer } from "./signals.js";
 export { affects } from "./affects.js";

package/dist/types/map.d.ts

@@ -47,6 +47,8 @@ export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly
     fallback?: Accessor<any>;
     name?: string;
 }): Accessor<MappedItem[]>;
+/** @internal */
+export declare function __smallMoveHits(): number;
 /**
  * Reactively renders a callback `count` times, reusing previously-rendered
  * entries when only the count changes. Underlying helper for `<Repeat>`.

package/dist/types/signals.d.ts

@@ -399,6 +399,16 @@ export declare function createRenderEffect<T>(compute: ComputeFunction<undefined
  * Creates a tracked reactive effect where dependency tracking and side effects happen
  * in the same scope.
  *
+ * @deprecated Do not use in new code. For a side effect that follows reactive
+ * state, use `createEffect(compute, effect)` — it separates tracking from the
+ * side effect, knows its dependencies before it runs, and participates in
+ * async and transitions. For one-time DOM work after render (measuring,
+ * attaching third-party widgets to a ref), use `onSettled`. Tracking from
+ * inside the effect phase — the only thing this primitive adds — is retained
+ * solely to ease 1.x migration: it runs beside user-effect callbacks after
+ * values commit, never holds a transition, and cannot observe a write staged
+ * earlier in the same flush by a signal it has not read yet.
+ *
  * WARNING: Because tracking and effects happen in the same scope, this primitive
  * may run multiple times for a single change or show tearing (reading inconsistent
  * state). Use only when dynamic subscription patterns require same-scope tracking.

package/dist/types/store/index.d.ts

@@ -1,18 +1,16 @@
 export type { Store, StoreReturn, ProjectionStoreReturn, StoreSetter, StoreNode, StoreOptions, ProjectionOptions, NotWrappable, SolidStore } from "./store.js";
 export type { Merge, Omit } from "./utils.js";
 export { isWrappable, $TRACK, $PROXY, $TARGET } from "./store.js";
+export { mergeSources } from "./utils.js";
 import type { NoFn, ProjectionOptions, Store, StoreOptions, StoreSetter } from "./store.js";
 import type { Refreshable } from "../core/index.js";
 export { createProjectionNext as createProjection } from "./next/projection.js";
-export { registerPatch, registerRowOps, registerSlotPatchNext as registerSlotPatch, patchableRaw } from "./next/patch.js";
 export { storeIsShallow, storeHasFamily, storeHasOptimisticFamily } from "./next/store.js";
 export { createOptimisticStoreNext as createOptimisticStore } from "./next/optimistic.js";
-/** Public createStore: plain form `(init, options?)` and derived writable
+/** Public createStore: plain form `(initialValue, options?)` and derived writable
  * form `(fn, seed, options?)`. */
-export declare function createStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>, options?: StoreOptions & {
-    shallow?: boolean;
-}): [get: Store<T>, set: StoreSetter<T>];
-export declare function createStore<T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Refreshable<Store<T>>, set: StoreSetter<T>];
+export declare function createStore<T extends object = {}>(initialValue: NoFn<T> | Store<NoFn<T>>, options?: StoreOptions): [get: Store<T>, set: StoreSetter<T>];
+export declare function createStore<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Refreshable<Store<T>>, set: StoreSetter<T>];
 export declare function reconcile<T extends U, U>(value: T, key?: string | ((item: NonNullable<any>) => any) | null): (state: U) => T;
 export declare function snapshot<T>(value: T): T;
 export declare function deep<T>(value: T): T;

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

@@ -1,5 +1,6 @@
+import { type Refreshable } from "../../core/index.js";
 import { type Transition } from "../../core/scheduler.js";
-import { type NoFn, type ProjectionOptions, type Store, type StoreSetter } from "../store.js";
+import { type NoFn, type ProjectionOptions, type Store, type StoreOptions, type StoreSetter } from "../store.js";
 import type { StoreNextTarget } from "./target.js";
 /** #3164 fold: a stamped truth is HELD (masked from ordinary readers until
  * the reveal) only while its transition is live AND retaining optimism —
@@ -8,7 +9,8 @@ import type { StoreNextTarget } from "./target.js";
  * staged values to converge (normal speculation). Resolves merges first:
  * merge unions optimistic nodes/stores into the target. */
 export declare function transitionHoldsOptimism(transition: Transition): boolean;
-export declare function createOptimisticStoreNext<T extends object = {}>(first: T | ((store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>), second?: NoFn<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Store<T>, set: StoreSetter<T>];
+export declare function createOptimisticStoreNext<T extends object = {}>(initialValue: NoFn<T> | Store<NoFn<T>>, options?: StoreOptions): [get: Store<T>, set: StoreSetter<T>];
+export declare function createOptimisticStoreNext<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Refreshable<Store<T>>, set: StoreSetter<T>];
 /** Diff the draft against the current OPTIMISTIC VIEW (committed + active
  * overrides — the same view the draft was seeded from) and emit engine writes
  * for exactly the changed keys. Visible-view diffing keeps no-op writes from

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

@@ -1,17 +1,10 @@
-import type { RowOps } from "./patch.js";
-import { type StoreNextTarget } from "./target.js";
 type KeyFn = (item: any) => any;
 export declare function reconcileNextState(value: any, state: any, key: string | KeyFn | null | undefined, replace?: boolean): void;
+/** Setter-channel row ops (the fold site calls this for array targets with
+ * ops consumers): structural mutation through the setter — push/splice/index
 /** Key equality for EVERY key comparison in this module (re-audit 2, P1-5):
- * SameValueZero, matching the Map-based matchers (buildRowOps, the adoption
- * window) — NaN keys are equal to themselves, so aligned NaN rows stay
- * aligned in the prefix walk instead of forever misaligning. Adoption and
- * row ops MUST agree on key equality or retained DOM rows go stale. */
+ * SameValueZero, matching the adoption window's Map-based matcher — NaN keys
+ * are equal to themselves, so aligned NaN rows stay aligned in the prefix
+ * walk instead of forever misaligning. */
 export declare function sameKey(a: any, b: any): boolean;
-export declare function emitSetterRowOps(t: StoreNextTarget, prevRows: any[], nextRows: any[]): void;
-/** Identity-keyed structural diff, returned rather than emitted: shared by
- * the setter channel (regular queue) and the OPTIMISTIC write channel (lane
- * queue) — same retention semantics, different dispatch timing. Returns
- * null when the lists are identity-aligned (no structure changed). */
-export declare function buildIdentityRowOps(prevRows: any[], nextRows: any[]): RowOps | null;
 export {};