@solidjs/signals 2.0.0-rc.13 → 2.0.0-rc.15

package/dist/prod/store/storePath.js

@@ -1,4 +1,4 @@
-import { isWrappable, ownEnumerableKeys } from "./store.js";
+import { isWrappable, ownEnumerableKeys } from "./types.js";
 
 const DELETE = Symbol(0);
 

package/dist/{observe/store/next → prod/store}/target.js

@@ -14,33 +14,29 @@
  */
 const $OWNER = Symbol(0);
 
-/** raw → target for UNOWNED backings (user-ingested, adopted); owned
- * backings resolve through their `$OWNER` stamp. Boundary mechanism (O8). */ const storeNextLookup = new WeakMap;
+/** raw → target for plain (family-less) stores. Family stores use their own
+ * map so one raw can wrap once per family (§7b). */ const storeLookup = new WeakMap;
 
-/** A backing the store allocated and may mutate in place. */ function isOwned(e) {
+function setLookup(e, o) {
+    (o.fam?.map ?? storeLookup).set(e, o);
+}
+
+function isOwned(e) {
     return e[$OWNER] !== undefined;
 }
 
-/** raw → target within a family (`null` = plain stores / the global map).
- * The stamp answers for backings owned by a target OF THAT FAMILY; anything
- * else (user objects, adoptees, another family's backings the family
- * re-registered for its own wrapper) resolves through the family's map. */ function lookupTarget(e, o) {
+/** The target wrapping `raw` in `fam` (or the plain lookup). An owned raw
+ * answers from its stamp; a user raw from the map. */ function lookupTarget(e, o) {
     const t = e[$OWNER];
-    return t !== undefined && t.fam === o ? t : (o?.map ?? storeNextLookup).get(e);
+    return t !== undefined && t.fam === o ? t : (o?.map ?? storeLookup).get(e);
 }
 
 function devAssertNeverUserMutation(e) {
     return;
 }
 
-let optHooks = null;
-
-function setOptHooks(e) {
-    optHooks = e;
-}
-
-/** Sticky descendants flag walk (§6d): reconcile's keyed pruning descends
- * only where subscriptions exist at/below. Nodes AND patches count. */ function markDescendants(e) {
+/** Sticky descendants flag up the parent chain (§6d): adoption descends
+ * into a changed child pair only where a target with nodes exists below. */ function markDescendants(e) {
     let o = e;
     while (o && !o.d) {
         o.d = true;
@@ -48,4 +44,4 @@ function setOptHooks(e) {
     }
 }
 
-export { $OWNER, devAssertNeverUserMutation, isOwned, lookupTarget, markDescendants, optHooks, setOptHooks, storeNextLookup };
+export { $OWNER, devAssertNeverUserMutation, isOwned, lookupTarget, markDescendants, setLookup, storeLookup };

package/dist/prod/store/types.js

@@ -0,0 +1,73 @@
+/** Brand keys the proxy answers directly (never user data). */
+const $TRACK = Symbol(0), $TARGET = Symbol(0), $PROXY = Symbol(0), $RECORD = Symbol(0);
+
+// ---------------------------------------------------------------------------
+// raw marking (R42 / RUL-12: a value is never both wrapped and raw)
+const rawValues = new WeakSet;
+
+let rawValuesUsed = false;
+
+function isRawValue(e) {
+    return rawValuesUsed && rawValues.has(e);
+}
+
+/** Mark a value so no store ever wraps it (sticky; it reads as a leaf). */ function markRaw(e) {
+    if (isWrappable(e)) {
+        rawValuesUsed = true;
+        rawValues.add(e);
+    }
+    return e;
+}
+
+/** A shallow store's ingested record: raw by contract (values served
+ * verbatim, slots replaced by reference). */ function markRawOne(e) {
+    if (isWrappable(e)) {
+        if (e[$TARGET] !== undefined) return;
+        rawValuesUsed = true;
+        rawValues.add(e);
+    }
+}
+
+function markRawIngest(e) {
+    if (Array.isArray(e)) {
+        for (let r = 0, a = e.length; r < a; r++) markRawOne(e[r]);
+    } else {
+        for (const r in e) markRawOne(e[r]);
+    }
+}
+
+// ---------------------------------------------------------------------------
+// wrappability
+const OBJECT_PROTO = Object.prototype;
+
+const wrappableProtos = new WeakMap;
+
+function isWrappable(e) {
+    if (e == null || typeof e !== "object" || Object.isFrozen(e)) return false;
+    const r = Object.getPrototypeOf(e);
+    if (r === OBJECT_PROTO || r === null) return true;
+    if (Array.isArray(e)) return true;
+    let a = wrappableProtos.get(r);
+    if (a === undefined) {
+        a = Object.prototype.toString.call(e) === "[object Object]" && (typeof Node === "undefined" || !(e instanceof Node));
+        wrappableProtos.set(r, a);
+    }
+    return a;
+}
+
+function ownEnumerableKeys(e) {
+    return Reflect.ownKeys(e).filter(r => Object.prototype.propertyIsEnumerable.call(e, r));
+}
+
+// ---------------------------------------------------------------------------
+// write override: a projection's draft ops carry it (the derive is the
+// author — its writes must land outside the sync setter scope too, in a
+// continuation after an `await`/`yield`). Projections return in S3; the
+// traps already honour it.
+let writeOverride = false;
+
+function setWriteOverride(e) {
+    writeOverride = e;
+}
+
+export { $PROXY, $RECORD, $TARGET, $TRACK, isRawValue, isWrappable, markRaw, markRawIngest, markRawOne, ownEnumerableKeys, rawValuesUsed, setWriteOverride, writeOverride };

package/dist/prod/store/utils.js

@@ -1,18 +1,8 @@
-import "../core/core.js";
-
 import { SUPPORTS_PROXY } from "../core/constants.js";
 
-import "../core/scheduler.js";
-
-import "../core/invariants.js";
-
-import "../core/verdict.js";
-
-import "../core/effect.js";
-
 import { createMemo } from "../signals.js";
 
-import { $PROXY, $RECORD, $TARGET, ownEnumerableKeys } from "./store.js";
+import { $PROXY, $RECORD, $TARGET, ownEnumerableKeys } from "./types.js";
 
 function trueFn() {
     return true;

package/dist/types/affects.d.ts

@@ -1,28 +1,15 @@
 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. 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 +17,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/boundaries.d.ts

@@ -1,109 +1,72 @@
-import type { OptimisticLane } from "./core/lanes.js";
-import { Queue, type Computed, type Effect, type Owner } 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>;
-    /** The output pass — fallback or content (createCollectionBoundary). */
-    _output?: Computed<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. */
+    _readers: Set<Computed<any>>;
+    /** Loading: has shown content. Fresh again after an `on` re-arm found
+     * something pending. */
     _initialized: boolean;
-    /** 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;
-    /** The lane the `on` pass that queued this re-arm ran under (onNode), if
-     * any: the fallback swap is display-ahead — shown through the lane. */
-    _rearmLane: OptimisticLane | null;
-    constructor(type: number);
-    run(type: number): void;
-    /** An `on` dependency notified (onNode → scheduler `pendingRearms`);
-     * drained after the heap, before the verdict, under the notifying write's
-     * transaction (#3540). A boundary showing content is fresh again: it
-     * releases its hold now and, if anything under it is still pending, swaps
-     * to its fallback. The swap is staged, so it lands with the write's frame
-     * — at once when nothing else holds it, with the rest of the new page
-     * when something outside the boundary does; if the pending lands first,
-     * `_checkSources` clears it and no fallback is shown. An `on` that read a
-     * lane (`latest()`, an optimistic write) asked for the change now:
-     * `_rearmLane` shows the swap through the lane, beside the held frame.
-     * Children stay alive behind the fallback. */
-    _rearm(): void;
-    /** Show the fallback: the swap the output pass selects on. Staged, it is
-     * the frame's and lands with its commit. Re-armed from a lane pass
-     * (`lane`), it is the current frame's — committed outright, as the lane's
-     * view already is on screen — and shown through the lane: the output pass
-     * publishes a derived override and its readers run from the lane's queue,
-     * at the park, ahead of the transaction (a lane pass reads staged plain
-     * writes committed, so a staged swap would be invisible to it). */
-    _swap(lane: OptimisticLane | null): void;
-    /** Retry the collected failures of an error boundary: recompute each
-     * source that threw, so the boundary can recover. */
-    _retry(): void;
-    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;
-    /** Has a collected source stopped counting for this boundary? A source
-     * with a live affects() mark holds display state for the mark's lifetime
-     * (the visual channel): the marked node carries no status of its own, so
-     * the count is the liveness test. The release sweep (finalizePureQueue
-     * after mark release) re-runs this check. A source born held under this
-     * boundary (recompute, #3540) carries no status either: it is collected
-     * while it has a staged value and no committed one, and released by the
-     * commit that initializes it. */
-    _settled(source: Computed<any>): boolean;
-    /** The pre-verdict sweep (scheduler run(), #3540): a collecting boundary
-     * whose OUTPUT is pending — its fallback read something not ready — is
-     * judged here, under the transaction. That output is what an initialized
-     * parent holds the frame on, and it derives from `_disabled`, not the
-     * tree: the tree settling never re-runs it, only a sweep does, and the
-     * commit sweep runs after the verdict the output's own read keeps parking
-     * — the content waited for the fallback's flight. Judged ready here, the
-     * boundary stages `_disabled` false with the frame and the output re-runs
-     * in this heap: it reads the tree and drops the fallback's read (recompute
-     * settles a pass's outgoing pending sources), so the verdict sees the
-     * release. A boundary showing a ready fallback parks nothing and keeps the
-     * commit sweep's reveal. */
-    _judgeHeld(): void;
-    _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 (`hidden`). */
+    _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;
+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.
@@ -173,76 +136,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,9 +16,9 @@
  * 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
@@ -28,8 +28,7 @@
  * 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
+ * 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:
@@ -42,7 +41,7 @@
  * ```
  *
  * (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,13 +1,12 @@
 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;
 /**
  * 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;
@@ -18,6 +17,12 @@ export declare function settlePendingSource(el: Computed<any>, source?: Computed
 export declare function isThenable<T>(value: T | PromiseLike<T>): value is PromiseLike<T>;
 /** Fire and clear a node's iterator-flight cancellation hook (#3122). */
 export declare function releaseFlightTeardown(el: Computed<any>): void;
-export declare function handleAsync<T>(el: Computed<T>, result: T | PromiseLike<T> | AsyncIterable<T>, setter?: (value: T) => void): T;
+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, blockStatus?: boolean): 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, downstreamBlockStatus?: boolean): void;

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

@@ -1,6 +1,10 @@
 import type { ChangeOrigin } from "./attribution.js";
-import type { Transition } from "./scheduler.js";
+import type { Transaction } from "./scheduler.js";
 import type { Computed, Owner, Signal } from "./types.js";
+/** The hold the engine records against (L2: scheduler.ts `Transaction`).
+ * Outward-facing language says *holds*; the engine's hook names keep their
+ * historical `transition` wording. */
+export type Transition = Transaction;
 /**
  * Observe-tier hook points for the reactive core.
  *
@@ -214,6 +218,21 @@ export interface InteractionRef {
     target?: string;
     /** Dispatch time on the `performance.now()` clock; defaults to now. */
     at?: number;
+    /**
+     * The dispatch this frame handles — the DOM `Event` itself. Frames with the
+     * same `event` are one interaction: the first opens the record (its `type`,
+     * `target` and `at` describe it) and every later one re-enters it, so each
+     * listener of one dispatch adds its work to one record. Such a record stays
+     * open for joining until the next task — every listener of a dispatch runs
+     * within its task — and is recorded no earlier; a frame for the event after
+     * that opens a new interaction. Without `event` the record is the frame's
+     * alone and can settle as it closes.
+     *
+     * A join key only, compared by identity and held weakly: it is never
+     * recorded — no `InteractionEvent`, origin or other record carries it — and
+     * the engine keeps no strong reference to it.
+     */
+    event?: object;
 }
 /**
  * A navigation, as a router describes it to `withOrigin` around the location