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

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

@@ -1,6 +1,7 @@
-import type { Computed } from "./types.js";
+import type { Computed, Signal } from "./types.js";
 /**
- * Dev-mode "why did this run" attribution.
+ * "Why did this run" attribution — the engine behind
+ * `@solidjs/signals/attribution`.
  *
  * The runtime already knows the full dependency set of every scope; this
  * module surfaces it. Every value commit stamps its node with a ChangeRecord
@@ -15,11 +16,13 @@ import type { Computed } from "./types.js";
  *
  * This module is the attribution ENGINE: all semantics live here, and it is
  * decoupled from the core. `enable()` installs it into the core's narrow
- * dev-only hook points (attribution-hooks.ts); core's only obligation is to
- * call those hooks with true facts. Disabled cost is one null check per hook
- * site; prod builds fold the sites out entirely. The same hook surface is the
- * intended substrate for external consumers (devtools) — one mechanism, two
- * front-ends.
+ * observe-tier hook points (attribution-hooks.ts); core's only obligation is
+ * to call those hooks with true facts. Disabled cost is one null check per
+ * hook site; prod builds fold the sites out entirely. Nothing in the core
+ * imports this module — it is reachable only through the package's
+ * `./attribution` entry, so an observe build that never imports it never
+ * ships it. The same hook surface is the intended substrate for external
+ * consumers (devtools) — one mechanism, two front-ends.
  */
 export type ChangeKind = "write" | "derived" | "async" | "refresh";
 /**
@@ -36,30 +39,32 @@ export type ChangeKind = "write" | "derived" | "async" | "refresh";
  *   name, when it has one). Writes after an `await` (not a `yield`) run in a
  *   bare microtask and stamp `external` — the documented escape.
  * - `async` — an async landing (`name` = the node whose flight landed).
+ * - `navigation` — a router's navigation, declared via `withOrigin` around
+ *   the location write (`name` = the matched route pattern `/users/:id`;
+ *   `to`/`from` the concrete paths; `params` what the pattern bound; `at`
+ *   when it was requested). The router-agnostic seam: any router that wraps
+ *   its write gets navigations named by route in every hold, re-run and
+ *   verdict, with no per-router knowledge anywhere in the engine.
  * - `external` — none of the above: timers, sockets, promise callbacks, setup.
  *
  * `interaction` on a non-interaction frame is the user event the frame runs
  * under — an action started by a click, an effect whose run was caused by a
- * click's write, a landing whose flight a click started. It is what lets
- * every downstream cost be keyed by the interaction that paid for it.
+ * click's write, a landing whose flight a click started, a navigation a link
+ * click performed. It is what lets every downstream cost be keyed by the
+ * interaction that paid for it.
  */
 export interface ChangeOrigin {
-    kind: "interaction" | "effect" | "action" | "async" | "external";
+    kind: "interaction" | "effect" | "action" | "async" | "navigation" | "external";
     name?: string;
     target?: string;
     at?: number;
     interaction?: ChangeOrigin;
     /** `effect` only: the `RerunEvent.run` of the compute run this callback belongs to. */
     run?: number;
-}
-/** A user interaction, as the web runtime describes it to `withInteraction`. */
-export interface InteractionRef {
-    /** Event type — `click`, `keydown`, `input`… */
-    type: string;
-    /** The element hit, e.g. `button#next "Next →"`. */
-    target?: string;
-    /** Dispatch time on the `performance.now()` clock; defaults to now. */
-    at?: number;
+    /** `navigation` only: concrete destination and departure paths, and the bound params. */
+    to?: string;
+    from?: string;
+    params?: Readonly<Record<string, string | undefined>>;
 }
 export interface ChangeRecord {
     /** Global monotonic change sequence — orders causes across the app. */
@@ -81,11 +86,22 @@ export interface ChangeRecord {
 export interface RerunEvent {
     /** Global monotonic run sequence. */
     run: number;
+    /** When the run started (`performance.now()` clock). */
+    at: number;
     /** How many times this node has re-run since attribution was enabled. */
     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
@@ -178,14 +194,11 @@ export interface AttributionOptions {
     /**
      * Written-fan-out warning: emit a diagnostic when a committed root
      * invalidation (write, refresh, async landing) reaches a node with at
-     * least this many subscribers (default 250). Complements the always-on
-     * HUGE_FAN_OUT graph-size warning, specced against it deliberately:
-     * HUGE_FAN_OUT fires at LINK time from GRAPH_SIZE_WARN_AT (2000) up —
-     * static structure so large it warns even if never written — while this
-     * fires at WRITE time from a much lower bar, because fan-out only costs
-     * anything when the node actually changes. Once per node, re-warning only
-     * on 2x subscriber growth, so the two never spam the same node. `false`
-     * disables.
+     * least this many subscribers (default 250). The lower-bar, opt-in sibling
+     * of the always-on HUGE_FAN_OUT graph-size warning, which fires on the
+     * same kind of write from GRAPH_SIZE_WARN_AT (2000) up; this one hands
+     * over to it there, so a write never carries both. Once per node,
+     * re-warning only on 2x subscriber growth. `false` disables.
      */
     wideWrites?: number | false;
     /**
@@ -243,57 +256,71 @@ export interface AttributionOptions {
         warnMs: number;
     } | false;
 }
-export interface ScopeCost {
-    name: string;
-    kind: "effect" | "memo";
-    runs: number;
-    selfMs: number;
-    /**
-     * Self-time of PLAIN, non-held runs that produced an unchanged value —
-     * the recoverable number. Overlay runs (optimistic/transition) are never
-     * counted here: an optimistic recompute landing back on the committed
-     * value is the mechanism working, not waste.
-     */
-    wastedMs: number;
-    /** Self-time spent in optimistic/transition (overlay) runs. */
-    overlayMs: number;
-}
-export interface WriteCost {
-    /** Root cause name (a signal write, async landing, or refresh target). */
-    name: string;
-    /** Number of downstream re-runs this root triggered. */
-    runs: number;
-    /** Summed self-time of every downstream re-run it caused. */
-    downstreamMs: number;
+/**
+ * The records the engine delivers, by `subscribe(type, …)` name. Every one is
+ * delivered synchronously at the moment it is complete — a re-run when its
+ * recompute ends, an interaction / hold / navigation when it settles — so a
+ * consumer never polls the ring buffers to learn that something finished.
+ */
+export interface AttributionRecords {
+    rerun: RerunEvent;
+    interaction: InteractionEvent;
+    hold: HoldEvent;
+    navigation: NavigationEvent;
 }
+export type AttributionRecordType = keyof AttributionRecords;
+/** @internal The engine's clock: `performance.now()` where it exists. */
+export declare const now: () => number;
 /**
- * Run `fn` as the handler of a user interaction: every root write it performs
- * (and every action step or effect the write causes) carries the interaction
- * as provenance. The web runtime wraps event dispatch in this; it is dev-only
- * and safe to call with no engine enabled.
+ * @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 declare function withInteraction<T>(ref: InteractionRef, fn: () => T): T;
-/** `click on button#next "Next →"`, `effect "syncTitle"`, `action "save"`, … */
+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;
-    subscribe(listener: (event: RerunEvent) => void): () => void;
-    history(): readonly RerunEvent[];
-    /** Re-run history for one node — pass a memo/effect accessor or raw node. */
-    why(target: unknown): RerunEvent[];
-    /** Current dependency names of one scope — the devtools subscription view. */
-    subscriptions(target: unknown): string[];
     /**
-     * Aggregated cost tables since enable(): `scopes` ranked by self-time
-     * (with `wastedMs` = time spent on unchanged-value runs), `writes` ranked
-     * by total downstream re-run time each root write caused.
+     * Deliver records as they complete — see `AttributionRecords`. The bare
+     * form is `subscribe("rerun", …)`. Records are the same objects the ring
+     * buffers hold (`history()`, `interactions()`, `holds()`, `navigations()`),
+     * delivered synchronously from the engine, so a listener must not write
+     * signals. All subscriptions are dropped by `disable()`.
      */
-    costs(): {
-        scopes: ScopeCost[];
-        writes: WriteCost[];
-    };
+    subscribe(listener: (event: RerunEvent) => void): () => void;
+    subscribe<K extends AttributionRecordType>(type: K, listener: (record: AttributionRecords[K]) => void): () => void;
+    history(): readonly RerunEvent[];
     /**
      * Every graph-provable sequential flight chain observed since enable()
      * (ring-buffered like history()). Facts, not verdicts: chains are recorded
@@ -309,18 +336,25 @@ export interface Attribution {
      */
     holds(): readonly HoldEvent[];
     /**
-     * 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. Two more tables round out the picture: `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.
+     * Every navigation a router declared via `withOrigin` since enable()
+     * (ring-buffered like history()), settled or not: what route, under which
+     * interaction, how many writes, and — once its writes are through — how
+     * long that took and how (`committed` in a plain drain, `held` behind
+     * route data with the HoldEvent attached, or `superseded` by a later
+     * navigation before it landed). Facts for any consumer that wants
+     * navigation spans named by route: no router integration needed.
      */
-    feedback(): AttributionFeedbackTables;
+    navigations(): readonly NavigationEvent[];
+    /**
+     * Every user interaction a runtime declared via `withInteraction` since
+     * enable() (ring-buffered like history()), settled or not: what was
+     * dispatched, when, what it wrote, the re-runs and creations it caused,
+     * the holds its writes waited in and the navigations it performed — and,
+     * once all of that is through, how long the person waited (`settledMs`)
+     * and how it ended (`idle` / `committed` / `held`). The per-dispatch
+     * record `feedback().interactions` folds by name.
+     */
+    interactions(): readonly InteractionEvent[];
     /**
      * Cooperative preload declaration: stamp a flight object (promise or async
      * iterable) with its true kickoff time BEFORE the reactive graph sees it.
@@ -330,18 +364,9 @@ export interface Attribution {
      * is then judged against the real start — work already in the air when its
      * upstream landed is parallel, never a waterfall link. Callable while
      * attribution is disabled (marks made at navigation time must survive a
-     * later enable()). Dev-only, like the whole DEV surface.
+     * later enable()).
      */
     markFlight(flight: object, startedAt?: number): void;
-    /**
-     * 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. Callable while attribution is disabled.
-     */
-    withInteraction: typeof withInteraction;
-    format: typeof formatRerun;
-    formatOrigin: typeof formatOrigin;
 }
 /** One landed flight: its node name, wall duration, and upstream chain. */
 export interface FlightLink {
@@ -362,10 +387,13 @@ export interface HeldWrite {
 }
 export interface HoldEvent {
     /**
-     * Wall time the user waited: from the interaction that performed the held
-     * writes when one is known (`interaction.at`) or the first flush that
-     * parked them, whichever is earlier, to the commit.
+     * When the wait began (`performance.now()` clock): the interaction that
+     * performed the held writes when one is known (`interaction.at`) or the
+     * first flush that parked them, whichever is earlier. `at + holdMs` is the
+     * commit.
      */
+    at: number;
+    /** Wall time the user waited: `at` to the commit. */
     holdMs: number;
     /**
      * The quiescent tail: from the LAST held write to join (the user's final
@@ -375,6 +403,13 @@ export interface HoldEvent {
     tailMs: number;
     /** The user interaction whose writes were held, when the stamp is known. */
     interaction?: ChangeOrigin;
+    /**
+     * The declared unit of work the held writes belong to — the `navigation`
+     * a router described via `withOrigin` — when one is known. What names the
+     * hold by route (`navigation to /users/:id`) rather than by signal; the
+     * same object as `navigations()[].origin`, so the two join by identity.
+     */
+    origin?: ChangeOrigin;
     /** Flushes that ended with the hold still open. */
     flushes: number;
     /** Root signal writes staged behind the hold (the user's unanswered input). */
@@ -382,11 +417,12 @@ export interface HoldEvent {
     /** Async nodes the hold waited on (union across its parked flushes). */
     blockers: string[];
     /**
-     * Feedback the graph provably rendered for this hold, as `"<kind>:<node>"`
-     * — `isPending:posts`, `latest:page`, `optimistic:todos`, `affects:list`.
-     * Empty and `paintedDuringHold === 0` is the SILENT_HOLD signature.
+     * Feedback the graph provably rendered for this hold — an `isPending()`
+     * reader, a `latest()` shadow, an optimistic value, an `affects()` mark —
+     * one entry per affordance, in the order found. Empty and
+     * `paintedDuringHold === 0` is the SILENT_HOLD signature.
      */
-    acknowledgedBy: string[];
+    acknowledgements: Acknowledgement[];
     /**
      * Effect callbacks that ran inside the hold's parked flushes. Mainline
      * effects are stashed while a hold is open, so these are lane effects —
@@ -398,98 +434,96 @@ export interface HoldEvent {
     /** The hold was opened (or joined) by an `action()`. */
     action: boolean;
 }
-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;
+/**
+ * One way the screen acknowledged a hold. `reader` is where it was painted —
+ * the owner path of the first effect the census found reading the
+ * affordance (`["<App>", "<Feed>", "effect"]`), so a consumer can say WHICH
+ * screen answered, not only that one did. Absent when the affordance was
+ * registered but the census found no reader through the graph (an optimistic
+ * store: its readers are proxy traps, not nodes). `feedback()` ranks
+ * acknowledgements by `kind:source` (`isPending:posts`).
+ */
+export interface Acknowledgement {
+    kind: "isPending" | "latest" | "optimistic" | "affects";
+    /** The node the affordance hangs on — the async source for `isPending`/`latest`, the optimistic/affected node otherwise. */
+    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;
+    to?: string;
+    params?: Readonly<Record<string, string | undefined>>;
+    /** When the redirect away from it was declared (`performance.now()` clock). */
+    at: number;
+}
+export interface NavigationEvent {
+    /** The matched route pattern the router gave — `/users/:id`. After a redirect, the final one. */
+    name?: string;
+    to?: string;
+    from?: string;
+    params?: Readonly<Record<string, string | undefined>>;
+    /** When the navigation was requested (`performance.now()` clock). */
+    at: number;
+    /** The user interaction it ran under, when known — a link click. */
+    interaction?: ChangeOrigin;
+    /** Root writes the frame performed, redirect hops included. */
+    writes: number;
+    /** Destinations abandoned along the way, in order — present only when a redirect occurred. */
+    redirects?: NavigationHop[];
+    /**
+     * Wall time from the request to settle: the end of the drain that committed
+     * its writes, or the commit of the hold they waited in. `undefined` while
+     * unsettled.
+     */
+    settledMs?: number;
+    outcome?: "committed" | "held" | "superseded";
+    /** The hold its writes waited in, when hold tracking recorded one. */
+    hold?: HoldEvent;
     /**
-     * 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.
+     * The frame object its writes were stamped with — `ChangeRecord.origin` on
+     * each, `HoldEvent.origin` on the hold. Join key, by identity.
      */
-    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;
+    origin: ChangeOrigin;
 }
-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. */
+export interface InteractionEvent {
+    /** Event type — `click`, `keydown`, `input`… */
+    name: string;
+    /** The element hit, as the runtime described it — `button#next "Next →"`. */
+    target?: string;
+    /** Dispatch time (`performance.now()` clock). */
+    at: number;
+    /** Wall time of the handler itself, dispatch to return. */
+    handlerMs: number;
+    /** Root writes attributed to the frame: the handler's, and those of frames it opened (a navigation). */
+    writes: number;
+    /** Re-runs traced back to this interaction while the record was open. */
     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;
+    /** Computations created in those runs or in the frame's flushes (the "create 1,000 rows" work). */
+    created: number;
+    /** Summed self-time of `runs` and `created` (ms). Quantized per run; `settledMs` is the wall clock. */
+    runMs: number;
+    /** Holds its writes waited in, in settle order. */
+    holds: HoldEvent[];
+    /** Navigations performed under it, in open order. */
+    navigations: NavigationEvent[];
     /**
-     * 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.
+     * Dispatch to settle: the handler's return when it wrote nothing, the end of
+     * the drain that committed its writes, or the commit of the last hold they
+     * waited in — whichever came last. `undefined` while unsettled.
      */
-    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;
+    settledMs?: number;
+    outcome?: "idle" | "committed" | "held";
     /**
-     * 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.
+     * The frame object every downstream fact carries — `ChangeOrigin.interaction`
+     * on writes and frames, `RerunEvent.interaction`, `HoldEvent.interaction`,
+     * `NavigationEvent.interaction`. Join key, by identity.
      */
-    flashes: number;
-}
-export interface AttributionFeedbackTables {
-    sources: FeedbackSource[];
-    interactions: FeedbackInteraction[];
-    /** Async sources ranked by abandoned flights, then by flights. */
-    flights: FlightStats[];
-    /** Loading boundaries ranked by flashes, then by time shown. */
-    fallbacks: FallbackStats[];
+    origin: ChangeOrigin;
 }
+/** @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

@@ -113,6 +113,59 @@ export declare const CONFIG_HELD_TRUTH: number;
  * unobserved closure, NodeExtension) were the measured create-floor bytes
  * (warm dbmon profile: store node machinery ~36% + GC ~29%). */
 export declare const CONFIG_SLOT_NODE: number;
+/** Optimistic node whose own source arrived with a value DIFFERENT from its
+ * active override (A18 supersession, #3331). The override survives only as
+ * the displayed value — untracked reads and the applied frame keep it until
+ * the owning transaction commits — while the graph has already moved to the
+ * staged truth in `_pendingValue`: tracked readers see it and the corrected
+ * cascade is that transaction's held work. Set by the two own-source write
+ * 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
+ * committed `_value` is stale against them. Governs read()'s reveal
+ * carve-out: a stale (render) reader in some OTHER transaction may show a
+ * foreign-held pending node's committed value — parallel transactions, no
+ * entanglement — only while that value is coherent with the visible frame,
+ * i.e. while the flight's inputs are themselves held (unpublished) and not
+ * 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;
@@ -121,6 +174,9 @@ export declare const EFFECT_PURE = 0;
 export declare const EFFECT_RENDER = 1;
 export declare const EFFECT_USER = 2;
 export declare const EFFECT_TRACKED = 3;
+/** OR-ed into the `type` a lane passes to its effect runners: lane runs
+ * apply ahead of their transaction and are exempt from ownership parking. */
+export declare const LANE_RUN = 4;
 export declare const NOT_PENDING: {};
 export declare const NO_SNAPSHOT: {};
 /**