@solidjs/signals 2.0.0-rc.2 → 2.0.0-rc.20

package/dist/types/affects-marks.d.ts

@@ -0,0 +1,14 @@
+import type { Computed, Signal } from "./core/types.js";
+export type Marked = Signal<any> | Computed<any>;
+/** The verdict readers downstream of `node` — through derivations, stopping
+ * at effects — re-derive: the mark's one notification (a probe's answer
+ * changed with no value notifying anyone). Truth readers (`until`, the
+ * `refresh` waiter) too, which a lagging flight parked (deferred.ts) — but
+ * not through a derived store, whose leaves change only once its derive
+ * re-runs: they re-derive at that write. */
+export declare function repoll(node: Marked, seen?: Set<Computed<any>>, readers?: number): void;
+/** One mark on `node`. The declarer repolls once its bookkeeping is done. */
+export declare function mark(node: Marked): void;
+/** Drops one mark from `node`: true when it was the last — the node's
+ * verdict readers have re-derived. */
+export declare function unmark(node: Marked): boolean;

package/dist/types/affects.d.ts

@@ -1,28 +1,16 @@
 import type { Accessor } from "./signals.js";
-import { type Store } from "./store/store.js";
+import { type Store } from "./store/types.js";
 /**
- * Declares that in-flight work will change the targeted data: the named
- * slot(s) — and everything DERIVED from them — read as pending
- * (`isPending` → `true`) from the declaration until the surrounding
- * transaction settles or reverts. A mark lives on its own channel — a
- * refcount on the marked node plus dep-graph reachability in the verdict
- * layer — so the marked values themselves stay readable (a mark is a promise
- * of change, not an absence of value), no reader ever suspends on one, and
- * completion/settlement accounting never sees one. This is the declaration
- * verb of the pending model — additive only. A mark can turn pending ON for
- * data the graph can't see changing yet; nothing can turn pending OFF while
- * a real change is in flight — a quiet `refresh()` re-ask under a mark still
- * reads pending (declaring the reload is what makes it a real question).
- *
- * Targets:
- * - `affects(store)` — a store proxy (any record, root or nested): every
- *   record reachable from it at declaration time reads pending, including
- *   through captured child proxies (e.g. `<For>` rows). Siblings are
- *   untouched; records added after the declaration are not covered.
- * - `affects(record, key)` — exactly the named slot of the record. One key
- *   per call (keys do NOT form a path — target the owning record directly).
- * - `affects(accessor)` — a source accessor (signal or memo): the source
- *   reads pending.
+ * Declares that in-flight work will change the targeted data: the source —
+ * and everything derived from it — reads as pending (`isPending` → `true`)
+ * from the declaration until the surrounding transaction settles — or, if
+ * the source's own fetch is still in flight then (a declared reload's
+ * `refresh()`), until that fetch lands. A mark is a promise of change, not an absence of value: the marked values stay
+ * readable, no reader suspends on one, and it holds nothing — the
+ * transaction's completion never waits on a mark. Pendingness is additive:
+ * a mark can turn pending on for data the graph cannot see changing yet
+ * (a declared reload's `refresh()` is a quiet re-ask on its own); nothing
+ * turns it off while the mark is live.
  *
  * Typically called at the top of an `action` alongside optimistic writes —
  * both are up-front declarations about the same mutation. Outside any
@@ -30,14 +18,8 @@ import { type Store } from "./store/store.js";
  *
  * @example
  * ```ts
- * const send = action(function* (text: string) {
- *   setState(s => { s.messages.push({ text, status: "sending" }); });
- *   affects(state.messages.at(-1)!, "status"); // this slot pends until settle
- *   yield api.send(text);
- * });
- *
  * const reload = action(function* () {
- *   affects(thing);      // the whole store pends…
+ *   affects(thing);      // `thing` and its derivations pend…
  *   refresh(thing);      // …over this otherwise-quiet re-ask
  *   yield api.done();
  * });

package/dist/types/attribution.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `@solidjs/signals/attribution` — the "why did this run" engine.
+ *
+ * A separate entry on purpose: the core ships only the hook slot
+ * (`OBSERVE.attribution`, which `enable()` installs into) and the declared
+ * frames (`withInteraction`, `withOrigin`); the engine that turns hook facts
+ * into re-run explanations, cost tables, holds and feedback lives here, so an
+ * observe build carries it only when something imports this module. The dev
+ * and observe tiers resolve to this file; the prod tier resolves to
+ * `attribution.prod.ts`, an inert engine with the same surface, so app code
+ * can import it unconditionally.
+ */
+export { attribution, formatOrigin, formatRerun, graphSize } 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, AttributionValues, ChangeKind, ChangeOrigin, ChangeRecord, CreateEvent, EffectRunEvent, FallbackEvent, FlightEvent, FlightLink, FlushEvent, GraphEvent, GraphSize, HeldWrite, HistoryRecords, HistoryType, 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";

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

@@ -0,0 +1,22 @@
+/**
+ * `@solidjs/signals/attribution` as the prod tier resolves it.
+ *
+ * A prod build has no hook sites — `__OBSERVE__` folded every one out — so an
+ * engine installed there would never hear a fact. Rather than make apps guard
+ * the import per tier, prod resolves this inert twin: the same `Attribution`
+ * surface, every query empty, `enable()` a no-op. Type-checked against the
+ * 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 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 declare const graphSize: typeof Engine.graphSize;
+export type { Acknowledgement, Attribution, AttributionOptions, AttributionValues, ChangeKind, ChangeOrigin, ChangeRecord, CreateEvent, EffectRunEvent, FallbackEvent, FlightEvent, FlightLink, FlushEvent, GraphEvent, GraphSize, HeldWrite, HistoryRecords, HistoryType, 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";

package/dist/types/boundaries.d.ts

@@ -1,55 +1,84 @@
-import { Queue, type Computed, type Effect } from "./core/index.js";
-import type { Signal } from "./core/index.js";
+import { type Transaction } from "./core/scheduler.js";
+import type { Computed, Owner, Signal } from "./core/types.js";
 import { type Accessor } from "./signals.js";
-export interface BoundaryComputed<T> extends Computed<T> {
-    _propagationMask: number;
-}
-type RevealSlot = CollectionQueue | RevealController;
-type BoolAccessor = () => boolean;
-export type RevealOrder = "sequential" | "together" | "natural";
-type OrderAccessor = () => RevealOrder;
-export declare class RevealController {
-    _orderAccessor: OrderAccessor;
-    _collapsedAccessor: BoolAccessor;
-    _slots: RevealSlot[];
-    _parentController?: RevealController;
-    _disabled: Signal<boolean>;
-    _collapsed: Signal<boolean>;
-    _ready: boolean;
-    _minimallyReady: boolean;
-    _evaluating: boolean;
-    constructor(order: OrderAccessor, collapsed: BoolAccessor);
-    _forEachOwnedSlot(fn: (slot: RevealSlot) => boolean | void): boolean;
-    _isReady(): boolean;
-    /**
-     * "Minimally ready" = this group has something visible to show under its own policy.
-     * Used by an enclosing `together` group to decide when it can release.
-     * - `together`: every direct slot is minimally ready.
-     * - `sequential`: the first owned slot is minimally ready (frontier can advance).
-     * - `natural`: any owned slot is minimally ready.
-     */
-    _isMinimallyReady(): boolean;
-    _register(slot: RevealSlot): void;
-    _unregister(slot: RevealSlot): void;
-    _evaluate(disabledOverride?: boolean, collapsedOverride?: boolean): void;
-}
-export declare class CollectionQueue extends Queue {
-    _collectionType: number;
-    _sources: Set<Computed<any>>;
-    _tree?: BoundaryComputed<any>;
-    _pending: boolean;
-    _disabled: Signal<boolean>;
-    _error?: Signal<unknown>;
-    _collapsed: Signal<boolean>;
-    _revealController?: RevealController;
+interface Boundary {
+    /** STATUS_PENDING (loading) or STATUS_ERROR. */
+    _type: number;
+    _parent: Boundary | null;
+    _owner: Owner;
+    _tree: Computed<any>;
+    /** Null during the output's first pass (its post-check decides then). */
+    _output: Computed<any> | null;
+    /** Frame readers under it carrying its status: caught, or (loading,
+     * showing content) forwarded — the `on` re-arm collects those. Each maps
+     * to what it waits on: itself, or (error) the source that threw. */
+    _readers: Map<Computed<any>, Computed<any>>;
+    /** Loading: has shown content. Fresh again after an `on` re-arm found
+     * something pending. */
     _initialized: boolean;
-    _onFn: (() => any) | undefined;
-    _prevOn: any;
-    constructor(type: number);
-    run(type: number): void;
-    notify(node: Effect<any>, type: number, flags: number, error?: any): boolean;
-    _checkSources(): void;
+    /** Loading: `on` changed this flush — collecting until the seam. */
+    _armed: boolean;
+    /** The lane the arming pass was work of (a display-ahead read in `on`:
+     * `latest`, `isPending`): the swap it causes is that lane's — shown now,
+     * beside the held frame — not the frame's. `_lane` is set when the arm
+     * flips the boundary and consumed by the swap pass. */
+    _armLane: Transaction | null;
+    _lane: Transaction | null;
+    /** DEV: the arm was display-ahead (a lane) — the fallback shows now,
+     * whatever holds the frame; no LOADING_ON_OUTSIDE_HOLD report. */
+    _ahead?: boolean;
+    /** The output's last pass chose the fallback: readers under it are off
+     * screen (`hiddenBy`). */
+    _fallback: boolean;
+    /** User effects whose run came due behind the fallback: re-queued at the
+     * reveal (`heldRun`). */
+    _runs: Set<Computed<any>> | null;
+    /** Reveal order (reveal.ts): the controller that owns this slot until it
+     * has shown content, and the state it forces — the fallback (`_gated`),
+     * or nothing at all (`_collapsed`). */
+    _reveal: object | null;
+    _gated: boolean;
+    _collapsed: boolean;
+    _error: Signal<unknown> | null;
+    _show: (b: Boundary) => unknown;
+    /** The fallback's own computed, in its own scope like `Show`'s function
+     * child: instantiated once per show and kept across the output's
+     * re-derives while it shows (#3991). */
+    _fb: Computed<unknown> | null;
+}
+/** Context key: the reveal controller a Loading boundary created here is a
+ * slot of (reveal.ts); a boundary clears it for its content — only direct
+ * children are slots. */
+export declare const REVEAL: unique symbol;
+/** Reveal order (reveal.ts), installed when something imports
+ * `createRevealOrder`: a Loading boundary registers as a slot of the
+ * controller in its context, tells it when its readiness changed, and
+ * leaves it when it has shown content. */
+export interface RevealHooks {
+    _register(controller: object, b: Boundary): void;
+    _unregister(controller: object, b: Boundary): void;
+    _changed(controller: object): void;
 }
+export declare let revealHooks: RevealHooks | null;
+export declare function setRevealHooks(h: RevealHooks): void;
+export type { Boundary };
+export declare function redraw(b: Boundary): void;
+/** Drop the readers that settled or died. Settled: a loading reader no
+ * longer pending; an error's source neither errored nor in flight. A reader
+ * that landed but is held (its value staged in a transaction) is not: the
+ * content reveals at the commit, with its run. The tree is: the output reads
+ * it and enters the transaction itself (its committed value shows until the
+ * landing). The statuses that keep a reader: pending — and its error, for an
+ * error boundary (`_type` is the status it catches) — on the reader or its
+ * source. A reader pending again after the source that threw answered (it
+ * re-asks through a memo that carried the error) has no new answer yet: the
+ * error stays the display (D-39: a pending is not a value; async-gen 91501
+ * #1831). */
+export declare function prune(b: Boundary, pass: boolean): number;
+/** Reveal order: a slot is ready when its content can show — it has shown
+ * content, or nothing under it is unready (the tree neither pending nor
+ * born held, no reader waited on). */
+export declare function ready(b: Boundary): boolean;
 /**
  * Lower-level primitive that backs the `<Loading>` flow control. Catches
  * pending async reads inside `fn` and renders `fallback` until they settle.
@@ -59,8 +88,27 @@ export declare class CollectionQueue extends Queue {
  *
  * @param fn the tracked subtree
  * @param fallback the fallback shown while async reads in `fn` are unresolved
- * @param options `on` — accessor whose value scopes the boundary; when set,
- *   transitions caused by writes to other reactive sources are *not* caught
+ * @param options `on` — a dependency list: a tracked function whose reads
+ *   re-arm the boundary. Its return value is irrelevant (never compared);
+ *   what matters is what it reads. Without `on`, a boundary that has shown
+ *   content keeps it through a refetch (the pending holds with the
+ *   transaction). With `on`, a write to anything it reads makes the boundary
+ *   fresh again: it stops waiting on its current content, and if something
+ *   under it is pending it shows `fallback` until the new content is ready;
+ *   if nothing is pending, the notification is a no-op. The fallback lands
+ *   with the same frame as the change that caused it — now, when nothing
+ *   else holds that frame; together with the rest of the new page during a
+ *   held navigation, not before it. If the same data is also read outside
+ *   the boundary, the frame waits on it and the fallback can never be seen
+ *   (DEV warns `LOADING_ON_OUTSIDE_HOLD`); the fix is structural — move the
+ *   outside read under the boundary so one hold owns the data. A frame held
+ *   past the content's landing by something else (the write's action, other
+ *   pending data) also shows no fallback; that is a race the fallback may
+ *   lose, a legitimate outcome, and not reported. A display-ahead read in
+ *   `on` (`latest()`) shows the fallback now, beside the held frame; that
+ *   is a capability, not the recommended shape. Optimistic writes and a
+ *   source going pending notify like any other. The children are not
+ *   re-created — they stay alive behind the fallback.
  *
  * @example
  * ```tsx
@@ -100,76 +148,3 @@ export declare function createLoadingBoundary<T, U>(fn: () => T, fallback: () =>
  * ```
  */
 export declare function createErrorBoundary<T, U>(fn: () => T, fallback: (error: Accessor<unknown>, reset: () => void) => U): Accessor<T | U>;
-/**
- * Coordinate the reveal timing of sibling loading boundaries.
- *
- * Accepts reactive accessors:
- * - `order`: `"sequential"` (default) | `"together"` | `"natural"`.
- *   - `"sequential"` — classic frontier reveal: siblings reveal in registration order
- *     as each resolves; later siblings stay hidden until earlier ones complete.
- *   - `"together"` — every direct slot stays on its fallback until the whole group
- *     is "minimally ready" (each direct slot has produced its own first visible
- *     content under its own order), then the whole group releases at once.
- *   - `"natural"` — children reveal independently (as each resolves). At the top
- *     level this is a no-op compared to not using `createRevealOrder`; the mode
- *     exists for nesting, where the group registers as a single composite slot to
- *     any enclosing `createRevealOrder`.
- * - `collapsed`: only meaningful when `order === "sequential"`. When set, tail siblings
- *   past the frontier suppress their own fallback output. Ignored under `"together"`
- *   and `"natural"` — those orders have no frontier.
- *
- * Nested `createRevealOrder` groups compose: the inner controller registers as a
- * single slot in the outer controller and is held on its fallbacks until the outer
- * releases that slot. Once released, the inner controller runs its own order locally
- * over anything still pending. There is no opt-out from an outer hold.
- *
- * "Minimally ready" is what an order considers its first visible content:
- * - `sequential` — frontier-0 is minimally ready (leaf: on resolve; nested: via its
- *   own minimal signal).
- * - `together` — every direct slot is minimally ready.
- * - `natural` — any direct slot has visible content (leaves on resolve; nested
- *   composites via their own minimal signal).
- *
- * @example
- * ```ts
- * // Primitive form of `<Reveal>` — coordinate sibling loading boundaries
- * // programmatically. App code uses the JSX `<Reveal>` component instead.
- * // Both options are accessors so they can react to state changes.
- * createRevealOrder(
- *   () => renderSiblings(),
- *   { order: () => mode(), collapsed: () => true }
- * );
- * ```
- */
-export declare function createRevealOrder<T>(fn: () => T, options?: {
-    order?: OrderAccessor;
-    collapsed?: BoolAccessor;
-}): T;
-/**
- * Resolves a children value to its renderable form: unwraps zero-arg functions
- * (accessors), recursively flattens arrays, and optionally skips
- * non-rendering values (`null`, `undefined`, `true`, `false`, `""`).
- *
- * Used internally by flow components and by the renderer to walk a children
- * tree. App code rarely needs this directly — see `children()` in `solid-js`
- * for the user-facing helper that memoizes the result.
- *
- * @param children value or array of values to flatten
- * @param options
- *   - `skipNonRendered` — drop values that won't render
- *   - `doNotUnwrap` — leave function children as-is (caller will resolve)
- *
- * @example
- * ```ts
- * // Custom renderer walking a children tree manually. Most authors should
- * // use `children()` from solid-js, which memoizes the resolved value.
- * function renderChildren(value: unknown): unknown {
- *   return flatten(value, { skipNonRendered: true });
- * }
- * ```
- */
-export declare function flatten(children: any, options?: {
-    skipNonRendered?: boolean;
-    doNotUnwrap?: boolean;
-}): any;
-export {};

package/dist/types/carved.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -16,26 +16,40 @@
  * submission tracking layered on top. The shared name is deliberate.
  *
  * Wraps a generator function so each invocation runs as a single transaction
- * (a "transition") that batches every signal/store write between yields. The
- * surrounding UI sees one atomic update per yielded step; nothing is committed
- * until the action either completes or the next `yield` resolves.
+ * that holds every signal/store write between yields. The surrounding UI sees
+ * one atomic update when the action completes; nothing is committed until
+ * every action in the transaction has returned.
  *
  * `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. `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));
  * ```
  *
+ * The same holds inside an async helper the action yields
+ * (`yield (async () => { ... })()`): everything after its first `await` runs
+ * outside the transaction. An `await refresh(x)` or `await until(...)` there
+ * waits for this action's commit, which waits on the helper, so it hangs
+ * whenever `x` re-ran during the action (#4263) and works otherwise. Call
+ * `refresh(x)` in the generator once the helper returns; `yield` it only when
+ * the action needs the fresh value.
+ *
  * (For the same reason, don't call `flush()` inside an action body — it
- * drains the transaction mid-step.)
+ * cannot reveal the held writes and is refused.)
  *
  * Each call returns a `Promise` that resolves with the generator's return
  * value, or rejects if it throws. Pair with `createOptimistic` /

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

@@ -1,21 +1,49 @@
 import { NotReadyError } from "./error.js";
-import { type OptimisticLane } from "./lanes.js";
 import type { Computed, Link } from "./types.js";
 export declare function addPendingSource(el: Computed<any>, source: Computed<any>): boolean;
+export declare function removePendingSource(el: Computed<any>, source: Computed<any>): boolean;
 /**
  * A loading-window node hit an unready source (sync throw in recompute, or a
  * NotReadyError-rejected flight): register for the source's settle — the
  * settlePendingSource walk runs off `_pendingSources` + `_blocked` alone —
- * with NO read-visible pending status, no downstream propagation, no
- * transition, no lane registration. Commit #0 keeps serving.
+ * with NO read-visible pending status and no downstream propagation. Commit
+ * #0 keeps serving.
  */
 export declare function parkLoadingWindow(el: Computed<any>, e: NotReadyError): void;
 export declare function setPendingError(el: Computed<any>, source?: Computed<any>, error?: any): void;
 export declare function forEachDependent(el: Computed<any>, fn: (node: Computed<any>, link: Link) => void): void;
+export declare function releaseIfSettledUnobserved(node: Computed<any>): void;
 export declare function releaseSettledDependents(el: Computed<any>): void;
+/** D-41: an error a pass of a held node found is an answer of
+ * that frame — it ends the wait like a value and shows when a value would.
+ * Staged like one: `_pendingValue` carries it (CONFIG_STAGED_ERROR), readers
+ * in the hold derive from it (`serve` throws it), and the commit publishes
+ * it through the ordinary error path (`commitPendingNode` → `notifyStatus`),
+ * dependents included. Not for a lane pass, nor a node with no shown value
+ * (born held — its error has no frame to wait behind): those publish now,
+ * as before. Returns whether the error was staged. */
+export declare function stageError(el: Computed<any>, error: any, inPass?: boolean): boolean;
 export declare function settleErroredDependents(el: Computed<any>, error: any): void;
-export declare function settlePendingSource(el: Computed<any>): void;
+export declare function settlePendingSource(el: Computed<any>, source?: Computed<any>): void;
 export declare function isThenable<T>(value: T | PromiseLike<T>): value is PromiseLike<T>;
-export declare function handleAsync<T>(el: Computed<T>, result: T | PromiseLike<T> | AsyncIterable<T>, setter?: (value: T) => void): T;
+/** Fire and clear a node's iterator-flight cancellation hook (#3122). */
+export declare function releaseFlightTeardown(el: Computed<any>): void;
+/**
+ * Internal (not a package export): run `fn` when the current pass's flight
+ * is superseded, at the same instant as the iterator close above, instead of
+ * when the replacing pass commits (owner cleanups wait for that). Chains onto
+ * the node's teardown slot; fires once with it. A no-op unless the ambient
+ * owner is a computed in its own pass. `consumeIterator` fills the slot
+ * before its first pull, so a source opened in an async generator's body
+ * (`for await`) composes after the generator's close.
+ */
+export declare function onSupersede(fn: () => void): void;
+export declare function handleAsync<T>(el: Computed<T>, result: T | PromiseLike<T> | AsyncIterable<T>, setter?: (value: T) => void, onError?: (error: unknown, pending: boolean) => void): T;
 export declare function clearStatus(el: Computed<any>, clearUninitialized?: boolean): void;
-export declare function notifyStatus(el: Computed<any>, status: number, error: any, blockStatus?: boolean, lane?: OptimisticLane): void;
+export declare function notifyStatus(el: Computed<any>, status: number, error?: any): void;
+/** The dependents' half of `notifyStatus`: `el`'s status reaches each
+ * subscriber as a propagated mark (or a re-derive). On its own for a store
+ * family's leaves, which are not the derive's dependents — the family
+ * propagates the derive's status from each leaf to the leaf's readers
+ * (store/projection.ts `wakeFamily`), exactly as a memo's would reach its. */
+export declare function propagateStatus(el: Computed<any>, status: number, error: any): void;

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;