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

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

@@ -24,6 +24,16 @@ export declare function getOrCreateLane(signal: Signal<any>): OptimisticLane;
  * Union-find: find the root lane.
  */
 export declare function findLane(lane: OptimisticLane): OptimisticLane;
+/**
+ * Is the lane held? `_pendingAsync` records the async the lane OWNS (derived
+ * under it); the transaction's reporter map records the async a render effect
+ * OBSERVED pending with no boundary taking it (INV-3, the one registration
+ * site). A hold needs both — the same rule the transaction itself uses, so a
+ * memo nobody renders, or one a fallback-showing boundary caught, cannot tear
+ * a frame and holds nothing (#3289). An orphan lane has no observation record
+ * and never holds.
+ */
+export declare function laneHeld(lane: OptimisticLane): boolean;
 /**
  * Merge two lanes when their dependency graphs overlap.
  */

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

@@ -9,7 +9,11 @@ export declare let clock: number;
 export declare let activeTransition: Transition | null;
 export declare let projectionWriteActive: boolean;
 export declare let _hitUnhandledAsync: boolean;
-export declare function resetUnhandledAsync(): void;
+/**
+ * Consume the unhandled-async hit. Returns whether this is the first report
+ * of the current enforcement window — the caller warns only then.
+ */
+export declare function resetUnhandledAsync(): boolean;
 /**
  * Toggles the dev-mode "must be inside a `<Loading>` boundary" enforcement
  * window. Only `render()` calls this — wrapping the initial mount so that a
@@ -130,9 +134,10 @@ export declare class GlobalQueue extends Queue {
     static _laneReadsCommitted: ((el: OptimisticNode, owner: OptimisticNode, c: Computed<any>) => boolean) | null;
     static _recomputeLane: ((el: Computed<any>, own: boolean) => OptimisticLane | null | false) | null;
     static _laneAsyncPending: ((el: Computed<any>) => void) | null;
-    /** Authoritative-view reader wakeup (until()): installed at first until() call.
-     * Call sites are gated by CONFIG_AUTHORITATIVE_OBSERVED, which only until()'s
-     * carve-out read can set, so `!` invocations are safe once the gate holds. */
+    /** Authoritative-view reader wakeup: installed by until() and refresh() before
+     * their first read. Call sites are gated by CONFIG_AUTHORITATIVE_OBSERVED, which
+     * only such a reader's carve-out read can set, so `!` invocations are safe once
+     * the gate holds (#3303). */
     static _notifyAuthoritativeObservers: ((el: Signal<any> | Computed<any>) => void) | null;
     static _laneAsyncSettled: ((el: Computed<any>) => void) | null;
     static _trackOptimisticStore: ((store: any) => void) | null;
@@ -209,6 +214,11 @@ export declare const globalQueue: GlobalQueue;
  */
 export declare function flush(): void;
 export declare function flush<T>(fn: () => T): T;
+/** A fresh, unentered transaction (#3146): the optimistic store's truth
+ * flight DECLARES an owned transaction instead of relying on whatever the
+ * ambient adoption machinery stamped on its firewall. Activate it with
+ * initTransition; it is a plain batch until then. */
+export declare function createTransition(): Transition;
 export declare function currentTransition(transition: Transition): Transition;
 export declare function setActiveTransition(transition: Transition | null): void;
 export declare function runInTransition<T>(transition: Transition, fn: () => T): T;

package/dist/types/signals.d.ts

@@ -365,17 +365,6 @@ export declare function createMemo<T>(compute: ComputeFunction<undefined | NoInf
  * @description https://docs.solidjs.com/reference/basic-reactivity/create-effect
  */
 export declare function createEffect<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, effectFn: EffectFunction<NoInfer<T>, T> | EffectBundle<NoInfer<T>, T>, options?: EffectOptions): void;
-/**
- * @deprecated `createEffect(compute)` (single argument) is no longer supported.
- * Pass a separate effect function as the second argument:
- * `createEffect(compute, effect)`. See [MISSING_EFFECT_FN].
- *
- * - For a side effect that reacts to changes, split the work:
- *   `createEffect(() => signal(), value => doWork(value))`.
- * - For a derived value, use `createMemo(() => signal())`.
- * - For a one-shot side effect at construction time, just call the function.
- */
-export declare function createEffect<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>): never;
 /**
  * Creates a reactive computation that runs during the render phase as DOM elements
  * are created and updated but not necessarily connected.
@@ -410,6 +399,16 @@ export declare function createRenderEffect<T>(compute: ComputeFunction<undefined
  * Creates a tracked reactive effect where dependency tracking and side effects happen
  * in the same scope.
  *
+ * @deprecated Do not use in new code. For a side effect that follows reactive
+ * state, use `createEffect(compute, effect)` — it separates tracking from the
+ * side effect, knows its dependencies before it runs, and participates in
+ * async and transitions. For one-time DOM work after render (measuring,
+ * attaching third-party widgets to a ref), use `onSettled`. Tracking from
+ * inside the effect phase — the only thing this primitive adds — is retained
+ * solely to ease 1.x migration: it runs beside user-effect callbacks after
+ * values commit, never holds a transition, and cannot observe a write staged
+ * earlier in the same flush by a signal it has not read yet.
+ *
  * WARNING: Because tracking and effects happen in the same scope, this primitive
  * may run multiple times for a single change or show tearing (reading inconsistent
  * state). Use only when dynamic subscription patterns require same-scope tracking.

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

@@ -4,15 +4,12 @@ export { isWrappable, $TRACK, $PROXY, $TARGET } from "./store.js";
 import type { NoFn, ProjectionOptions, Store, StoreOptions, StoreSetter } from "./store.js";
 import type { Refreshable } from "../core/index.js";
 export { createProjectionNext as createProjection } from "./next/projection.js";
-export { registerPatch, registerRowOps, registerSlotPatchNext as registerSlotPatch, patchableRaw } from "./next/patch.js";
 export { storeIsShallow, storeHasFamily, storeHasOptimisticFamily } from "./next/store.js";
 export { createOptimisticStoreNext as createOptimisticStore } from "./next/optimistic.js";
-/** Public createStore: plain form `(init, options?)` and derived writable
+/** Public createStore: plain form `(initialValue, options?)` and derived writable
  * form `(fn, seed, options?)`. */
-export declare function createStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>, options?: StoreOptions & {
-    shallow?: boolean;
-}): [get: Store<T>, set: StoreSetter<T>];
-export declare function createStore<T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Refreshable<Store<T>>, set: StoreSetter<T>];
+export declare function createStore<T extends object = {}>(initialValue: NoFn<T> | Store<NoFn<T>>, options?: StoreOptions): [get: Store<T>, set: StoreSetter<T>];
+export declare function createStore<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Refreshable<Store<T>>, set: StoreSetter<T>];
 export declare function reconcile<T extends U, U>(value: T, key?: string | ((item: NonNullable<any>) => any) | null): (state: U) => T;
 export declare function snapshot<T>(value: T): T;
 export declare function deep<T>(value: T): T;

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

@@ -1,5 +1,6 @@
+import { type Refreshable } from "../../core/index.js";
 import { type Transition } from "../../core/scheduler.js";
-import { type NoFn, type ProjectionOptions, type Store, type StoreSetter } from "../store.js";
+import { type NoFn, type ProjectionOptions, type Store, type StoreOptions, type StoreSetter } from "../store.js";
 import type { StoreNextTarget } from "./target.js";
 /** #3164 fold: a stamped truth is HELD (masked from ordinary readers until
  * the reveal) only while its transition is live AND retaining optimism —
@@ -8,7 +9,8 @@ import type { StoreNextTarget } from "./target.js";
  * staged values to converge (normal speculation). Resolves merges first:
  * merge unions optimistic nodes/stores into the target. */
 export declare function transitionHoldsOptimism(transition: Transition): boolean;
-export declare function createOptimisticStoreNext<T extends object = {}>(first: T | ((store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>), second?: NoFn<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Store<T>, set: StoreSetter<T>];
+export declare function createOptimisticStoreNext<T extends object = {}>(initialValue: NoFn<T> | Store<NoFn<T>>, options?: StoreOptions): [get: Store<T>, set: StoreSetter<T>];
+export declare function createOptimisticStoreNext<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Refreshable<Store<T>>, set: StoreSetter<T>];
 /** Diff the draft against the current OPTIMISTIC VIEW (committed + active
  * overrides — the same view the draft was seeded from) and emit engine writes
  * for exactly the changed keys. Visible-view diffing keeps no-op writes from

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

@@ -1,17 +1,10 @@
-import type { RowOps } from "./patch.js";
-import { type StoreNextTarget } from "./target.js";
 type KeyFn = (item: any) => any;
 export declare function reconcileNextState(value: any, state: any, key: string | KeyFn | null | undefined, replace?: boolean): void;
+/** Setter-channel row ops (the fold site calls this for array targets with
+ * ops consumers): structural mutation through the setter — push/splice/index
 /** Key equality for EVERY key comparison in this module (re-audit 2, P1-5):
- * SameValueZero, matching the Map-based matchers (buildRowOps, the adoption
- * window) — NaN keys are equal to themselves, so aligned NaN rows stay
- * aligned in the prefix walk instead of forever misaligning. Adoption and
- * row ops MUST agree on key equality or retained DOM rows go stale. */
+ * SameValueZero, matching the adoption window's Map-based matcher — NaN keys
+ * are equal to themselves, so aligned NaN rows stay aligned in the prefix
+ * walk instead of forever misaligning. */
 export declare function sameKey(a: any, b: any): boolean;
-export declare function emitSetterRowOps(t: StoreNextTarget, prevRows: any[], nextRows: any[]): void;
-/** Identity-keyed structural diff, returned rather than emitted: shared by
- * the setter channel (regular queue) and the OPTIMISTIC write channel (lane
- * queue) — same retention semantics, different dispatch timing. Returns
- * null when the lists are identity-aligned (no structure changed). */
-export declare function buildIdentityRowOps(prevRows: any[], nextRows: any[]): RowOps | null;
 export {};

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

@@ -1,20 +1,14 @@
 import type { Signal } from "../../core/types.js";
-import { type StoreNextFamily, type StoreNextTarget, type PatchChannel } from "./target.js";
-/** Lazily allocate the patch-channel extension (one literal shape). */
-export declare function pcOf(t: StoreNextTarget): PatchChannel;
+import { type StoreNextFamily, type StoreNextTarget } from "./target.js";
 export declare function wrapNext<T extends Record<PropertyKey, any>>(value: T, parent?: StoreNextTarget | null, parentKey?: PropertyKey | null, fam?: StoreNextFamily | null): T;
 /** Unwrap our own proxies to their current backing; leave everything else. */
 export declare function unwrapValue(v: any): any;
-export declare function getNode(target: StoreNextTarget, key: PropertyKey, current: any): Signal<any>;
+export declare function getNode(target: StoreNextTarget, key: PropertyKey, current: any, accKnown?: -1 | 0 | 1): Signal<any>;
 export declare function getHasNode(target: StoreNextTarget, key: PropertyKey, present: boolean): Signal<boolean>;
 export declare function getKeySetNode(target: StoreNextTarget): Signal<number>;
 /** Deep-witness bump: any value/shape change on a record with a live deep()
  * subscriber notifies it. One null check when unused. */
 export declare function bumpDeep(t: StoreNextTarget): void;
-/** Scanned plainness for patch admission (patchableRaw): runs the one-time
- * accessor scan if it hasn't happened yet — the sticky `a` flag alone is not
- * trustworthy before a scan (it starts false and is discovered lazily). */
-export declare function targetIsPlain(target: StoreNextTarget): boolean;
 /** Downgrade a prototype-overlay pending backing to the clone path: builds
  * the real container (committed + overlay writes − deletes) that fold will
  * SWAP in as the committed backing, exactly as if the draft had started on
@@ -90,7 +84,7 @@ export type SetStoreNextFunction<T> = (fn: (draft: T) => T | void) => void;
  * replacements as adoptions. `guard=false` skips the owned-scope dev guard —
  * projection recomputes legitimately write from inside their computed. */
 export declare function storeSetterNext<T>(proxy: T, fn: (draft: T) => T | void, guard?: boolean): void;
-export declare function createStoreNext<T extends Record<PropertyKey, any>>(init: T, shallow?: boolean): [T, SetStoreNextFunction<T>];
+export declare function createStoreNext<T extends Record<PropertyKey, any>>(initialValue: T, shallow?: boolean): [T, SetStoreNextFunction<T>];
 /** True when `proxy` is a SHALLOW store (children served verbatim, slots
  * replaced by reference — #2932). The list driver uses this to choose the
  * slot-patch channel (collected row bodies) over per-record registration. */

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

@@ -12,7 +12,7 @@
  * entry per read-through object; zero layer slots; nodes, has-nodes, and the
  * key-set node are lazy, materialized only by subscription.
  */
-import type { Computed, Owner, Signal } from "../../core/types.js";
+import type { Computed, Signal } from "../../core/types.js";
 /** Projection family (§7b): children wrap into the family's own map (writes
  * land in the projection, never the source family), and every node created
  * under the family carries the projection computed as its firewall. */
@@ -34,6 +34,16 @@ export interface StoreNextFamily {
      * landing under an active override. Dead members prune lazily at each
      * landing (retainingTransition). */
     rt?: Set<any>;
+    /** Flight-owned transaction (#3146): declared when a truth-flight
+     * registers (the ask's transaction — created by the flight's own pending
+     * throw when none was ambient, the causing write's when one was), renewed
+     * per settle event once the previous reveal committed. Bare optimistic
+     * writes and landings route into it BY DECLARATION; the transitionBlocked
+     * store-half checks it for ownership instead of reconstructing it from
+     * `_optimisticStores` membership. null = no flight declared one (sync
+     * derive, or a loading-window flight — the loading rail is
+     * transaction-invisible, #2933). */
+    ft?: any;
     /** Normalized row-key fn (same resolution as the projection channels:
      * `options.key`, "id" default, null = unkeyed). The staged-landing walk
      * reads it: key-matched rows keep their proxy identity across a fold. */
@@ -43,40 +53,6 @@ export interface StoreNextFamily {
     node: Computed<any> | null;
     shallow?: boolean;
 }
-/** Write-side patch-channel state (stage 2), grouped off the target's named
- * fields — see the shape rule on `StoreNextTarget.pc`. One literal shape,
- * allocated by `pcOf` on first use. */
-export interface PatchChannel {
-    /** Slot-patch hooks for shallow arrays — the reconcile walk emits
-     * (i, next, prev) for key-aligned value-replaced slots through the patch
-     * apply queue (records are raw, no per-record targets exist).
-     * MULTI-CONSUMER (external audit): one array can drive several lists. */
-    sp: {
-        fn: (index: number, next: any, prev: any) => void;
-        owner: Owner | null;
-    }[] | null;
-    /** Patch-channel consumers (next/patch.ts): per-record compiled patch
-     * entries, multi-consumer. null when unpatched (the common case). */
-    p: object[] | null;
-    /** Same-batch coalescing stamp (re-audit 2/3): the container array this
-     * channel last pushed a non-forced SELF entry into, plus that entry. A
-     * later same-batch emission UPDATES the queued entry's `next` in place
-     * (latest state wins — adoption REPLACES the captured object, so dropping
-     * the later emission would apply stale state) while `prev` stays the
-     * batch's earliest. The drain clears both stamps so a quiet record
-     * retains nothing from its last batch. */
-    qa: unknown;
-    qe: unknown;
-    /** Row-ops consumers (next/patch.ts, PR-B): structural list ops —
-     * (nextRows, { prefix, sources, removed }) at apply timing. */
-    ro: object[] | null;
-    /** Keys written through the traps since the last fold commit. Bounds the
-     * setter notify/hold-check to O(written) instead of O(subscribed nodes) —
-     * a record with thousands of per-key subscriptions (selection maps) would
-     * otherwise pay a full node scan on every write. null = no trap writes
-     * this batch (bulk paths fall back to the full scan). */
-    wk: Set<PropertyKey> | null;
-}
 export interface StoreNextTarget {
     /** Committed backing: source object (shared) or owned clone. */
     v: Record<PropertyKey, any>;
@@ -92,15 +68,19 @@ export interface StoreNextTarget {
     h: Record<PropertyKey, Signal<boolean>> | null;
     /** Lazy key-set node: membership/iteration/$TRACK subscriptions (§6). */
     k: Signal<number> | null;
-    /** Patch-channel extension (lazily allocated on first use): groups the
-     * write-side stage-2 fields so they never widen the TARGET's own named
-     * field count. LOAD-BEARING SHAPE RULE: array proxy targets carry their
-     * fields as named properties on a real array, and V8 normalizes an array
-     * to dictionary properties as the named count grows (empirically at
-     * counts ≡ 0 mod 3 from 18 up on V8 13.x) — every trap field read then
-     * becomes a hash lookup (~15% uibench, tree suites worst). New
-     * patch-channel state MUST go inside this object, not on the target. */
-    pc: PatchChannel | null;
+    /** Keys written through the traps since the last fold commit. Bounds the
+     * setter notify/hold-check to O(written) instead of O(subscribed nodes) —
+     * a record with thousands of per-key subscriptions (selection maps) would
+     * otherwise pay a full node scan on every write. null = no trap writes
+     * this batch (bulk paths fall back to the full scan); WK_ALL = bound
+     * unusable (array length write). LOAD-BEARING SHAPE RULE: array proxy
+     * targets carry their fields as named properties on a real array, and V8
+     * normalizes an array to dictionary properties as the named count grows
+     * (empirically at counts ≡ 0 mod 3 from 18 up on V8 13.x) — every trap
+     * field read then becomes a hash lookup (~15% uibench, tree suites
+     * worst). Future write-side state MUST ride an extension object, not new
+     * named fields. */
+    wk: Set<PropertyKey> | null;
     /** Lazy deep-witness node: `deep()` subscribes ONE node per record instead
      * of one per path; write paths bump it only when it exists. Separate from
      * `k` so $TRACK/mapArray never rerun on leaf value changes (R9). */
@@ -120,8 +100,12 @@ export interface StoreNextTarget {
     /** Accessor scan performed (scan-once on first trap read; adopted data is
      * not rescanned — legacy-parity behavior). */
     sc: boolean;
-    /** Backing was swapped by adoption this batch (fold diff-notifies it). */
-    adopted: boolean;
+    /** Adoption diff base, non-null when the backing was swapped by adoption
+     * this batch: the view the nodes were LAST TOLD — the pre-batch committed
+     * backing, or the draft's pending backing when a draft preceded the
+     * adoption (its setter-exit notifications already moved the nodes, #3296).
+     * The deferred fold diffs incoming against this, never against committed. */
+    ab: Record<PropertyKey, any> | null;
     /** Pending backing is a prototype-chain OVERLAY of the committed backing
      * (`Object.create(v)` — own keys are this batch's writes, everything else
      * reads through). O(written) per flush instead of O(container) clones

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

@@ -1,7 +1,7 @@
 import { type Signal } from "../core/index.js";
 import type { Refreshable } from "../core/index.js";
-/** A read-only view of a store's value as seen by consumers. Mutate it via the paired `StoreSetter`. */
-export type Store<T> = Readonly<T>;
+/** A reactive view of a store's value. Update it through the paired `StoreSetter`. */
+export type Store<T> = T;
 /**
  * A store setter. The callback receives a writable **draft** of the store.
  *
@@ -14,25 +14,30 @@ export type Store<T> = Readonly<T>;
  *
  * The setter does **not** perform keyed reconciliation. If you need surviving
  * items to keep their store identity across full-array replacement, use the
- * projection form — `createStore(fn, seed, { key })` or `createProjection` —
- * whose derive function reconciles its return by `options.key`.
+ * projection form — `createStore(fn, seed, { key })` or
+ * `createProjection(fn, seed, { key })` — whose derive function reconciles
+ * its return by `options.key`.
  */
 export type StoreSetter<T> = (fn: (state: T) => T | void) => void;
-/** Tuple returned by the plain `createStore(initialValue)` form. */
+/** Tuple returned by the plain `createStore(initialValue, options?)` form. */
 export type StoreReturn<T> = [get: Store<T>, set: StoreSetter<T>];
 /** Tuple returned by the derived `createStore(fn, seed, options?)` form. */
 export type ProjectionStoreReturn<T> = [get: Refreshable<Store<T>>, set: StoreSetter<T>];
-/** Base options for store primitives. */
+/** Options shared by all store primitives. */
 export interface StoreOptions {
     /** Debug name (dev mode only) */
     name?: string;
+    /** Single-layer store: root keys reactive, values raw records replaced by reference */
+    shallow?: boolean;
 }
-/** Options for derived/projected stores created with `createStore(fn)`, `createProjection`, or `createOptimisticStore(fn)`. */
+/**
+ * Options for derived/projected stores created with
+ * `createStore(fn, seed, options?)`, `createProjection(fn, seed, options?)`,
+ * or `createOptimisticStore(fn, seed, options?)`.
+ */
 export interface ProjectionOptions extends StoreOptions {
     /** Key property name or function for reconciliation identity; `null` merges positionally */
     key?: string | ((item: NonNullable<any>) => any) | null;
-    /** Single-layer store: root keys reactive, values raw records replaced by reference */
-    shallow?: boolean;
     /**
      * Treat the seed as commit #0: the store is born committed with the seed's
      * contents, shown until the derive's first real answer lands. While that

package/dist/types-cjs/core/attribution-hooks.d.cts

@@ -1,3 +1,4 @@
+import type { Transition } from "./scheduler.cjs";
 import type { Computed, Signal } from "./types.cjs";
 /**
  * Dev-only observability hook points for the reactive core.
@@ -36,6 +37,17 @@ export interface AttributionHooks {
     write(el: Signal<any> | Computed<any>, prev: unknown, value: unknown): void;
     /** refresh() invalidated this node (self-invalidation, no dep changed). */
     refreshed(el: Computed<any>): void;
+    /**
+     * A new async flight entered the system (`_inFlight` was just assigned
+     * during a recompute of `el`). Always fired inside the owning recompute —
+     * both call paths (core's recompute and the projection self-registration)
+     * run within one — so the engine can read the current frame stack to link
+     * the flight to the change that caused it (waterfall chaining). `flight`
+     * is the registered thenable/iterable itself: the engine keys a first-seen
+     * origin registry on its identity, so shared and preloader-marked promises
+     * carry their true start time instead of the moment the graph saw them.
+     */
+    flightStart(el: Computed<any>, flight: object): void;
     /** An async landing is about to apply its value (before any branch). */
     asyncStart(el: Computed<any>): void;
     /**
@@ -47,6 +59,69 @@ export interface AttributionHooks {
      * from the node's state against its asyncStart snapshot.
      */
     asyncEnd(el: Computed<any>, prev: unknown, value: unknown, direct: boolean): void;
+    /**
+     * An effect's imperative half (its effect callback) is about to run /
+     * has run. Both fire outside the run's try; `effectRunEnd` fires whether
+     * or not the callback threw. Writes between the two are the effect's.
+     */
+    effectRunStart(el: Computed<any>): void;
+    effectRunEnd(el: Computed<any>): void;
+    /**
+     * One synchronous step of an `action()` generator is about to run / has
+     * run (`it.next()`/`it.throw()` up to the next yield). `it` is the
+     * invocation's iterator — stable identity across its steps; `name` the
+     * generator function's name. Writes between the two are the action's.
+     */
+    actionStepStart(it: object, name: string | undefined): void;
+    actionStepEnd(it: object): void;
+    /**
+     * A flush found `t` incomplete (transitionComplete's false verdict): its
+     * writes stay staged and its queues are about to be parked. Fired BEFORE
+     * this flush's lane effects (the visible acknowledgers — isPending
+     * companions, optimistic values) run; `holdEnd` fires from the root
+     * stashQueues call after them, so effect runs between the two are runs that
+     * painted *during* the hold.
+     */
+    holdStart(t: Transition): void;
+    holdEnd(): void;
+    /**
+     * `t` was judged complete (transitionComplete's true verdict, before `_done`
+     * flips). Fired before its held writes commit, so `t._pendingNodes` still
+     * lists what was staged.
+     */
+    transitionSettled(t: Transition): void;
+    /** `outgoing` was folded into `target` (`outgoing._done = target`). */
+    transitionMerged(target: Transition, outgoing: Transition): void;
+    /**
+     * A store setter batch replaced the container at `path` (e.g. `store.user`)
+     * with a different one (both non-null, same array-ness, not the same
+     * logical slot), and this is the leaf census of the new container against
+     * the old: `total` leaves (own keys, or items) in the new one, `unchanged`
+     * of which are the same value as before (identity, judged on unwrapped
+     * values — object keys compared by key, array items by membership), and
+     * `prevTotal` leaves in the old one. Containers above 64 leaves are not
+     * announced. Fired per written key from the write channel's notify. The
+     * engine decides whether the replacement was a spread-copy worth a
+     * diagnostic.
+     */
+    storeReplaced(path: string, isArray: boolean, total: number, unchanged: number, prevTotal: number): void;
+    /**
+     * A `mapArray` update both disposed and created rows: `removed` are the
+     * items whose rows were disposed, `created` the items that got new rows,
+     * `newLen` the list's new length, `keyed` whether a key function is in use
+     * (false = identity or by-index). Fired after commit. The engine judges
+     * whether the churn replaced equivalent records (unstable identity).
+     */
+    listChurn(el: Computed<any>, removed: unknown[], created: unknown[], newLen: number, keyed: boolean): void;
+    /**
+     * A loading boundary started (`shown` true) or stopped showing its
+     * fallback. `boundary` is the boundary's queue (stable identity); `tree`
+     * its bound subtree computed when already constructed — the first show can
+     * fire while the subtree is still being built — whose owner chain names
+     * the boundary. Fired at the source-set transitions (first pending source
+     * registers / last one clears), not per flush.
+     */
+    boundaryFallback(boundary: object, tree: Computed<any> | undefined, shown: boolean): void;
 }
 export declare let attrHooks: AttributionHooks | null;
 export declare function setAttributionHooks(hooks: AttributionHooks | null): void;