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

package/dist/types/attribution.d.ts

@@ -10,6 +10,11 @@
  * `attribution.prod.ts`, an inert engine with the same surface, so app code
  * can import it unconditionally.
  */
-export { attribution } from "./core/attribution.js";
-export type { Acknowledgement, Attribution, AttributionFeedbackTables, AttributionOptions, AttributionRecords, AttributionRecordType, ChangeKind, ChangeOrigin, ChangeRecord, FallbackStats, FeedbackInteraction, FeedbackNavigation, FeedbackSource, FlightLink, FlightStats, HeldWrite, HoldEvent, InteractionEvent, NavigationEvent, NavigationHop, RerunEvent, ScopeCost, WaterfallRecord, WriteCost } from "./core/attribution.js";
+export { attribution, formatOrigin, formatRerun } from "./core/attribution.js";
+export { costs } from "./core/attribution-costs.js";
+export { feedback } from "./core/attribution-feedback.js";
+export { subscriptions, why } from "./core/attribution-queries.js";
+export type { Acknowledgement, Attribution, AttributionOptions, AttributionRecords, AttributionRecordType, ChangeKind, ChangeOrigin, ChangeRecord, FlightLink, HeldWrite, HoldEvent, InteractionEvent, NavigationEvent, NavigationHop, RerunEvent, WaterfallRecord } from "./core/attribution.js";
+export type { AttributionCostTables, ScopeCost, WriteCost } from "./core/attribution-costs.js";
+export type { AttributionFeedbackTables, FallbackStats, FeedbackInteraction, FeedbackNavigation, FeedbackSource, FlightStats } from "./core/attribution-feedback.js";
 export type { InteractionRef, NavigationRef, OriginRef } from "./core/attribution-hooks.js";

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

@@ -8,6 +8,15 @@
  * real engine's interface so the two cannot drift.
  */
 import type { Attribution } from "./core/attribution.js";
+import type * as Engine from "./attribution.js";
 export declare const attribution: Attribution;
-export type { Acknowledgement, Attribution, AttributionFeedbackTables, AttributionOptions, AttributionRecords, AttributionRecordType, ChangeKind, ChangeOrigin, ChangeRecord, FallbackStats, FeedbackInteraction, FeedbackNavigation, FeedbackSource, FlightLink, FlightStats, HeldWrite, HoldEvent, InteractionEvent, NavigationEvent, NavigationHop, RerunEvent, ScopeCost, WaterfallRecord, WriteCost } from "./core/attribution.js";
+export declare const costs: typeof Engine.costs;
+export declare const feedback: typeof Engine.feedback;
+export declare const why: typeof Engine.why;
+export declare const subscriptions: typeof Engine.subscriptions;
+export declare const formatRerun: typeof Engine.formatRerun;
+export declare const formatOrigin: typeof Engine.formatOrigin;
+export type { Acknowledgement, Attribution, AttributionOptions, AttributionRecords, AttributionRecordType, ChangeKind, ChangeOrigin, ChangeRecord, FlightLink, HeldWrite, HoldEvent, InteractionEvent, NavigationEvent, NavigationHop, RerunEvent, WaterfallRecord } from "./core/attribution.js";
+export type { AttributionCostTables, ScopeCost, WriteCost } from "./core/attribution-costs.js";
+export type { AttributionFeedbackTables, FallbackStats, FeedbackInteraction, FeedbackNavigation, FeedbackSource, FlightStats } from "./core/attribution-feedback.js";
 export type { InteractionRef, NavigationRef, OriginRef } from "./core/attribution-hooks.js";

package/dist/types/boundaries.d.ts

@@ -1,4 +1,4 @@
-import { Queue, type Computed, type Effect } from "./core/index.js";
+import { Queue, type Computed, type Effect, type Owner } from "./core/index.js";
 import type { Signal } from "./core/index.js";
 import { type Accessor } from "./signals.js";
 export interface BoundaryComputed<T> extends Computed<T> {
@@ -45,9 +45,18 @@ export declare class CollectionQueue extends Queue {
     _initialized: boolean;
     _onFn: (() => any) | undefined;
     _prevOn: any;
+    /** The boundary's owner — where a `caught` report locates itself, set before the children are built (a creation-time throw arrives before `_tree`). */
+    _owner?: Owner;
     constructor(type: number);
     run(type: number): void;
+    /** The `on` key, or ON_INIT when it throws. Evaluated mid-propagation,
+     * inside the pending node's own pass: read as a spectator so the key's
+     * sources never become that node's dependencies (#3528). */
+    _readOn(): any;
     notify(node: Effect<any>, type: number, flags: number, error?: any): boolean;
+    /** Is `reporter` live and routed to this boundary — under it, with no
+     * collecting pending-type boundary in between (`reporterBlocksSource`'s test)? */
+    _holds(reporter: Computed<any>): boolean;
     _checkSources(): void;
 }
 /**

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

@@ -23,15 +23,22 @@
  * `yield` is the transaction-safe suspension point: the action waits for a
  * yielded promise and re-enters the transaction before running the code after
  * it. A plain `await` does NOT — the runtime has no hook into an async
- * generator's internal await continuations, so writes to fresh signals
- * between an `await` and the next `yield` escape the transaction and commit
- * immediately. `await` is still the ergonomic choice for typed results; just
- * put a bare `yield` before any writes that follow it:
+ * generator's internal await continuations, so code between an `await` and
+ * the next `yield` runs OUTSIDE the transaction: writes to fresh signals
+ * commit immediately, and anything that creates a reader there — `until()`,
+ * `latest()`, a memo or effect, a mount — is created mainline, where a read of
+ * this action's held state makes it born held (A29): staged with the
+ * transaction and replayed at its commit. For `until()` that commit is the
+ * settle its own promise holds open (#3482). `await` is still the ergonomic
+ * choice for typed results; just put a bare `yield` before any write or
+ * reader creation that follows it — including the expression of the next
+ * `yield`, which is evaluated before the step re-enters:
  *
  * ```ts
  * const saved = await api.createTodo(text); // typed result
- * yield; // re-enter the transaction before writing
+ * yield; // re-enter the transaction before writing or reading
  * setTodos(t => { ... });
+ * yield until(() => todos.some(t => t.id === saved.id));
  * ```
  *
  * (For the same reason, don't call `flush()` inside an action body — it

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

@@ -0,0 +1,35 @@
+export interface ScopeCost {
+    name: string;
+    kind: "effect" | "memo";
+    runs: number;
+    selfMs: number;
+    /**
+     * Self-time of PLAIN, non-held runs that produced an unchanged value —
+     * the recoverable number. Overlay runs (optimistic/transition) are never
+     * counted here: an optimistic recompute landing back on the committed
+     * value is the mechanism working, not waste.
+     */
+    wastedMs: number;
+    /** Self-time spent in optimistic/transition (overlay) runs. */
+    overlayMs: number;
+}
+export interface WriteCost {
+    /** Root cause name (a signal write, async landing, or refresh target). */
+    name: string;
+    /** Number of downstream re-runs this root triggered. */
+    runs: number;
+    /** Summed self-time of every downstream re-run it caused. */
+    downstreamMs: number;
+}
+export interface AttributionCostTables {
+    /** Ranked by self-time. */
+    scopes: ScopeCost[];
+    /** Ranked by the total downstream re-run time each root write caused. */
+    writes: WriteCost[];
+}
+/**
+ * Aggregated cost tables since `enable()`: `scopes` ranked by self-time
+ * (with `wastedMs` = time spent on unchanged-value runs), `writes` ranked by
+ * total downstream re-run time each root write caused.
+ */
+export declare function costs(): AttributionCostTables;

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

@@ -0,0 +1,133 @@
+export interface FeedbackSource {
+    /** The async nodes the holds waited on; empty when an action alone kept them open. */
+    sources: string[];
+    holds: number;
+    /** Summed wait across the holds (ms). */
+    heldMs: number;
+    worstMs: number;
+    /** Holds with no acknowledgment at all — the SILENT_HOLD signature, at any duration. */
+    silent: number;
+    silentMs: number;
+    /** Holds whose only acknowledgment was a `latest()` shadow: the input showed, nothing said "loading". */
+    latestOnly: number;
+    /**
+     * Holds whose quiescent tail (last write to join → commit) reached
+     * `longHolds.infoMs`, acknowledged or not — the LONG_HOLD signature at the
+     * table level. The affordance is not the whole answer there: a fallback
+     * (`Loading` keyed with `on`), a preload, a cache, or a faster source is.
+     * `longMs` sums the tails.
+     */
+    long: number;
+    longMs: number;
+    /** Which affordances answered, and in how many holds — ranked. */
+    acknowledgedBy: {
+        by: string;
+        holds: number;
+    }[];
+    /** Interactions whose writes were held here, ranked by holds. */
+    interactions: {
+        interaction: string;
+        holds: number;
+    }[];
+    /** Distinct root writes that were held. */
+    writes: string[];
+    /** Holds an action opened or joined. */
+    actions: number;
+}
+export interface FeedbackInteraction {
+    /** `click on button#next "Next →"` — type and target; repeated dispatches fold together. */
+    interaction: string;
+    /** Distinct dispatches seen (by dispatch time). */
+    dispatches: number;
+    /** Re-runs traced back to this interaction, and their summed self-time. */
+    runs: number;
+    selfMs: number;
+    /** The most re-run self-time a single dispatch caused — the long-flush hazard. */
+    worstDispatchMs: number;
+    /** Holds this interaction's writes waited in — the silent-hold hazard. */
+    holds: number;
+    heldMs: number;
+    silentMs: number;
+    worstHoldMs: number;
+}
+/** Per async source: how many flights it started, and how many it threw away. */
+export interface FlightStats {
+    source: string;
+    /** Flights registered (a recompute that produced a new promise/iterable). */
+    flights: number;
+    /** Flights that landed (whether or not the value changed). */
+    landed: number;
+    /**
+     * Flights superseded by a newer one before landing — the search-as-you-type
+     * signature when large: every keystroke asked, most answers were discarded.
+     * A debounced/equality-gated derivation between input and fetch is the repair.
+     */
+    abandoned: number;
+    /** Summed and worst wall time of landed flights (ms). */
+    landedMs: number;
+    worstMs: number;
+}
+/** Per loading boundary: how long, and how briefly, it showed its fallback. */
+export interface FallbackStats {
+    /** The boundary's owner path (`<App> › <Feed>`), or `boundary` when unnamed. */
+    boundary: string;
+    /** Times the fallback was shown. */
+    shows: number;
+    /** Summed and worst fallback duration (ms) across completed shows. */
+    shownMs: number;
+    worstMs: number;
+    /**
+     * Shows shorter than the flash window (default 150ms): a spinner that
+     * appeared and vanished — the other end of the SILENT_HOLD spectrum, too
+     * much feedback for too little wait. A preload, a cache, or lifting the
+     * fetch above the boundary removes the flash.
+     */
+    flashes: number;
+}
+/**
+ * Per route: what navigating to it cost, folded from settled
+ * `NavigationEvent`s — the route-level view a router integration used to
+ * have to build itself, from the runtime's own facts.
+ */
+export interface FeedbackNavigation {
+    /** The route pattern (`/users/:id`), or the concrete `to` when the router gave no pattern. */
+    name: string;
+    navigations: number;
+    /** Summed and worst request-to-settle time (ms) across settled navigations. */
+    settledMs: number;
+    worstMs: number;
+    /** Navigations whose writes waited in a hold, and the time they waited. */
+    held: number;
+    heldMs: number;
+    /** Held navigations the screen acknowledged nothing for — the SILENT_HOLD signature. */
+    silent: number;
+    /** Navigations overwritten by a later one before they landed. */
+    superseded: number;
+    /** Navigations a redirect sent elsewhere on the way (keyed by where they ended up). */
+    redirected: number;
+}
+export interface AttributionFeedbackTables {
+    sources: FeedbackSource[];
+    interactions: FeedbackInteraction[];
+    /** Routes ranked by the time spent held navigating to them, then by total settle time. */
+    navigations: FeedbackNavigation[];
+    /** Async sources ranked by abandoned flights, then by flights. */
+    flights: FlightStats[];
+    /** Loading boundaries ranked by flashes, then by time shown. */
+    fallbacks: FallbackStats[];
+}
+/**
+ * What the user waited on, folded from holds and the interaction on each
+ * re-run: `sources` ranks async sources by the silent time writes spent held
+ * behind them (with which affordances answered, how often, and which
+ * interactions were held); `interactions` ranks user events by the total time
+ * they cost — re-run work caused (long-flush hazard) beside time held
+ * (silent-hold hazard). Facts at every duration; SILENT_HOLD is the
+ * thresholded verdict. Three more tables round out the picture: `navigations`
+ * ranks routes by the time spent held navigating to them (folded from settled
+ * navigations), `flights` counts each async source's flights and how many
+ * were abandoned before landing (the re-ask storm), and `fallbacks` measures
+ * how long each loading boundary showed its fallback and how often that was a
+ * flash.
+ */
+export declare function feedback(): AttributionFeedbackTables;

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

@@ -1,5 +1,6 @@
+import type { ChangeOrigin } from "./attribution.js";
 import type { Transition } from "./scheduler.js";
-import type { Computed, Signal } from "./types.js";
+import type { Computed, Owner, Signal } from "./types.js";
 /**
  * Observe-tier hook points for the reactive core.
  *
@@ -127,9 +128,12 @@ export interface AttributionHooks {
      * `prevTotal` leaves in the old one. Containers above 64 leaves are not
      * announced. Fired per written key from the write channel's notify. The
      * engine decides whether the replacement was a spread-copy worth a
-     * diagnostic.
+     * diagnostic. `owner` is the owner the store root was created under
+     * (undefined when unrecorded): the finding is about the store, not about
+     * whoever wrote it, so an `OBSERVE.exclude`d panel's store stays silent
+     * however its writes arrive.
      */
-    storeReplaced(path: string, isArray: boolean, total: number, unchanged: number, prevTotal: number): void;
+    storeReplaced(path: string, isArray: boolean, total: number, unchanged: number, prevTotal: number, owner: Owner | null | undefined): void;
     /**
      * A `mapArray` update both disposed and created rows: `removed` are the
      * items whose rows were disposed, `created` the items that got new rows,
@@ -147,6 +151,18 @@ export interface AttributionHooks {
      * registers / last one clears), not per flush.
      */
     boundaryFallback(boundary: object, tree: Computed<any> | undefined, shown: boolean): void;
+    /**
+     * The one query on the surface: the provenance a root write performed at
+     * this moment would be stamped with — the innermost open frame (an effect
+     * callback, an action step, a navigation), the interaction the handler
+     * runs under, or, inside a recompute, the origin of the change that caused
+     * it — or `undefined` when none applies (external). For a runtime that
+     * records a fact of its own beside the engine's records — `@solidjs/web`'s
+     * `"call"` record stamps the server-function call it is about to make —
+     * so the fact joins the engine's interaction and navigation records by the
+     * identity of the object returned, not by time.
+     */
+    currentOrigin(): ChangeOrigin | undefined;
 }
 /** A user interaction, as a rendering runtime describes it to `withInteraction`. */
 export interface InteractionRef {
@@ -238,3 +254,12 @@ export declare function withInteraction<T>(ref: InteractionRef, fn: () => T): T;
  * ```
  */
 export declare function withOrigin<T>(ref: OriginRef, fn: () => T): T;
+/**
+ * The provenance a root write performed now would carry, as the installed
+ * engine sees it (`AttributionHooks.currentOrigin`); `undefined` with no
+ * engine, or when nothing is in effect. Reachable as
+ * `OBSERVE.attribution.currentOrigin` — how a runtime stamps a fact of its
+ * own (a server-function call) with the interaction or navigation it ran
+ * for, so an observer joins the two by identity.
+ */
+export declare function currentOrigin(): ChangeOrigin | undefined;

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

@@ -0,0 +1,10 @@
+/**
+ * Point queries over the engine's live state — the devtools/console view of
+ * one scope. Their own module so a records-only consumer never ships them;
+ * they read the engine's ring buffer and the graph, and register nothing.
+ */
+import { type RerunEvent } from "./attribution.js";
+/** Re-run history for one node — pass a memo/effect accessor or raw node. */
+export declare function why(target: unknown): RerunEvent[];
+/** Current dependency names of one scope — the devtools subscription view. */
+export declare function subscriptions(target: unknown): string[];

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

@@ -1,4 +1,4 @@
-import type { Computed } from "./types.js";
+import type { Computed, Signal } from "./types.js";
 /**
  * "Why did this run" attribution — the engine behind
  * `@solidjs/signals/attribution`.
@@ -92,7 +92,16 @@ export interface RerunEvent {
     nodeRuns: number;
     nodeKind: "effect" | "memo";
     nodeName: string;
-    node: Computed<any>;
+    /**
+     * Identity of the scope that ran, stable for the node's lifetime within
+     * the process: every run of one memo/effect carries the same `nodeId`, so
+     * runs join to a scope after the record has left the process (where
+     * `nodeName` alone would merge every unnamed `effect`). The engine's own
+     * per-node id, also what `ChangeOrigin.run` and the cycle/relay checks
+     * key on; not meaningful across processes or sessions. In-process
+     * consumers that want the live node ask `OBSERVE.subjectOf(event)`.
+     */
+    nodeId: number;
     /**
      * The deps that changed since this node's previous run. Empty means the
      * re-run was not triggered by a tracked value change (creation-adjacent
@@ -260,32 +269,45 @@ export interface AttributionRecords {
     navigation: NavigationEvent;
 }
 export type AttributionRecordType = keyof AttributionRecords;
-export interface ScopeCost {
-    name: string;
-    kind: "effect" | "memo";
-    runs: number;
-    selfMs: number;
-    /**
-     * Self-time of PLAIN, non-held runs that produced an unchanged value —
-     * the recoverable number. Overlay runs (optimistic/transition) are never
-     * counted here: an optimistic recompute landing back on the committed
-     * value is the mechanism working, not waste.
-     */
-    wastedMs: number;
-    /** Self-time spent in optimistic/transition (overlay) runs. */
-    overlayMs: number;
-}
-export interface WriteCost {
-    /** Root cause name (a signal write, async landing, or refresh target). */
-    name: string;
-    /** Number of downstream re-runs this root triggered. */
-    runs: number;
-    /** Summed self-time of every downstream re-run it caused. */
-    downstreamMs: number;
+/** @internal The engine's clock: `performance.now()` where it exists. */
+export declare const now: () => number;
+/**
+ * @internal The fold tables' seam. The engine emits records; the tables that
+ * fold them — `costs()` (scopes and writes), `feedback()` (sources,
+ * interactions, navigations, flights, fallbacks) — live in their own modules
+ * and register here when imported, so a consumer that only subscribes to
+ * records never ships them. Each hook fires at the moment the engine has the
+ * fact; `reset` on `enable()`/`disable()`. With nothing registered every
+ * site is one empty loop.
+ */
+export interface FoldHooks {
+    rerun?(el: Computed<any>, event: RerunEvent): void;
+    hold?(event: HoldEvent): void;
+    navigation?(event: NavigationEvent): void;
+    /** A flight started; `abandoned` when it superseded one still in the air. */
+    flightStart?(el: Computed<any>, abandoned: boolean): void;
+    flightLanded?(el: Computed<any>, ms: number): void;
+    fallback?(boundary: object, tree: Computed<any> | undefined, shown: boolean): void;
+    reset?(): void;
 }
+/** @internal */
+export declare function registerFold(hooks: FoldHooks): void;
+/** @internal Root cause names of a cause chain — the writes/landings/refreshes the chain bottoms out in. */
+export declare function rootsOf(causes: ChangeRecord[], out: Set<string>): void;
+export declare function nodeName(node: Signal<any> | Computed<any>): string;
 /** `click on button#next "Next →"`, `effect "syncTitle"`, `action "save"`, `navigation to /users/:id`, … */
 export declare function formatOrigin(origin: ChangeOrigin): string;
 export declare function formatRerun(event: RerunEvent): string;
+/**
+ * The engine: turn it on, subscribe to its records, read its ring buffers.
+ * The folds over those records — `costs()`, `feedback()` — and the point
+ * queries — `why()`, `subscriptions()` — and the formatters —
+ * `formatRerun()`, `formatOrigin()` — are named exports of
+ * `@solidjs/signals/attribution` rather than methods here, so a consumer
+ * that only wants records (a production adapter) does not ship the tables a
+ * console or an agent reads; importing a fold is what turns its accounting
+ * on.
+ */
 export interface Attribution {
     enable(opts?: AttributionOptions): void;
     disable(): void;
@@ -299,19 +321,6 @@ export interface Attribution {
     subscribe(listener: (event: RerunEvent) => void): () => void;
     subscribe<K extends AttributionRecordType>(type: K, listener: (record: AttributionRecords[K]) => void): () => void;
     history(): readonly RerunEvent[];
-    /** Re-run history for one node — pass a memo/effect accessor or raw node. */
-    why(target: unknown): RerunEvent[];
-    /** Current dependency names of one scope — the devtools subscription view. */
-    subscriptions(target: unknown): string[];
-    /**
-     * Aggregated cost tables since enable(): `scopes` ranked by self-time
-     * (with `wastedMs` = time spent on unchanged-value runs), `writes` ranked
-     * by total downstream re-run time each root write caused.
-     */
-    costs(): {
-        scopes: ScopeCost[];
-        writes: WriteCost[];
-    };
     /**
      * Every graph-provable sequential flight chain observed since enable()
      * (ring-buffered like history()). Facts, not verdicts: chains are recorded
@@ -346,21 +355,6 @@ export interface Attribution {
      * record `feedback().interactions` folds by name.
      */
     interactions(): readonly InteractionEvent[];
-    /**
-     * What the user waited on, folded from holds() and the interaction on each
-     * re-run: `sources` ranks async sources by the silent time writes spent
-     * held behind them (with which affordances answered, how often, and which
-     * interactions were held); `interactions` ranks user events by the total
-     * time they cost — re-run work caused (long-flush hazard) beside time held
-     * (silent-hold hazard). Facts at every duration; SILENT_HOLD is the
-     * thresholded verdict. Three more tables round out the picture:
-     * `navigations` ranks routes by the time spent held navigating to them
-     * (folded from navigations()), `flights` counts each async source's
-     * flights and how many were abandoned before landing (the re-ask storm),
-     * and `fallbacks` measures how long each loading boundary showed its
-     * fallback and how often that was a flash.
-     */
-    feedback(): AttributionFeedbackTables;
     /**
      * Cooperative preload declaration: stamp a flight object (promise or async
      * iterable) with its true kickoff time BEFORE the reactive graph sees it.
@@ -373,8 +367,6 @@ export interface Attribution {
      * later enable()).
      */
     markFlight(flight: object, startedAt?: number): void;
-    format: typeof formatRerun;
-    formatOrigin: typeof formatOrigin;
 }
 /** One landed flight: its node name, wall duration, and upstream chain. */
 export interface FlightLink {
@@ -457,6 +449,9 @@ export interface Acknowledgement {
     source: string;
     reader?: string[];
 }
+/** `isLongHold` — the tail outlasted `longHolds.infoMs`. */
+/** @internal */
+export declare function isLongHold(event: HoldEvent): boolean;
 /** A destination a navigation abandoned when a redirect sent it elsewhere. */
 export interface NavigationHop {
     name?: string;
@@ -529,122 +524,6 @@ export interface InteractionEvent {
      */
     origin: ChangeOrigin;
 }
-export interface FeedbackSource {
-    /** The async nodes the holds waited on; empty when an action alone kept them open. */
-    sources: string[];
-    holds: number;
-    /** Summed wait across the holds (ms). */
-    heldMs: number;
-    worstMs: number;
-    /** Holds with no acknowledgment at all — the SILENT_HOLD signature, at any duration. */
-    silent: number;
-    silentMs: number;
-    /** Holds whose only acknowledgment was a `latest()` shadow: the input showed, nothing said "loading". */
-    latestOnly: number;
-    /**
-     * Holds whose quiescent tail (last write to join → commit) reached
-     * `longHolds.infoMs`, acknowledged or not — the LONG_HOLD signature at the
-     * table level. The affordance is not the whole answer there: a fallback
-     * (`Loading` keyed with `on`), a preload, a cache, or a faster source is.
-     * `longMs` sums the tails.
-     */
-    long: number;
-    longMs: number;
-    /** Which affordances answered, and in how many holds — ranked. */
-    acknowledgedBy: {
-        by: string;
-        holds: number;
-    }[];
-    /** Interactions whose writes were held here, ranked by holds. */
-    interactions: {
-        interaction: string;
-        holds: number;
-    }[];
-    /** Distinct root writes that were held. */
-    writes: string[];
-    /** Holds an action opened or joined. */
-    actions: number;
-}
-export interface FeedbackInteraction {
-    /** `click on button#next "Next →"` — type and target; repeated dispatches fold together. */
-    interaction: string;
-    /** Distinct dispatches seen (by dispatch time). */
-    dispatches: number;
-    /** Re-runs traced back to this interaction, and their summed self-time. */
-    runs: number;
-    selfMs: number;
-    /** The most re-run self-time a single dispatch caused — the long-flush hazard. */
-    worstDispatchMs: number;
-    /** Holds this interaction's writes waited in — the silent-hold hazard. */
-    holds: number;
-    heldMs: number;
-    silentMs: number;
-    worstHoldMs: number;
-}
-/** Per async source: how many flights it started, and how many it threw away. */
-export interface FlightStats {
-    source: string;
-    /** Flights registered (a recompute that produced a new promise/iterable). */
-    flights: number;
-    /** Flights that landed (whether or not the value changed). */
-    landed: number;
-    /**
-     * Flights superseded by a newer one before landing — the search-as-you-type
-     * signature when large: every keystroke asked, most answers were discarded.
-     * A debounced/equality-gated derivation between input and fetch is the repair.
-     */
-    abandoned: number;
-    /** Summed and worst wall time of landed flights (ms). */
-    landedMs: number;
-    worstMs: number;
-}
-/** Per loading boundary: how long, and how briefly, it showed its fallback. */
-export interface FallbackStats {
-    /** The boundary's owner path (`<App> › <Feed>`), or `boundary` when unnamed. */
-    boundary: string;
-    /** Times the fallback was shown. */
-    shows: number;
-    /** Summed and worst fallback duration (ms) across completed shows. */
-    shownMs: number;
-    worstMs: number;
-    /**
-     * Shows shorter than the flash window (default 150ms): a spinner that
-     * appeared and vanished — the other end of the SILENT_HOLD spectrum, too
-     * much feedback for too little wait. A preload, a cache, or lifting the
-     * fetch above the boundary removes the flash.
-     */
-    flashes: number;
-}
-/**
- * Per route: what navigating to it cost, folded from settled
- * `NavigationEvent`s — the route-level view a router integration used to
- * have to build itself, from the runtime's own facts.
- */
-export interface FeedbackNavigation {
-    /** The route pattern (`/users/:id`), or the concrete `to` when the router gave no pattern. */
-    name: string;
-    navigations: number;
-    /** Summed and worst request-to-settle time (ms) across settled navigations. */
-    settledMs: number;
-    worstMs: number;
-    /** Navigations whose writes waited in a hold, and the time they waited. */
-    held: number;
-    heldMs: number;
-    /** Held navigations the screen acknowledged nothing for — the SILENT_HOLD signature. */
-    silent: number;
-    /** Navigations overwritten by a later one before they landed. */
-    superseded: number;
-    /** Navigations a redirect sent elsewhere on the way (keyed by where they ended up). */
-    redirected: number;
-}
-export interface AttributionFeedbackTables {
-    sources: FeedbackSource[];
-    interactions: FeedbackInteraction[];
-    /** Routes ranked by the time spent held navigating to them, then by total settle time. */
-    navigations: FeedbackNavigation[];
-    /** Async sources ranked by abandoned flights, then by flights. */
-    flights: FlightStats[];
-    /** Loading boundaries ranked by flashes, then by time shown. */
-    fallbacks: FallbackStats[];
-}
+/** @internal No affordance answered and nothing painted while held. */
+export declare function isSilentHold(event: HoldEvent): boolean;
 export declare const attribution: Attribution;

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

@@ -122,6 +122,18 @@ export declare const CONFIG_SLOT_NODE: number;
  * paths (asyncWrite, transition-held recompute); cleared by a fresh optimistic
  * write (a new override re-masks) and by the revert. */
 export declare const CONFIG_OVERRIDE_SUPERSEDED: number;
+/** HELD children (#3404): this node's `_firstChild` chain (and `_disposal`
+ * list) was built by a recompute whose result has not committed — a staged
+ * value, a pending window, or a run under a held transaction. A later
+ * recompute may tear those children down immediately: nothing observable
+ * was ever built on them. Unset, the children belong to the committed frame
+ * and a recompute defers them as zombies (`_pendingFirstChild`) until this
+ * node commits — regardless of whether the recompute runs under a
+ * transaction. A parked node (status propagation stamps `_transition`
+ * without recomputing) recomputed when its source lands otherwise disposed
+ * its committed children mid-hold, running their cleanups before the
+ * transaction's atomic reveal. Cleared by `commitPendingNode`. */
+export declare const CONFIG_HELD_CHILDREN: number;
 /** In-flight async node whose inputs were PUBLISHED while it was pending: a
  * batch or transaction committed with the node still `STATUS_PENDING` (an
  * unobserved flight, #3305), so the inputs are on screen and the node's
@@ -133,6 +145,27 @@ export declare const CONFIG_OVERRIDE_SUPERSEDED: number;
  * lane-revealed. Set by `commitPendingNodes`; cleared when the node next
  * enters pending fresh (a new flight from a settled state). */
 export declare const CONFIG_INPUTS_PUBLISHED: number;
+/** A28 (4): the node was written inside a recompute that ran OUTSIDE a flush
+ * (a creation-time compute — boundary machinery, a mapArray's first run). Such
+ * a write is promoted at that recompute's end: readers in the same block see
+ * it. Cleared when the next flush begins; set only on that rare path. */
+export declare const CONFIG_PROMOTED: number;
+/** A28 for same-tick adoption: the node was staged outside a flush and then
+ * adopted by a transaction (initTransition) before any flush carried the
+ * staging — the stamp says "held", but nothing flushed is staged for it, so
+ * on no channel is the write visible yet: `latest()` answers the committed
+ * value, the verdict sees nothing pending (as the store's leaves already did
+ * through their own selection). Cleared when the carrying flush re-stamps the
+ * transaction's pending nodes (reassignPendingTransition). */
+export declare const CONFIG_ADOPTED_UNFLUSHED: number;
+/** The node's active override is a DERIVED one: a lane pass published its
+ * speculative result into the override slot instead of `_value` (lanes
+ * stage — an optimistic derivation is an override, #3479). Its truth is not
+ * `_value` but a recompute from its inputs' truth, so the body-end
+ * supersession (`endOptimism`) and the authoritative-flight blockage
+ * (`transitionBlocked`) skip it; the revert drops the override and re-derives
+ * it (`resolveOptimisticNodes`). Cleared with the override. */
+export declare const CONFIG_DERIVED_OVERRIDE: number;
 export declare const STATUS_NONE = 0;
 export declare const STATUS_PENDING: number;
 export declare const STATUS_ERROR: number;