@solidjs/signals 2.0.0-beta.15 → 2.0.0-beta.16

package/dist/types/boundaries.d.ts

@@ -73,9 +73,9 @@ export declare class CollectionQueue extends Queue {
  * }
  * ```
  */
-export declare function createLoadingBoundary(fn: () => any, fallback: () => any, options?: {
+export declare function createLoadingBoundary<T, U>(fn: () => T, fallback: () => U, options?: {
     on?: () => any;
-}): import("./signals.js").SourceAccessor<unknown>;
+}): Accessor<T | U>;
 /**
  * Lower-level primitive that backs the `<Errored>` flow control. Catches
  * thrown errors inside `fn` and invokes `fallback(error, reset)` instead.
@@ -99,7 +99,7 @@ export declare function createLoadingBoundary(fn: () => any, fallback: () => any
  * }
  * ```
  */
-export declare function createErrorBoundary<U>(fn: () => any, fallback: (error: Accessor<unknown>, reset: () => void) => U): import("./signals.js").SourceAccessor<unknown>;
+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.
  *

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

@@ -1,6 +1,7 @@
 import { type OptimisticLane } from "./lanes.js";
 import type { Computed } from "./types.js";
 export declare function settlePendingSource(el: 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;
 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;

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

@@ -7,7 +7,6 @@ export declare const REACTIVE_WRITE_IN_OWNED_SCOPE_REFRESH_MESSAGE: string;
 export declare let tracking: boolean;
 export declare let stale: boolean;
 export declare let pendingCheckActive: boolean;
-export declare let foundPending: boolean;
 export declare let latestReadActive: boolean;
 export declare let context: Owner | null;
 export declare let currentOptimisticLane: OptimisticLane | null;
@@ -98,12 +97,37 @@ export declare function setMemo<T>(el: Computed<T>, v: T | ((prev: T) => T)): T;
  * ```
  */
 export declare function runWithOwner<T>(owner: Owner | null, fn: () => T): T;
+/**
+ * Keep the lazily-created isPending()/latest() companion nodes in sync with a
+ * new value. Every path that produces a value for `el` — direct set, async
+ * resolution, transition-held sync recompute — must route through here so a
+ * new write path can't silently skip the companions (#2831).
+ */
+export declare function syncCompanions<T>(el: Signal<T> | Computed<T>, value: T): void;
 /**
  * Update _pendingSignal when pending state changes. When the override clears
  * (pending -> not pending), merge the sub-lane into the source's lane so
  * isPending effects are blocked until the full scope resolves.
  */
 export declare function updatePendingSignal(el: Signal<any> | Computed<any>): void;
+/**
+ * A firewall's status change re-derives the verdicts of its probed leaves:
+ * leaf companions consult the firewall (broad inheritance), so async
+ * starting/settling on the firewall must poke them or they keep a stale
+ * verdict forever (V4 stuck-companion class, #2838).
+ */
+export declare function updateChildCompanions(el: Computed<any>): void;
+/**
+ * Settlement checkpoint (#2838): re-derive a node's companions directly from
+ * its committed state. Called when the transition machinery for the node is
+ * done with it — a pending commit or an optimistic revert. Verdicts are
+ * written committed (not through setSignal) because a transition-scoped
+ * override window opened here would itself need a settlement, re-scheduling
+ * forever while async is still in flight. This is what keeps companions
+ * coherent past transition completion: a verdict is a property of the data
+ * (A19), so it must survive the transition that happened to produce it.
+ */
+export declare function snapCompanionsToState(owner: Signal<any> | Computed<any>): void;
 export declare function staleValues<T>(fn: () => T, set?: boolean): T;
 /**
  * Reads reactive expressions while bypassing any pending async overlay — i.e.

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

@@ -6,8 +6,8 @@ export interface DevHooks {
     onStoreNodeUpdate?: (state: any, property: PropertyKey, value: any, prev: any) => void;
 }
 export type DiagnosticSeverity = "warn" | "error";
-export type DiagnosticCode = "STRICT_READ_UNTRACKED" | "PENDING_ASYNC_UNTRACKED_READ" | "PENDING_ASYNC_FORBIDDEN_SCOPE" | "REACTIVE_WRITE_IN_OWNED_SCOPE" | "RUN_WITH_DISPOSED_OWNER" | "NO_OWNER_CLEANUP" | "CLEANUP_IN_FORBIDDEN_SCOPE" | "PRIMITIVE_IN_FORBIDDEN_SCOPE" | "NO_OWNER_EFFECT" | "NO_OWNER_BOUNDARY" | "ASYNC_OUTSIDE_LOADING_BOUNDARY" | "INVALID_REFRESH_TARGET" | "MISSING_EFFECT_FN" | "SYNC_NODE_RECEIVED_ASYNC";
-export type DiagnosticKind = "strict-read" | "async" | "write" | "lifecycle" | "owner";
+export type DiagnosticCode = "STRICT_READ_UNTRACKED" | "PENDING_ASYNC_UNTRACKED_READ" | "PENDING_ASYNC_FORBIDDEN_SCOPE" | "REACTIVE_WRITE_IN_OWNED_SCOPE" | "RUN_WITH_DISPOSED_OWNER" | "NO_OWNER_CLEANUP" | "CLEANUP_IN_FORBIDDEN_SCOPE" | "SETTLED_CLEANUP_UNOWNED" | "PRIMITIVE_IN_FORBIDDEN_SCOPE" | "NO_OWNER_EFFECT" | "NO_OWNER_BOUNDARY" | "ASYNC_OUTSIDE_LOADING_BOUNDARY" | "INVALID_REFRESH_TARGET" | "MISSING_EFFECT_FN" | "SYNC_NODE_RECEIVED_ASYNC" | "REACTIVITY_HALTED" | "INVARIANT_VIOLATION";
+export type DiagnosticKind = "strict-read" | "async" | "write" | "lifecycle" | "owner" | "error";
 export interface DiagnosticEvent {
     sequence: number;
     code: DiagnosticCode;
@@ -39,6 +39,14 @@ export interface Dev {
     getObservers: typeof getObservers;
 }
 export declare const DEV: Dev;
+/**
+ * Dev-mode internal consistency check. A failure means the reactive system
+ * contradicted itself (not that user code misbehaved) — see
+ * INTERNALS-ASYNC-STATE.md for the invariant catalog. Throws under __TEST__
+ * so the suite (and fuzzing) treats any violation as a hard failure; logs in
+ * dev builds so user apps degrade instead of crashing.
+ */
+export declare function assertInvariant(condition: boolean, name: string, message: string): void;
 export declare function emitDiagnostic(event: Omit<DiagnosticEvent, "sequence">): DiagnosticEvent;
 export declare function registerGraph(value: any, owner: Owner | null): void;
 export declare function clearSignals(node: Owner): void;

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

@@ -2,11 +2,10 @@ import type { Computed, NodeOptions, Owner } from "./types.js";
 export interface Effect<T> extends Computed<T>, Owner {
     _effectFn: (val: T, prev: T | undefined) => void | (() => void);
     _errorFn?: (err: unknown, cleanup: () => void) => void;
-    _cleanup?: () => void;
-    _cleanupRegistered?: boolean;
     _modified: boolean;
     _prevValue: T | undefined;
     _type: number;
+    _boundRunEffect?: () => void;
 }
 /**
  * Effects are the leaf nodes of our reactive graph. When their sources change, they are
@@ -19,7 +18,6 @@ export declare function effect<T>(compute: (prev: T | undefined) => T, effect: (
     schedule?: boolean;
 }): void;
 export interface TrackedEffect extends Computed<void> {
-    _cleanup?: () => void;
     _modified: boolean;
     _type: number;
     _run: () => void;

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

@@ -2,4 +2,4 @@ import type { Computed, Link, Signal } from "./types.js";
 export declare function unlinkSubs(link: Link): Link | null;
 export declare function trimStaleDeps(el: Computed<any>): void;
 export declare function unobserved(el: Computed<unknown>): void;
-export declare function link(dep: Signal<any> | Computed<any>, sub: Computed<any>): void;
+export declare function link(dep: Signal<any> | Computed<any>, sub: Computed<any>, pendingObserver?: boolean): void;

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

@@ -1,5 +1,5 @@
 export { ContextNotFoundError, NoOwnerError, NotReadyError } from "./error.js";
-export { isEqual, untrack, runWithOwner, computed, signal, read, setSignal, setMemo, suppressComputedRecompute, optimisticSignal, optimisticComputed, isPending, latest, refresh, staleValues, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots } from "./core.js";
+export { isEqual, untrack, runWithOwner, computed, signal, read, setSignal, setMemo, suppressComputedRecompute, optimisticSignal, optimisticComputed, isPending, latest, updatePendingSignal, updateChildCompanions, refresh, staleValues, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots } from "./core.js";
 export { enableExternalSource, _resetExternalSourceConfig, type ExternalSourceFactory, type ExternalSource, type ExternalSourceConfig } from "./external.js";
 export { createOwner, createRoot, dispose, getNextChildId, getObserver, getOwner, isDisposed, cleanup, peekNextChildId } from "./owner.js";
 export { createContext, getContext, setContext, type Context, type ContextRecord } from "./context.js";
@@ -7,6 +7,6 @@ export { handleAsync } from "./async.js";
 export type { Computed, Disposable, FirewallSignal, Link, Owner, Root, Signal, NodeOptions } from "./types.js";
 export { effect, trackedEffect, type Effect, type TrackedEffect } from "./effect.js";
 export { action } from "./action.js";
-export { flush, Queue, GlobalQueue, trackOptimisticStore, enforceLoadingBoundary, type IQueue, type QueueCallback } from "./scheduler.js";
+export { flush, Queue, GlobalQueue, trackOptimisticStore, enforceLoadingBoundary, resetErrorHalt, type IQueue, type QueueCallback } from "./scheduler.js";
 export { DEV, type Dev, type DevHooks, type DiagnosticCapture, type DiagnosticCode, type DiagnosticEvent, type DiagnosticKind, type Diagnostics, type DiagnosticSeverity } from "./dev.js";
 export * from "./constants.js";

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

@@ -0,0 +1,49 @@
+import type { OptimisticLane } from "./lanes.js";
+import type { Computed, Signal } from "./types.js";
+/**
+ * Test-mode invariant checks for the async/transition/lane machinery.
+ * Catalog and rationale: packages/solid-signals/INTERNALS-ASYNC-STATE.md.
+ *
+ * These are implementation self-consistency checks, not semantic rules: a
+ * violation means the reactive system contradicted itself.
+ *
+ * They are gated on `__TEST__` (not just `__DEV__`): the per-write Set
+ * tracking and per-flush quiescence sweep are too expensive for shipped dev
+ * builds and for benchmarks (they showed up as a 5-21% hit across the
+ * CodSpeed suite when they ran under `__DEV__`). Call sites stay `__DEV__`
+ * guarded so production tree-shakes the calls; each entry point here
+ * early-returns unless `__TEST__` is set, so dev builds pay only a no-op
+ * call. The test suite (vitest run) defines `__TEST__: true`; benchmark mode
+ * defines `__TEST__: false`.
+ */
+type AnyNode = Signal<any> | Computed<any>;
+/** Wired by core.ts at module init to avoid import cycles. */
+export declare const InvariantHooks: {
+    pendingProbeActive: (() => boolean) | null;
+    /** Fresh oracle for what an isPending companion SHOULD read right now. */
+    computePendingState: ((node: AnyNode) => boolean) | null;
+};
+export declare function devTrackHeldPending(node: AnyNode): void;
+export declare function devTrackCompanionOwner(node: AnyNode): void;
+export declare function devTrackOptimistic(node: AnyNode): void;
+/**
+ * Open/close the sanctioned registration window. Call sites are `__DEV__`
+ * guarded (no prod cost); the code inside the window must not throw.
+ */
+export declare function beginAsyncReporterWrites(): void;
+export declare function endAsyncReporterWrites(): void;
+export declare function createAsyncReporters(): Map<Computed<any>, Set<Computed<any>>>;
+export declare function devCheckActiveOverrides(isRegisteredForRevert: (node: AnyNode) => boolean): void;
+/** INV-1: an isPending() probe must never leak past its own call. */
+export declare function devCheckFlushStart(): void;
+/** INV-5: a merged lane's work moved to its root on merge and must stay empty. */
+export declare function devCheckMergedLaneEmpty(lane: OptimisticLane): void;
+export declare function devCensusCompanions(isQueuedForCommit?: (node: AnyNode) => boolean): void;
+/**
+ * Quiescence checks. Run only when the system is fully drained: nothing
+ * scheduled, no active/stashed transitions, no live lanes. At that point no
+ * transition-scoped state may survive, and the lazily-created companions must
+ * agree with a fresh computation of their owner's state.
+ */
+export declare function devCheckQuiescent(isQueuedForCommit: (node: AnyNode) => boolean): void;
+export {};

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

@@ -41,6 +41,14 @@ export interface Transition {
     _gatedSubs: Set<Computed<any>>;
 }
 export declare function schedule(): void;
+/**
+ * Permanently halts the reactive system. Called when a user error escapes
+ * every boundary — app state is undefined at that point, so scheduling stops
+ * entirely rather than limping along with a half-applied update.
+ */
+export declare function haltReactivity(): void;
+/** @internal Test/dev-reload hook. Revives scheduling after a halt. */
+export declare function resetErrorHalt(): void;
 export interface IQueue {
     enqueue(type: number, fn: QueueCallback): void;
     run(type: number): boolean | void;

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

@@ -10,6 +10,14 @@ export interface Link {
     _nextDep: Link | null;
     _prevSub: Link | null;
     _nextSub: Link | null;
+    /**
+     * `_sub._depGen` at the time this link was created or last revalidated
+     * in-order. A link stamped with the subscriber's current pass generation is
+     * inside the validated `[deps.._depsTail]` prefix — an O(1) replacement for
+     * scanning the dep list to answer membership (see `link()`).
+     */
+    _gen: number;
+    _pendingObserver?: boolean;
 }
 export interface NodeOptions<T> {
     id?: string;
@@ -50,6 +58,8 @@ export interface Owner {
     id?: string;
     _config: number;
     _snapshotScope?: boolean;
+    /** Effect-returned cleanup; managed across reruns, invoked at true disposal */
+    _cleanup?: () => void;
     _disposal: Disposable | Disposable[] | null;
     _parent: Owner | null;
     _context: Record<symbol | string, unknown>;
@@ -64,6 +74,8 @@ export interface Owner {
 export interface Computed<T> extends RawSignal<T>, Owner {
     _deps: Link | null;
     _depsTail: Link | null;
+    /** Recompute-pass counter; bumped when dep revalidation starts. */
+    _depGen: number;
     _flags: number;
     _blocked?: boolean;
     _pendingSource?: Computed<any>;
@@ -77,6 +89,13 @@ export interface Computed<T> extends RawSignal<T>, Owner {
     _inFlight: PromiseLike<T> | AsyncIterable<T> | null;
     _child: FirewallSignal<any> | null;
     _notifyStatus?: (status?: number, error?: any) => void;
+    /**
+     * Store-wide optimistic mask (count of this firewall's store targets with
+     * live optimistic writes). Non-zero decrees the whole store settled for
+     * `isPending` — the store is the primitive the mask covers (A20 re-rule
+     * 2026-07-07c).
+     */
+    _optimisticMask?: number;
 }
 export interface Root extends Owner {
     _root: true;

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-export { $REFRESH, ContextNotFoundError, NoOwnerError, NotReadyError, action, createContext, createOwner, createRoot, runWithOwner, flush, getNextChildId, peekNextChildId, getContext, setContext, getOwner, isDisposed, getObserver, isEqual, untrack, isPending, latest, refresh, SUPPORTS_PROXY, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots, enforceLoadingBoundary, enableExternalSource } from "./core/index.js";
+export { $REFRESH, ContextNotFoundError, NoOwnerError, NotReadyError, action, createContext, createOwner, createRoot, runWithOwner, flush, getNextChildId, peekNextChildId, getContext, setContext, getOwner, isDisposed, getObserver, isEqual, untrack, isPending, latest, refresh, SUPPORTS_PROXY, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots, enforceLoadingBoundary, enableExternalSource, resetErrorHalt } from "./core/index.js";
 import { type Dev } from "./core/index.js";
 export declare const DEV: Dev | undefined;
 export type { Owner, Context, ContextRecord, IQueue, ExternalSourceFactory, ExternalSource, ExternalSourceConfig, Refreshable, Dev, DevHooks, DiagnosticCapture, DiagnosticCode, DiagnosticEvent, DiagnosticKind, Diagnostics, DiagnosticSeverity } from "./core/index.js";

package/dist/types/signals.d.ts

@@ -69,6 +69,17 @@ export type ComputeFunction<Prev, Next extends Prev = Prev> = (v: Prev) => Promi
 export type EffectFunction<Prev, Next extends Prev = Prev> = (v: Next, p?: Prev) => (() => void) | void;
 export type EffectBundle<Prev, Next extends Prev = Prev> = {
     effect: EffectFunction<Prev, Next>;
+    /**
+     * Intercepts compute-phase errors (thrown by the compute function or arriving
+     * from upstream sources). Effect-phase throws are NOT routed here — they are
+     * your own imperative code and escalate to the nearest error boundary.
+     *
+     * This is the error arm of the effect phase: it runs on the same queue and
+     * in the same imperative, writable scope as `effect` (signal writes are
+     * legal), receives the error the user code threw, and observes settled
+     * outcomes — an error that recovers before the effect phase runs the
+     * `effect` arm instead, and a held transition defers it like `effect`.
+     */
     error: (err: unknown, cleanup: () => void) => void;
 };
 /** Options shared by every effect primitive. */
@@ -245,7 +256,24 @@ export declare function createMemo<T>(compute: ComputeFunction<undefined | NoInf
  * `createTrackedEffect` (with the tradeoffs noted there).
  *
  * Pass an `EffectBundle` (`{ effect, error }`) instead of a plain function to
- * intercept errors thrown from the compute or effect phases.
+ * intercept **compute-phase** errors — errors thrown by `compute` or arriving
+ * from upstream reactive sources (including async rejections), which your own
+ * code has no frame to `try/catch`. The `error` handler is the error arm of
+ * the effect phase: it runs on the same schedule and in the same imperative,
+ * writable scope as `effect` (setting error state via signals is fine), and
+ * only for *settled* errors — a transient error that recovers before the
+ * effect phase runs `effect` with the recovered value instead, and a held
+ * transition defers it exactly as it defers `effect`. Without an `error`
+ * handler a compute-phase error is logged and the effect simply skips that
+ * run — a non-render effect's reactivity failing does not crash the app.
+ * Rethrowing from `error` escalates it to the nearest error boundary
+ * (halting the system if none exists).
+ *
+ * The **effect phase is different**: it is your own imperative code, so handle
+ * failures with `try/catch` where they occur. An uncaught effect-phase throw
+ * is treated as an unhandled application error — caught by the nearest
+ * `createErrorBoundary`/`<Errored>`, and permanently halting the reactive
+ * system if there is none. It is *not* routed to the bundle's `error` handler.
  *
  * ```typescript
  * createEffect<T>(compute, effectFn | { effect, error }, options?: EffectOptions);
@@ -383,7 +411,9 @@ export declare function createReaction(effectFn: EffectFunction<undefined> | Eff
  * Awaits a reactive expression and returns its first fully-settled value as a
  * `Promise`. Pending async reads (`createMemo` returning a promise, etc.) are
  * waited on; once the expression returns synchronously without `NotReadyError`
- * the promise resolves with that value.
+ * the promise resolves with that value. If the expression settles with an
+ * error instead — including an async source that rejects — the promise
+ * rejects with it.
  *
  * Must be called *outside* a tracking scope — it doesn't subscribe, it just
  * resolves the current value once.
@@ -459,6 +489,13 @@ export declare function createOptimistic<T>(fn: ComputeFunction<T>, options?: Si
  * `onCleanup` is **not** allowed inside the callback — return a cleanup
  * function instead. The returned cleanup runs on owner disposal.
  *
+ * A cleanup return is only honored when `onSettled` is called from an **owned**
+ * scope (e.g. a component body). When it fires out of band from an *unowned*
+ * scope — an event handler, a tracked effect, or another `onSettled` — there is
+ * no owner lifecycle to bind a cleanup to; returning one is a dev-mode error
+ * (and is dropped in production). Use the post-settle/event-handler forms below
+ * for one-shot work, and keep setup-with-teardown in an owned scope.
+ *
  * @example
  * ```tsx
  * // Component-level setup + teardown — replaces onMount + onCleanup.

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

@@ -1,5 +1,5 @@
 import { type Computed, type Refreshable } from "../core/index.js";
-import { type ProjectionOptions, type Store } from "./store.js";
+import { type NoFn, type ProjectionOptions, type Store } from "./store.js";
 export declare function createProjectionInternal<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T>, options?: ProjectionOptions): {
     store: Refreshable<Store<T>>;
     node: Computed<void | T>;
@@ -47,7 +47,7 @@ export declare function createProjectionInternal<T extends object = {}>(fn: (dra
  *
  * @see {@link https://github.com/solidjs/x-reactivity#createprojection}
  */
-export declare function createProjection<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T>, options?: ProjectionOptions): Refreshable<Store<T>>;
+export declare function createProjection<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): Refreshable<Store<T>>;
 /**
  * Shared projection computed body used by both `createProjection` and the derived
  * form of `createOptimisticStore`. Encapsulates the write-trap draft, `storeSetter`

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

@@ -41,7 +41,7 @@ type DataNodes = Record<PropertyKey, DataNode>;
  * @internal
  */
 export declare const $TRACK: unique symbol, $TARGET: unique symbol, $PROXY: unique symbol, $DELETED: unique symbol;
-export declare const STORE_VALUE = "v", STORE_OVERRIDE = "o", STORE_OPTIMISTIC_OVERRIDE = "x", STORE_NODE = "n", STORE_HAS = "h", STORE_CUSTOM_PROTO = "c", STORE_WRAP = "w", STORE_LOOKUP = "l", STORE_FIREWALL = "f", STORE_OPTIMISTIC = "p";
+export declare const STORE_VALUE = "v", STORE_OVERRIDE = "o", STORE_OPTIMISTIC_OVERRIDE = "x", STORE_NODE = "n", STORE_HAS = "h", STORE_CUSTOM_PROTO = "c", STORE_WRAP = "w", STORE_LOOKUP = "l", STORE_FIREWALL = "f", STORE_OPTIMISTIC = "p", STORE_MASKED = "m";
 export type StoreNode = {
     [$PROXY]: any;
     [STORE_VALUE]: Record<PropertyKey, any>;
@@ -54,6 +54,8 @@ export type StoreNode = {
     [STORE_LOOKUP]?: WeakMap<any, any>;
     [STORE_FIREWALL]?: Computed<any>;
     [STORE_OPTIMISTIC]?: boolean;
+    /** This target currently contributes to its firewall's store-wide mask. */
+    [STORE_MASKED]?: boolean;
     [STORE_SNAPSHOT_PROPS]?: Record<PropertyKey, any>;
 };
 export declare namespace SolidStore {
@@ -63,13 +65,38 @@ export declare namespace SolidStore {
 export type NotWrappable = string | number | bigint | symbol | boolean | Function | null | undefined | SolidStore.Unwrappable[keyof SolidStore.Unwrappable];
 export declare function createStoreProxy<T extends object>(value: T, traps?: ProxyHandler<StoreNode>, extend?: (target: StoreNode) => void): any;
 export declare const storeLookup: WeakMap<WeakKey, any>;
+export declare const symbolKeyedRecords: WeakSet<object>;
 export declare function wrap<T extends Record<PropertyKey, any>>(value: T, target?: StoreNode): T;
 export declare function isWrappable<T>(obj: T | NotWrappable): obj is T;
 export declare function setWriteOverride(value: boolean): void;
+export declare function ownEnumerableKeys(o: object): (string | symbol)[];
+/**
+ * Single chokepoint for the store's layered value resolution: returns the
+ * override layer (optimistic first, then regular) that shadows `property`, or
+ * `undefined` when the base `STORE_VALUE` is authoritative. Every trap must
+ * resolve through this — hand-inlining the layer order is how the optimistic
+ * layer gets missed (#2850).
+ */
+export declare function getOverlayLayer(target: StoreNode, property: PropertyKey): Record<PropertyKey, any> | undefined;
+/**
+ * The value a store leaf's backing signal currently shows to readers: active
+ * override, else held pending value, else committed value.
+ */
+export declare function visibleNodeValue(node: DataNode): any;
 export declare function trackSelf(target: StoreNode, symbol?: symbol): void;
 export declare function notifySelf(target: StoreNode): void;
 export declare function getKeys(source: Record<PropertyKey, any>, override: Record<PropertyKey, any> | undefined, enumerable?: boolean): PropertyKey[];
 export declare function getPropertyDescriptor(source: Record<PropertyKey, any>, override: Record<PropertyKey, any> | undefined, property: PropertyKey): PropertyDescriptor | undefined;
+/**
+ * Store-wide mask bookkeeping (A20 re-rule 2026-07-07c): the store is the
+ * primitive, so an optimistic write decrees the WHOLE store settled for
+ * `isPending` — firewall, written leaves, untouched siblings, structural
+ * reads — for the lifetime of the override/transition. The firewall carries a
+ * count of masked targets (nested objects mask independently); companions of
+ * the firewall and its probed leaves are poked on 0↔1 transitions so an
+ * already-materialized verdict flips without waiting for another write.
+ */
+export declare function maskStoreTarget(target: StoreNode, on: boolean): void;
 export declare const storeTraps: ProxyHandler<StoreNode>;
 export declare function storeSetter<T extends object>(store: Store<T>, fn: (draft: T) => T | void): void;
 /**

package/dist/types-cjs/boundaries.d.cts

@@ -73,9 +73,9 @@ export declare class CollectionQueue extends Queue {
  * }
  * ```
  */
-export declare function createLoadingBoundary(fn: () => any, fallback: () => any, options?: {
+export declare function createLoadingBoundary<T, U>(fn: () => T, fallback: () => U, options?: {
     on?: () => any;
-}): import("./signals.cjs").SourceAccessor<unknown>;
+}): Accessor<T | U>;
 /**
  * Lower-level primitive that backs the `<Errored>` flow control. Catches
  * thrown errors inside `fn` and invokes `fallback(error, reset)` instead.
@@ -99,7 +99,7 @@ export declare function createLoadingBoundary(fn: () => any, fallback: () => any
  * }
  * ```
  */
-export declare function createErrorBoundary<U>(fn: () => any, fallback: (error: Accessor<unknown>, reset: () => void) => U): import("./signals.cjs").SourceAccessor<unknown>;
+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.
  *

package/dist/types-cjs/core/async.d.cts

@@ -1,6 +1,7 @@
 import { type OptimisticLane } from "./lanes.cjs";
 import type { Computed } from "./types.cjs";
 export declare function settlePendingSource(el: 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;
 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;

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

@@ -7,7 +7,6 @@ export declare const REACTIVE_WRITE_IN_OWNED_SCOPE_REFRESH_MESSAGE: string;
 export declare let tracking: boolean;
 export declare let stale: boolean;
 export declare let pendingCheckActive: boolean;
-export declare let foundPending: boolean;
 export declare let latestReadActive: boolean;
 export declare let context: Owner | null;
 export declare let currentOptimisticLane: OptimisticLane | null;
@@ -98,12 +97,37 @@ export declare function setMemo<T>(el: Computed<T>, v: T | ((prev: T) => T)): T;
  * ```
  */
 export declare function runWithOwner<T>(owner: Owner | null, fn: () => T): T;
+/**
+ * Keep the lazily-created isPending()/latest() companion nodes in sync with a
+ * new value. Every path that produces a value for `el` — direct set, async
+ * resolution, transition-held sync recompute — must route through here so a
+ * new write path can't silently skip the companions (#2831).
+ */
+export declare function syncCompanions<T>(el: Signal<T> | Computed<T>, value: T): void;
 /**
  * Update _pendingSignal when pending state changes. When the override clears
  * (pending -> not pending), merge the sub-lane into the source's lane so
  * isPending effects are blocked until the full scope resolves.
  */
 export declare function updatePendingSignal(el: Signal<any> | Computed<any>): void;
+/**
+ * A firewall's status change re-derives the verdicts of its probed leaves:
+ * leaf companions consult the firewall (broad inheritance), so async
+ * starting/settling on the firewall must poke them or they keep a stale
+ * verdict forever (V4 stuck-companion class, #2838).
+ */
+export declare function updateChildCompanions(el: Computed<any>): void;
+/**
+ * Settlement checkpoint (#2838): re-derive a node's companions directly from
+ * its committed state. Called when the transition machinery for the node is
+ * done with it — a pending commit or an optimistic revert. Verdicts are
+ * written committed (not through setSignal) because a transition-scoped
+ * override window opened here would itself need a settlement, re-scheduling
+ * forever while async is still in flight. This is what keeps companions
+ * coherent past transition completion: a verdict is a property of the data
+ * (A19), so it must survive the transition that happened to produce it.
+ */
+export declare function snapCompanionsToState(owner: Signal<any> | Computed<any>): void;
 export declare function staleValues<T>(fn: () => T, set?: boolean): T;
 /**
  * Reads reactive expressions while bypassing any pending async overlay — i.e.

package/dist/types-cjs/core/dev.d.cts

@@ -6,8 +6,8 @@ export interface DevHooks {
     onStoreNodeUpdate?: (state: any, property: PropertyKey, value: any, prev: any) => void;
 }
 export type DiagnosticSeverity = "warn" | "error";
-export type DiagnosticCode = "STRICT_READ_UNTRACKED" | "PENDING_ASYNC_UNTRACKED_READ" | "PENDING_ASYNC_FORBIDDEN_SCOPE" | "REACTIVE_WRITE_IN_OWNED_SCOPE" | "RUN_WITH_DISPOSED_OWNER" | "NO_OWNER_CLEANUP" | "CLEANUP_IN_FORBIDDEN_SCOPE" | "PRIMITIVE_IN_FORBIDDEN_SCOPE" | "NO_OWNER_EFFECT" | "NO_OWNER_BOUNDARY" | "ASYNC_OUTSIDE_LOADING_BOUNDARY" | "INVALID_REFRESH_TARGET" | "MISSING_EFFECT_FN" | "SYNC_NODE_RECEIVED_ASYNC";
-export type DiagnosticKind = "strict-read" | "async" | "write" | "lifecycle" | "owner";
+export type DiagnosticCode = "STRICT_READ_UNTRACKED" | "PENDING_ASYNC_UNTRACKED_READ" | "PENDING_ASYNC_FORBIDDEN_SCOPE" | "REACTIVE_WRITE_IN_OWNED_SCOPE" | "RUN_WITH_DISPOSED_OWNER" | "NO_OWNER_CLEANUP" | "CLEANUP_IN_FORBIDDEN_SCOPE" | "SETTLED_CLEANUP_UNOWNED" | "PRIMITIVE_IN_FORBIDDEN_SCOPE" | "NO_OWNER_EFFECT" | "NO_OWNER_BOUNDARY" | "ASYNC_OUTSIDE_LOADING_BOUNDARY" | "INVALID_REFRESH_TARGET" | "MISSING_EFFECT_FN" | "SYNC_NODE_RECEIVED_ASYNC" | "REACTIVITY_HALTED" | "INVARIANT_VIOLATION";
+export type DiagnosticKind = "strict-read" | "async" | "write" | "lifecycle" | "owner" | "error";
 export interface DiagnosticEvent {
     sequence: number;
     code: DiagnosticCode;
@@ -39,6 +39,14 @@ export interface Dev {
     getObservers: typeof getObservers;
 }
 export declare const DEV: Dev;
+/**
+ * Dev-mode internal consistency check. A failure means the reactive system
+ * contradicted itself (not that user code misbehaved) — see
+ * INTERNALS-ASYNC-STATE.md for the invariant catalog. Throws under __TEST__
+ * so the suite (and fuzzing) treats any violation as a hard failure; logs in
+ * dev builds so user apps degrade instead of crashing.
+ */
+export declare function assertInvariant(condition: boolean, name: string, message: string): void;
 export declare function emitDiagnostic(event: Omit<DiagnosticEvent, "sequence">): DiagnosticEvent;
 export declare function registerGraph(value: any, owner: Owner | null): void;
 export declare function clearSignals(node: Owner): void;

package/dist/types-cjs/core/effect.d.cts

@@ -2,11 +2,10 @@ import type { Computed, NodeOptions, Owner } from "./types.cjs";
 export interface Effect<T> extends Computed<T>, Owner {
     _effectFn: (val: T, prev: T | undefined) => void | (() => void);
     _errorFn?: (err: unknown, cleanup: () => void) => void;
-    _cleanup?: () => void;
-    _cleanupRegistered?: boolean;
     _modified: boolean;
     _prevValue: T | undefined;
     _type: number;
+    _boundRunEffect?: () => void;
 }
 /**
  * Effects are the leaf nodes of our reactive graph. When their sources change, they are
@@ -19,7 +18,6 @@ export declare function effect<T>(compute: (prev: T | undefined) => T, effect: (
     schedule?: boolean;
 }): void;
 export interface TrackedEffect extends Computed<void> {
-    _cleanup?: () => void;
     _modified: boolean;
     _type: number;
     _run: () => void;

package/dist/types-cjs/core/graph.d.cts

@@ -2,4 +2,4 @@ import type { Computed, Link, Signal } from "./types.cjs";
 export declare function unlinkSubs(link: Link): Link | null;
 export declare function trimStaleDeps(el: Computed<any>): void;
 export declare function unobserved(el: Computed<unknown>): void;
-export declare function link(dep: Signal<any> | Computed<any>, sub: Computed<any>): void;
+export declare function link(dep: Signal<any> | Computed<any>, sub: Computed<any>, pendingObserver?: boolean): void;

package/dist/types-cjs/core/index.d.cts

@@ -1,5 +1,5 @@
 export { ContextNotFoundError, NoOwnerError, NotReadyError } from "./error.cjs";
-export { isEqual, untrack, runWithOwner, computed, signal, read, setSignal, setMemo, suppressComputedRecompute, optimisticSignal, optimisticComputed, isPending, latest, refresh, staleValues, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots } from "./core.cjs";
+export { isEqual, untrack, runWithOwner, computed, signal, read, setSignal, setMemo, suppressComputedRecompute, optimisticSignal, optimisticComputed, isPending, latest, updatePendingSignal, updateChildCompanions, refresh, staleValues, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots } from "./core.cjs";
 export { enableExternalSource, _resetExternalSourceConfig, type ExternalSourceFactory, type ExternalSource, type ExternalSourceConfig } from "./external.cjs";
 export { createOwner, createRoot, dispose, getNextChildId, getObserver, getOwner, isDisposed, cleanup, peekNextChildId } from "./owner.cjs";
 export { createContext, getContext, setContext, type Context, type ContextRecord } from "./context.cjs";
@@ -7,6 +7,6 @@ export { handleAsync } from "./async.cjs";
 export type { Computed, Disposable, FirewallSignal, Link, Owner, Root, Signal, NodeOptions } from "./types.cjs";
 export { effect, trackedEffect, type Effect, type TrackedEffect } from "./effect.cjs";
 export { action } from "./action.cjs";
-export { flush, Queue, GlobalQueue, trackOptimisticStore, enforceLoadingBoundary, type IQueue, type QueueCallback } from "./scheduler.cjs";
+export { flush, Queue, GlobalQueue, trackOptimisticStore, enforceLoadingBoundary, resetErrorHalt, type IQueue, type QueueCallback } from "./scheduler.cjs";
 export { DEV, type Dev, type DevHooks, type DiagnosticCapture, type DiagnosticCode, type DiagnosticEvent, type DiagnosticKind, type Diagnostics, type DiagnosticSeverity } from "./dev.cjs";
 export * from "./constants.cjs";

package/dist/types-cjs/core/invariants.d.cts

@@ -0,0 +1,49 @@
+import type { OptimisticLane } from "./lanes.cjs";
+import type { Computed, Signal } from "./types.cjs";
+/**
+ * Test-mode invariant checks for the async/transition/lane machinery.
+ * Catalog and rationale: packages/solid-signals/INTERNALS-ASYNC-STATE.md.
+ *
+ * These are implementation self-consistency checks, not semantic rules: a
+ * violation means the reactive system contradicted itself.
+ *
+ * They are gated on `__TEST__` (not just `__DEV__`): the per-write Set
+ * tracking and per-flush quiescence sweep are too expensive for shipped dev
+ * builds and for benchmarks (they showed up as a 5-21% hit across the
+ * CodSpeed suite when they ran under `__DEV__`). Call sites stay `__DEV__`
+ * guarded so production tree-shakes the calls; each entry point here
+ * early-returns unless `__TEST__` is set, so dev builds pay only a no-op
+ * call. The test suite (vitest run) defines `__TEST__: true`; benchmark mode
+ * defines `__TEST__: false`.
+ */
+type AnyNode = Signal<any> | Computed<any>;
+/** Wired by core.ts at module init to avoid import cycles. */
+export declare const InvariantHooks: {
+    pendingProbeActive: (() => boolean) | null;
+    /** Fresh oracle for what an isPending companion SHOULD read right now. */
+    computePendingState: ((node: AnyNode) => boolean) | null;
+};
+export declare function devTrackHeldPending(node: AnyNode): void;
+export declare function devTrackCompanionOwner(node: AnyNode): void;
+export declare function devTrackOptimistic(node: AnyNode): void;
+/**
+ * Open/close the sanctioned registration window. Call sites are `__DEV__`
+ * guarded (no prod cost); the code inside the window must not throw.
+ */
+export declare function beginAsyncReporterWrites(): void;
+export declare function endAsyncReporterWrites(): void;
+export declare function createAsyncReporters(): Map<Computed<any>, Set<Computed<any>>>;
+export declare function devCheckActiveOverrides(isRegisteredForRevert: (node: AnyNode) => boolean): void;
+/** INV-1: an isPending() probe must never leak past its own call. */
+export declare function devCheckFlushStart(): void;
+/** INV-5: a merged lane's work moved to its root on merge and must stay empty. */
+export declare function devCheckMergedLaneEmpty(lane: OptimisticLane): void;
+export declare function devCensusCompanions(isQueuedForCommit?: (node: AnyNode) => boolean): void;
+/**
+ * Quiescence checks. Run only when the system is fully drained: nothing
+ * scheduled, no active/stashed transitions, no live lanes. At that point no
+ * transition-scoped state may survive, and the lazily-created companions must
+ * agree with a fresh computation of their owner's state.
+ */
+export declare function devCheckQuiescent(isQueuedForCommit: (node: AnyNode) => boolean): void;
+export {};

package/dist/types-cjs/core/scheduler.d.cts

@@ -41,6 +41,14 @@ export interface Transition {
     _gatedSubs: Set<Computed<any>>;
 }
 export declare function schedule(): void;
+/**
+ * Permanently halts the reactive system. Called when a user error escapes
+ * every boundary — app state is undefined at that point, so scheduling stops
+ * entirely rather than limping along with a half-applied update.
+ */
+export declare function haltReactivity(): void;
+/** @internal Test/dev-reload hook. Revives scheduling after a halt. */
+export declare function resetErrorHalt(): void;
 export interface IQueue {
     enqueue(type: number, fn: QueueCallback): void;
     run(type: number): boolean | void;