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

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

@@ -0,0 +1,71 @@
+import type { Owner } from "./types.js";
+/**
+ * The client error hook — the prod-tier seam through which an app or an
+ * error monitor hears the one failure nothing else can see: an error
+ * boundary (`createErrorBoundary`, `<Errored>`) collected it and is rendering
+ * its fallback. The browser's global handlers hear what reaches
+ * `window.onerror`; a rendered fallback never does. An UNCAUGHT error is not
+ * this hook's: the halt (`REACTIVITY_HALTED`) hands its cause to the
+ * platform's `reportError`, the channel every monitor already listens on —
+ * one event, not two.
+ *
+ * Called once per error object: a boundary's `reset()` recomputing the same
+ * failing node re-collects the same error and does not report it again.
+ * Two tiers: ambient (`configureClientErrors`) and per root
+ * (`render`/`hydrate`'s `onError` in `@solidjs/web`), the nearest root's
+ * winning. Fires in every tier; no return — the client has no wire to map
+ * for. `ownerPath` carries the component labels where the runtime keeps
+ * owner names (the observe and dev artifacts).
+ *
+ * Pay-for-use: this module is retained by `createErrorBoundary` (which
+ * reports here) or the app's own `configureClientErrors` import. A root's
+ * hook is parked ON the root owner under a registered symbol
+ * (`ROOT_ERROR_HOOK`, defined in the scheduler), so `render` writes it
+ * without importing anything: an app that configures no hook and renders no
+ * boundary carries none of this.
+ */
+export interface ClientErrorContext {
+    /**
+     * Where the error was THROWN: labels root-first up the owner chain of the
+     * computation that threw — component labels and named primitives — when
+     * the runtime keeps owner names (the observe and dev artifacts). The
+     * boundary's own chain when the thrower is unknown (a value thrown
+     * outside any computation).
+     */
+    ownerPath?: string[];
+    /**
+     * Where the error was MET: the same labels up the chain of the `<Errored>`
+     * that rendered its fallback for it — what the user saw, as against
+     * `ownerPath`, which is what broke.
+     */
+    boundaryPath?: string[];
+}
+export type ClientErrorHook = (error: unknown, context: ClientErrorContext) => void;
+export interface ClientErrorsConfig {
+    /** The hook, or `undefined` to clear it. */
+    onError?: ClientErrorHook;
+}
+/**
+ * Registers the ambient client error hook — the one call a browser `init()`
+ * makes to see every failure a boundary renders a fallback for, in
+ * production. (Uncaught errors reach `reportError` / `window.onerror`.)
+ *
+ * ```ts
+ * configureClientErrors({
+ *   onError: (error, { ownerPath }) =>
+ *     Sentry.captureException(error, {
+ *       mechanism: { type: "solid.error_boundary", handled: true }
+ *     })
+ * });
+ * ```
+ */
+export declare function configureClientErrors(config: ClientErrorsConfig): void;
+/**
+ * Tells the client error hook about `error`, caught by the boundary whose
+ * owner is `owner`, thrown by `thrower` (the computation the engine's status
+ * wrapper named; unknown for a value that never crossed one) — once per
+ * error object. A throwing hook is reported on the console and otherwise
+ * ignored — a monitor must never take the app down.
+ * @internal
+ */
+export declare function reportClientError(error: unknown, owner: Owner | null | undefined, thrower?: Owner | null): void;

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

@@ -9,5 +9,8 @@ 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 { ROOT_ERROR_HOOK } from "./scheduler.js";
+export { configureClientErrors, type ClientErrorContext, type ClientErrorHook, type ClientErrorsConfig } from "./error-hooks.js";
+export { DEV, OBSERVE, ownerPath, type AttributionSlot, type Dev, type Observe, type ServerObserve, type Records, type RecordTypes, type HostRecordTypes, type RecordType, type RecordEvent, type RecordLive, type RecordListener, 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

@@ -25,6 +25,10 @@ export declare const InvariantHooks: {
 };
 export declare function devTrackHeldPending(node: AnyNode): void;
 export declare function devTrackCompanionOwner(node: AnyNode): void;
+/** #3503: a firewall child the store released (unobserved sweep) leaves the
+ * registry with it — the runtime drops it from `_companionChildren` so the
+ * projection stops retaining it; the test-only set must not either. */
+export declare function devUntrackCompanionOwner(node: AnyNode): void;
 export declare function devTrackOptimistic(node: AnyNode): void;
 export declare function devTrackAffects(node: AnyNode): void;
 /**

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

@@ -1,3 +1,5 @@
+import { hasActiveOverride } from "./core.js";
+export { hasActiveOverride };
 import { type QueueCallback, type Transition } from "./scheduler.js";
 import type { Computed, Signal } from "./types.js";
 /**
@@ -26,14 +28,50 @@ export declare function getOrCreateLane(signal: Signal<any>): OptimisticLane;
 export declare function findLane(lane: OptimisticLane): OptimisticLane;
 /**
  * Is the lane held? `_pendingAsync` records the async the lane OWNS (derived
- * under it); the transaction's reporter map records the async a render effect
+ * 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;
+/**
+ * Lanes mirror transitions (#3460): a render effect OFF a HELD lane that reads
+ * a value the lane is revealing — an override, a `latest()` shadow — sees the
+ * committed value, exactly as a stale reader of a held transaction does
+ * (A15 reveal corollary): it publishes now, with the frame that is on screen
+ * (the lane defers its own readers' runs, so the committed value is what is
+ * visible), entangles nothing — a sync write is never held by a lane — and
+ * re-derives at the release. The release re-run rides the lane's own render
+ * queue, which runs when the lane reveals (runLaneEffects) or its transaction
+ * commits (cleanupCompletedLanes). A reader ON the lane computes the lane's
+ * reveal and takes the value as before.
+ *
+ * OFF the lane is provenance, not membership — the transaction mirror
+ * exactly: a stale reader of a transaction is a pass that runs outside it. A
+ * pass under the lane's own transaction is the lane's work — its write (lane
+ * posture), or the landing of its async, which re-enters the transaction
+ * (#3334) and runs a member with no ambient lane. Read as an outsider, that
+ * pass published the committed view and queued a replay that revealed the
+ * override beside its unready derivation at the release (`1:0` for an
+ * optimistic frame that never became ready; #3479 review). Membership is the
+ * wrong test the other way: a member re-run by a sibling's sync write is a
+ * mainline pass and shows the committed view.
+ */
+export declare function readsHeldCommitted(owner: Computed<any>, c: Computed<any>): boolean;
+/** The ownership relation for a lane hold (core `ownsHold`, §6 ruling 2): the
+ * running pass owns `lane`'s hold if it runs under the transition that owns
+ * the lane (the node's, resolved through override ownership and merges) or
+ * inside the lane itself. */
+export declare function ownsLane(lane: OptimisticLane, owner: Computed<any>): boolean;
 /**
  * Merge two lanes when their dependency graphs overlap.
  */
@@ -43,10 +81,6 @@ export declare function mergeLanes(lane1: OptimisticLane, lane2: OptimisticLane)
  */
 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: 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.

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

@@ -3,12 +3,20 @@ import { activeLanes, assignOrMergeLane, findLane, type OptimisticLane } from ".
 import type { Computed, Signal } from "./types.js";
 export { activeLanes, assignOrMergeLane, findLane };
 export { getOrCreateLane, hasActiveOverride, mergeLanes, resolveLane } from "./lanes.js";
+export declare const transitions: Set<Transition>;
 export declare const dirtyQueue: Heap;
 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;
+/** Slot hook's deferral: release this node when its carried state resolves. */
+export declare function deferSlotRelease(node: Signal<any>): void;
 /**
  * Consume the unhandled-async hit. Returns whether this is the first report
  * of the current enforcement window — the caller warns only then.
@@ -40,9 +48,18 @@ export interface Transition {
     _affectsNodes: OptimisticNode[];
     _optimisticStores: Set<any>;
     _actions: Array<Generator<any, any, any> | AsyncGenerator<any, any, any>>;
+    /** An action ran in this transaction (#3427, set by action()): once
+     * `_actions` drains, its bodies are OVER — as opposed to a transaction that
+     * never had one, whose bare optimistic writes live until it settles. */
+    _acted?: boolean;
     _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
@@ -63,11 +80,44 @@ export interface Transition {
  */
 export declare function entangleConfirmingTransitions(obs: Computed<any>, target: Transition): void;
 export declare function schedule(): void;
+/**
+ * Parked transactions whose reporter set changed without a write. A
+ * transaction completes when nothing live reports a flight it waits on, but
+ * the flush only judges the ACTIVE transaction: a parked one is re-entered by
+ * a stamped node's landing or an action's resume. A reporter that stops
+ * counting for another reason — its loading boundary flipped to the fallback
+ * (#3375), or it was disposed by ambient work (#3372) — is neither: the
+ * pruning in `reporterBlocksSource` would drop it at the next check, but no
+ * check comes, and the writes held with it stay staged. Such sites record the
+ * transaction here (deduped: one idle pass per transaction, however many
+ * reporters changed); the flush re-enters it on an otherwise idle pass, so
+ * the re-evaluation adopts no unrelated ambient work.
+ */
+export declare const wokenTransitions: Transition[];
+/** Wake every parked transaction — for a site that knows a reporter stopped
+ * counting but not whose (a boundary reset). */
+export declare function wakeParked(): void;
+/** Transactions a mainline tick has PROPOSED against (A34, #3494): a write to a
+ * node one of them holds — the same value or another — is a second proposal
+ * on a contested node, and the tick reveals with the hold ("both are
+ * suggesting a value; if one finished before the other that would be odd").
+ * Entered at the next flush's start, where the ambient batch is adopted;
+ * never from the write itself, which left `activeTransition` set across the
+ * caller's block and made creation after the write the transaction's (A29). */
+export declare const batchJoins: Transition[];
 /**
  * Permanently halts the reactive system. Called when a user error escapes
  * every boundary — app state is undefined at that point, so scheduling stops
  * entirely rather than limping along with a half-applied update.
  */
+/**
+ * The key a root owner carries its client error hook under (`render`'s
+ * `onError`) — registered, so a runtime writes it with no import of the hook
+ * module (core/error-hooks.ts) and no property mangling in the way. Defined
+ * HERE, not there: a runtime that only writes the key must not retain the
+ * hook machinery (pay-for-use).
+ */
+export declare const ROOT_ERROR_HOOK: unique symbol;
 export declare function haltReactivity(cause?: unknown): void;
 /** @internal Test/dev-reload hook. Revives scheduling after a halt. */
 export declare function resetErrorHalt(): void;
@@ -81,6 +131,11 @@ export interface IQueue {
     stashQueues(stub: QueueStub): void;
     restoreQueues(stub: QueueStub): void;
     _parent: IQueue | null;
+    /** Loading/error boundary queues (boundaries.ts): the status dimension the
+     * queue consumes, and whether it currently shows content (initialized) or
+     * its fallback (collecting). Read by `reporterBlocksSource`. */
+    _collectionType?: number;
+    _initialized?: boolean;
 }
 export declare class Queue implements IQueue {
     _parent: IQueue | null;
@@ -131,6 +186,11 @@ 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;
@@ -140,6 +200,44 @@ export declare class GlobalQueue extends Queue {
      * 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;
+    /** The flush's pre-verdict step (#3427): once the transaction's action
+     * bodies have all ended and nothing authoritative is left in flight, the
+     * engine supersedes every override still in force with the truth it
+     * reverts to, so the graph re-derives from it now, as the transaction's
+     * held work, instead of after the flights the overrides fed have landed.
+     * True when it superseded something: the caller re-runs the heap ahead of
+     * the verdict. The engine owns every gate (acted, actions drained, has
+     * overrides, no store edits, no authoritative flight); null without it. */
+    static _endOptimism: ((transition: Transition) => boolean) | 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. */
+    /** A tracked read of an active override: the lane outside-view rule
+     * (#3460) and the A18 supersession selection (#3331) — see optimistic.ts. */
+    static _overrideRead: ((el: Computed<any>, c: Computed<any>) => unknown) | null;
+    /** A lane pass's publish for a memo (#3479, lanes stage): the speculative
+     * result becomes a DERIVED override, `_value` stays committed — see
+     * optimistic.ts laneOverride. Set with the engine, which a lane implies. */
+    static _laneOverride: ((el: Computed<any>, value: unknown, lane: OptimisticLane) => void) | null;
+    /** Verdict-layer recompute in progress (companion creation, latest()/
+     * isPending() pulls): never born held — see core.ts enterStagedRead. */
+    static _verdictPull: boolean;
+    /** 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;
@@ -154,6 +252,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;
@@ -165,6 +278,15 @@ export declare function setStoreCommitHook(fn: () => void): void;
  * storeCommitHook to stay tree-shakeable. */
 export declare let patchCommitHook: ((batch: Transition) => void) | null;
 export declare function setPatchCommitHook(fn: (batch: Transition) => void): void;
+/** Unchanged passes with a stale dependency tail, waiting on this flush's
+ * verdict (A30, #3469). A pass that changed nothing replaced nothing either —
+ * and cannot know at its own tail whether the flush that ran it will park:
+ * parked, its inputs are held and the committed frame still derives from the
+ * tail (`b() ? b() : a()` computed `1` from the held `b`, equal to the `1` it
+ * had from `a` — with `a` trimmed, the mainline `a = 2` never reached it).
+ * Trimmed when the flush commits; dropped with a park, the tail stays linked
+ * until a committing pass trims it (one spurious recompute at most). */
+export declare const heldTrims: Computed<any>[];
 export declare function finalizePureQueue(completingTransition?: Transition | null, incomplete?: boolean): void;
 /**
  * Count of live `affects()` registrations across the system (including
@@ -214,12 +336,43 @@ export declare const globalQueue: GlobalQueue;
  */
 export declare function flush(): void;
 export declare function flush<T>(fn: () => T): T;
+/**
+ * Does a live reporter of `transition` still observe `source` pending? Dead
+ * reporters (disposed, behind a fallback, no longer reading the source) are
+ * pruned as they are found, and the source's entry with them. Shared by the
+ * settle verdict and the lane's hold check (`waitingTransition`): a live
+ * action parks its transaction without a verdict, so this prune is the only
+ * one an optimistic lane whose last async reader unmounted mid-action ever
+ * gets — without it the lane held on the dead reporter's registration until
+ * the flight it no longer observed landed (#3426).
+ */
+export declare function sourceObserved(transition: Transition, source: Computed<any>, verdict?: Transition): boolean;
 /** A fresh, unentered transaction (#3146): the optimistic store's truth
  * flight DECLARES an owned transaction instead of relying on whatever the
  * ambient adoption machinery stamped on its firewall. Activate it with
  * 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 — a registration whose every
+ * reporter has since died is nobody (#3426).
+ */
+export declare function waitingTransition(source: Computed<any>): Transition | null;
+/** A landing enters EVERY parked transaction still waiting on `source`, folding
+ * them into the active one (A15: each reveal that discovered the flight
+ * completes at its landing). The fold used to happen as the waiters' stamped
+ * readers recomputed under the landing — recompute re-entering an effect's
+ * stamp — which also folded in writes those readers merely shared a hole
+ * with (#3407); effects no longer re-enter, so the landing folds explicitly.
+ * Live iteration is safe: a merge deletes the outgoing (active) entry and
+ * re-adds the visited one. */
+export declare function enterWaiting(source: Computed<any>): void;
 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,19 @@ 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;
+    /** A28: the staged value the last flush left on a HELD node that has since
+     * been rewritten (latest() keeps answering with it); NOT_PENDING otherwise. */
+    _flushedStaged: unknown;
+    /** 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 +125,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 +156,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 +178,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";
+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, ownerPath, configureClientErrors, ROOT_ERROR_HOOK } 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, ClientErrorContext, ClientErrorHook, ClientErrorsConfig, InteractionRef, NavigationRef, OriginRef, Dev, Observe, ServerObserve, Records, RecordTypes, HostRecordTypes, RecordType, RecordEvent, RecordLive, RecordListener, 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

@@ -582,12 +582,20 @@ export interface UntilOptions {
  *
  * Must be called *outside* a tracking scope.
  *
+ * Inside an action, call it from a step: after an `await`, put a bare `yield`
+ * before `yield until(...)`. The runtime cannot hook an async generator's
+ * `await` continuation, so the `until(...)` expression — which CREATES the
+ * predicate's reader — would otherwise run outside the transaction; created
+ * there it is born held (A29) and replays only at the commit its own promise
+ * holds open (#3482). See {@link action}.
+ *
  * @example
  * ```ts
  * const send = action(async function* (text: string) {
  *   const clientId = crypto.randomUUID();
  *   setMessages(m => { m.push({ clientId, text, pending: true }); }); // optimistic
  *   await socket.send({ clientId, text }); // fire-and-forget transport
+ *   yield; // re-enter the transaction after the await
  *   // Hold until the live source echoes the write (authoritative view —
  *   // the optimistic row above cannot satisfy this):
  *   yield until(() => messages.some(m => m.clientId === clientId), { timeout: 10_000 });

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

@@ -1,6 +1,8 @@
 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, mergeView, viewOf, omitView, sourceKeys, sourceHas, sourceGet, hasStaticKeys, isStatic, resolvedTable, OmitView, MergeView, SOURCE_PLAIN, SOURCE_OMIT, SOURCE_PROXY, SOURCE_MEMO, SOURCE_MERGE, sourceOwners } from "./utils.js";
+export type { SourceKind } 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";

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

@@ -22,4 +22,4 @@ export declare function notifyOptimisticWrites(t: StoreNextTarget, pb: Record<Pr
  * Authoritative-view reads (until()'s predicate) skip composition entirely:
  * the predicate observes authoritative truth, never the caller's tentative
  * overlay. (Write-side emission callers never run under such a compute.) */
-export declare function optimisticView(t: StoreNextTarget, src: Record<PropertyKey, any>): Record<PropertyKey, any>;
+export declare function optimisticView(t: StoreNextTarget, src: Record<PropertyKey, any>, draft?: boolean): Record<PropertyKey, any>;

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

@@ -1,3 +1,4 @@
+import { hasActiveOverride, visibleOverride } from "../../core/core.js";
 import type { Signal } from "../../core/types.js";
 import { type StoreNextFamily, type StoreNextTarget } from "./target.js";
 export declare function wrapNext<T extends Record<PropertyKey, any>>(value: T, parent?: StoreNextTarget | null, parentKey?: PropertyKey | null, fam?: StoreNextFamily | null): T;
@@ -15,6 +16,11 @@ export declare function bumpDeep(t: StoreNextTarget): void;
  * the clone path. Consumers that need a complete container (reconcile's
  * diff walks, drafts escaping into other storage) call this. */
 export declare function materializePB(target: StoreNextTarget): void;
+/** Resolve the held committed view (#3074): answers the masked old backing
+ * while the hold is live, and lazily clears a hold whose transition has
+ * committed (transitions merge — resolve through currentTransition, same as
+ * foldHeld's node stamps). */
+export declare function heldMaskView(t: StoreNextTarget): Record<PropertyKey, any> | null;
 /**
  * Adoption (2026-08-16c): the incoming object becomes the committed backing
  * IMMEDIATELY — reconcile is eagerly visible to every reader (shipped
@@ -60,9 +66,7 @@ export declare function notifyFold(t: StoreNextTarget, old: Record<PropertyKey,
  * share the instance core reads — cross-module live-binding writes from other
  * store modules were observed not to propagate under the test transform). */
 export declare function runAuthoritative<T>(fn: () => T): T;
-/** Active optimistic override on an armed node (armed slot idles at
- * NOT_PENDING; undefined = unarmed plain node). */
-export declare function hasActiveOverride(node: Signal<any>): boolean;
+export { hasActiveOverride, visibleOverride };
 /** The reading computation is until()'s authoritative-view predicate — same
  * source of truth as core read()'s A17 carve-out (`context`, which persists
  * under untrack). optimisticView()'s composition gate consults exactly this:
@@ -81,8 +85,10 @@ export declare function authoritativeServe(): boolean;
 export type SetStoreNextFunction<T> = (fn: (draft: T) => T | void) => void;
 /** Low-level setter primitive: opens write mode on a next proxy, runs `fn`,
  * emits write-time notifications at outermost exit, applies returned
- * replacements as adoptions. `guard=false` skips the owned-scope dev guard —
- * projection recomputes legitimately write from inside their computed. */
+ * replacements as adoptions. `guard=false` skips the dev guards (owned-scope
+ * write, thenable result) — projection recomputes legitimately write from
+ * inside their computed, and their async derive is handled by the recompute,
+ * not returned through here. */
 export declare function storeSetterNext<T>(proxy: T, fn: (draft: T) => T | void, guard?: boolean): void;
 export declare function createStoreNext<T extends Record<PropertyKey, any>>(initialValue: T, shallow?: boolean): [T, SetStoreNextFunction<T>];
 /** True when `proxy` is a SHALLOW store (children served verbatim, slots