@solidjs/signals 2.0.0-beta.18 → 2.0.0-beta.20

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

@@ -48,6 +48,13 @@ export declare const DEV: Dev;
  */
 export declare function assertInvariant(condition: boolean, name: string, message: string): void;
 export declare function emitDiagnostic(event: Omit<DiagnosticEvent, "sequence">): DiagnosticEvent;
+/**
+ * Shared strict-read diagnostics for core read() and the store proxy traps.
+ * Single source for the message text — the #2897 safeguard parity between
+ * memos and stores is exactly these firing identically from both paths.
+ */
+export declare function throwPendingUntrackedRead(strictReadLabel: string, fields?: Partial<Omit<DiagnosticEvent, "sequence" | "data">>): never;
+export declare function warnStrictReadUntracked(strictReadLabel: string, fields?: Partial<Omit<DiagnosticEvent, "sequence">>): void;
 export declare function registerGraph(value: any, owner: Owner | null): void;
 export declare function clearSignals(node: Owner): void;
 export declare function getChildren(owner: Owner): Owner[];

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

@@ -11,35 +11,5 @@ export declare let externalSourceConfig: {
     factory: ExternalSourceFactory;
     untrack: <T>(fn: () => T) => T;
 } | null;
-/**
- * Registers a factory that bridges external reactive systems (e.g. MobX, Vue refs)
- * into Solid's tracking graph. Every computation will be wrapped so that the
- * external library can track its own dependencies alongside Solid's.
- *
- * Multiple calls pipe together: each new factory wraps the previous one.
- *
- * @param config.factory receives `(fn, trigger)` — wrap fn execution in external tracking,
- *   call trigger when external deps change. Return `{ track, dispose }`.
- * @param config.untrack optional wrapper for `untrack` — disables external tracking too.
- *
- * @example
- * ```ts
- * // Bridge an external "subscribe / notify" library into Solid's graph.
- * // `factory` wraps every Solid compute so the external library can attach
- * // its own dependency tracker; `trigger` re-runs the compute on external
- * // change. `untrack` mirrors Solid's `untrack()` into the external library
- * // so that reads inside `untrack(...)` don't get tracked twice.
- * enableExternalSource({
- *   factory: (compute, trigger) => {
- *     const sub = externalLib.subscribe(trigger);
- *     return {
- *       track: prev => externalLib.run(() => compute(prev)),
- *       dispose: () => sub.unsubscribe()
- *     };
- *   },
- *   untrack: fn => externalLib.untracked(fn)
- * });
- * ```
- */
 export declare function enableExternalSource(config: ExternalSourceConfig): void;
 export declare function _resetExternalSourceConfig(): void;

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

@@ -1,4 +1,12 @@
 import type { Computed } from "./types.js";
+/** The queue a node belongs to, picked from its own zombie flag. */
+export declare function queueFor(n: Computed<any>): Heap;
+/**
+ * Schedule one subscriber to re-run on the next flush: tracked effects bypass
+ * the heap and go directly to their effect queue; everything else is inserted
+ * into its own (zombie-flag-routed) heap with the `_min` cursor pulled down.
+ */
+export declare function enqueueSub(node: Computed<any>): void;
 export interface Heap {
     _heap: (Computed<unknown> | undefined)[];
     _marked: boolean;

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

@@ -1,12 +1,13 @@
 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, 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";
 export { handleAsync } from "./async.js";
+export { isPending, latest } from "./verdict.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, resetErrorHalt, type IQueue, type QueueCallback } from "./scheduler.js";
+export { flush, Queue, GlobalQueue, 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/lanes.d.ts

@@ -37,6 +37,8 @@ export declare function resolveLane(el: {
 export declare function resolveTransition(el: {
     _optimisticLane?: OptimisticLane;
     _transition?: Transition | null;
+    _overrideValue?: any;
+    _overrideOwner?: Transition | null;
 }): Transition | null | undefined;
 /**
  * Check if a node has an active optimistic override.

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

@@ -0,0 +1,6 @@
+/**
+ * Installs the engine's hooks. Idempotent; called by every module that can
+ * create optimistic state (verdict.ts at module top level, createOptimistic
+ * and createOptimisticStore at first call) BEFORE any optimistic node exists.
+ */
+export declare function installOptimisticEngine(): void;

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

@@ -9,6 +9,14 @@ export declare function disposeChildren(node: Owner, self?: boolean, zombie?: bo
  * @internal
  */
 export declare function getNextChildId(owner: Owner): string;
+/**
+ * The id a freshly-created node inherits: an explicit `options.id` wins;
+ * transparent nodes share their parent's id; otherwise the parent's next
+ * child id is consumed (or `undefined` outside an id-carrying tree).
+ */
+export declare function inheritId(options: {
+    id?: string;
+} | undefined, transparent: boolean, parent: Owner | null | undefined): string | undefined;
 /**
  * Returns the *next* child id for `owner` without consuming it. Used by
  * hydration plumbing to peek at the id a future child will receive.

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

@@ -1,5 +1,5 @@
 import { type Heap } from "./heap.js";
-import { activeLanes, assignOrMergeLane, findLane } from "./lanes.js";
+import { activeLanes, assignOrMergeLane, findLane, type OptimisticLane } from "./lanes.js";
 import type { Computed, Signal } from "./types.js";
 export { activeLanes, assignOrMergeLane, findLane };
 export { getOrCreateLane, hasActiveOverride, mergeLanes, resolveLane } from "./lanes.js";
@@ -20,7 +20,6 @@ export declare function resetUnhandledAsync(): void;
  * @internal
  */
 export declare function enforceLoadingBoundary(enabled: boolean): void;
-export declare function shouldReadStashedOptimisticValue(node: Signal<any>): boolean;
 export declare function setProjectionWriteActive(value: boolean): void;
 export declare function setTrackedQueueCallback(value: boolean): void;
 export type QueueCallback = (type: number) => void;
@@ -47,7 +46,7 @@ export declare function schedule(): void;
  * 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;
+export declare function haltReactivity(cause?: unknown): void;
 /** @internal Test/dev-reload hook. Revives scheduling after a halt. */
 export declare function resetErrorHalt(): void;
 export interface IQueue {
@@ -76,18 +75,44 @@ export declare class Queue implements IQueue {
 }
 export declare class GlobalQueue extends Queue {
     _running: boolean;
-    _pendingNode: Signal<any> | null;
-    _pendingNodes: Signal<any>[];
-    _optimisticNodes: OptimisticNode[];
-    _affectsNodes: OptimisticNode[];
-    _optimisticStores: Set<any>;
+    _batch: Transition;
     static _update: (el: Computed<unknown>) => void;
     static _dispose: (el: Computed<unknown>, self: boolean, zombie: boolean) => void;
     static _runEffect: (el: Computed<unknown>) => void;
-    static _clearOptimisticStore: ((store: any) => void) | null;
+    static _clearOptimisticStores: ((stores: Set<any>, completing: Transition | null) => void) | null;
     static _releaseAffectsScope: ((node: OptimisticNode) => void) | null;
-    static _propagateAffects: ((node: OptimisticNode) => void) | null;
-    static _settleAffects: ((node: OptimisticNode) => void) | null;
+    static _applyAffectsReads: ((el: Computed<any>, sources: (Signal<any> | Computed<any>)[]) => void) | null;
+    static _releaseAffectsMarks: ((nodes: OptimisticNode[]) => void) | null;
+    static _markAffects: ((node: OptimisticNode) => void) | null;
+    static _releaseAffectsMark: ((node: OptimisticNode) => void) | null;
+    static _onlyMarkPending: ((el: Computed<any>) => boolean) | null;
+    static _collectMarkSources: ((el: Computed<any>, into: OptimisticNode[]) => void) | null;
+    static _wireExternalSource: ((self: Computed<any>) => void) | null;
+    static _externalUntrack: (<T>(fn: () => T) => T) | null;
+    static _syncCompanions: (<T>(el: Signal<T> | Computed<T>, value: T) => void) | null;
+    static _updatePendingSignal: ((el: OptimisticNode) => void) | null;
+    static _updateChildCompanions: ((el: Computed<any>) => void) | null;
+    static _snapCompanions: ((el: OptimisticNode) => void) | null;
+    static _latestRead: (<T>(el: Signal<T> | Computed<T>) => T) | null;
+    static _pendingCheck: ((el: OptimisticNode, c: Computed<any> | null, owner: OptimisticNode, firewall: Computed<any> | null) => void) | null;
+    static _recordFresh: ((el: OptimisticNode, value: any) => void) | null;
+    static _applyReask: ((el: Computed<any>, hadReask: boolean) => boolean) | null;
+    static _repollVerdicts: ((el: Computed<any>) => void) | null;
+    static _witnessAffects: ((node: OptimisticNode) => void) | null;
+    static _optimisticWrite: (<T>(el: Signal<T> | Computed<T>, v: T | ((prev: T) => T)) => T) | null;
+    static _resolveOptimistic: ((nodes: OptimisticNode[]) => void) | null;
+    static _stashOptimistic: ((stashedTransition: Transition) => void) | null;
+    static _transitionBlocked: ((transition: Transition) => boolean) | null;
+    static _cleanupLanes: ((completingTransition: Transition | null) => void) | null;
+    static _runLaneEffects: ((type: number) => void) | null;
+    static _readStashed: ((el: Signal<any>) => boolean) | null;
+    static _gatedRead: ((el: Signal<any>, owner: OptimisticNode, c: Computed<any>) => boolean) | null;
+    static _laneSuspends: ((owner: OptimisticNode) => boolean) | null;
+    static _laneReadsCommitted: ((el: OptimisticNode, owner: OptimisticNode, c: Computed<any>) => boolean) | null;
+    static _recomputeLane: ((el: Computed<any>, own: boolean) => OptimisticLane | null) | null;
+    static _laneAsyncPending: ((el: Computed<any>) => void) | null;
+    static _laneAsyncSettled: ((el: Computed<any>) => void) | null;
+    static _trackOptimisticStore: ((store: any) => void) | null;
     flush(): void;
     notify(node: Computed<any>, mask: number, flags: number, error?: any): boolean;
     initTransition(transition?: Transition | null): void;
@@ -96,7 +121,6 @@ export declare function queuePendingNode(node: Signal<any>): void;
 export declare function armReaskClear(): void;
 export declare function insertSubs(node: Signal<any> | Computed<any>, optimistic?: boolean): void;
 export declare function finalizePureQueue(completingTransition?: Transition | null, incomplete?: boolean): void;
-export declare function trackOptimisticStore(store: any): void;
 /**
  * Count of live `affects()` registrations across the system (including
  * store-scope inherited marks). Gates the read-path mark check in `read()` so
@@ -104,36 +128,13 @@ export declare function trackOptimisticStore(store: any): void;
  */
 export declare let activeAffectsMarks: number;
 /**
- * The counting half of a mark, shared by direct registration and store-scope
- * inheritance (a node created inside a live keyless mark's identity scope):
- * bumps the refcount and pokes the node's verdict companions so an
- * already-materialized `false` flips reactively.
- *
- * @internal
- */
-export declare function markAffects(node: OptimisticNode): void;
-/**
- * Registers one `affects()` mark on a node: counts it, records the
- * registration with the current transaction (after initTransition the queue's
- * array aliases the active transition's, mirroring `_optimisticNodes`), and
- * propagates STATUS_PENDING downstream on the status rails so everything
- * DERIVED from the marked data reads pending too. Propagation runs on every
- * registration (not just the first): subscribers gained since an earlier
- * overlapping registration get covered, and dedup stops re-descent early.
- *
- * @internal
- */
-export declare function registerAffectsMark(node: OptimisticNode): void;
-/**
- * Releases one registration. When the node's last mark drops, settles the
- * mark's sentinel out of every downstream `_pendingSources` (waking blocked
- * nodes and re-deriving verdicts along the walk). Companion writes go through
- * the settlement snap (committed, not transition-scoped) so releasing a mark
- * can't open a fresh override window that would itself need settlement.
+ * Counter mutation seam for the mark engine in affects.ts: an imported `let`
+ * binding is read-only, and the read-path gate above must stay a plain module
+ * variable so `read()` pays one integer compare, not a function call.
  *
  * @internal
  */
-export declare function releaseAffectsMark(node: OptimisticNode): void;
+export declare function shiftAffectsMarks(delta: 1 | -1): void;
 export declare const globalQueue: GlobalQueue;
 /**
  * Synchronously processes the pending reactive queue, or runs `fn` in a synchronous

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

@@ -44,6 +44,15 @@ export interface RawSignal<T> {
     _transition: Transition | null;
     _pendingValue: T | typeof NOT_PENDING;
     _overrideValue?: T | typeof NOT_PENDING;
+    /**
+     * The transaction that owns the active override (stamped at optimistic
+     * write, cleared at settle). Ownership must live on the node: a lane's
+     * _transition is a scheduling affinity that a shared subscriber can merge
+     * across transactions (#2912) — following it would let one action's settle
+     * revert another action's live override. Node-level sibling of the store
+     * layer's STORE_OPTIMISTIC_OWNERS stamps (#2899). `null` = ambient write.
+     */
+    _overrideOwner?: Transition | null;
     _optimisticLane?: OptimisticLane;
     _pendingSignal?: Signal<boolean>;
     _latestValueComputed?: Computed<T>;
@@ -93,7 +102,6 @@ export interface Computed<T> extends RawSignal<T>, Owner {
     _depGen: number;
     _flags: number;
     _blocked?: boolean;
-    _pendingSource?: Computed<any>;
     _pendingSources?: Set<Computed<any>>;
     _error?: unknown;
     _statusFlags: number;

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

@@ -0,0 +1,2 @@
+export declare function latest<T>(fn: () => T): T;
+export declare function isPending(fn: () => any): boolean;

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

@@ -63,4 +63,3 @@ export declare function createProjection<T extends object = {}>(fn: (draft: T) =
  */
 export declare function runProjectionComputed<T extends object>(wrappedStore: Store<T>, fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, key: string | ((item: NonNullable<any>) => any), wrapCommit?: (write: () => void) => void, onDraftWrite?: () => void): Computed<void | T>;
 export declare function createWriteTraps(isActive?: () => boolean, onDraftWrite?: () => void): ProxyHandler<any>;
-export declare const writeTraps: ProxyHandler<any>;

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

@@ -1,4 +1,5 @@
 import { STORE_SNAPSHOT_PROPS, type Computed, type Refreshable, type Signal } from "../core/index.js";
+import { type Transition } from "../core/scheduler.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>;
 /**
@@ -41,12 +42,13 @@ type DataNodes = Record<PropertyKey, DataNode>;
  * @internal
  */
 export declare const $TRACK: unique symbol, $TARGET: unique symbol, $PROXY: unique symbol, $DELETED: unique symbol, $AFFECTS: 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_OPTIMISTIC_OWNERS = "t", STORE_PARENT = "u", STORE_DESC = "d";
 export type StoreNode = {
     [$PROXY]: any;
     [STORE_VALUE]: Record<PropertyKey, any>;
     [STORE_OVERRIDE]?: Record<PropertyKey, any>;
     [STORE_OPTIMISTIC_OVERRIDE]?: Record<PropertyKey, any>;
+    [STORE_OPTIMISTIC_OWNERS]?: Record<PropertyKey, Transition | null>;
     [STORE_NODE]?: DataNodes;
     [STORE_HAS]?: DataNodes;
     [STORE_CUSTOM_PROTO]?: boolean;
@@ -55,6 +57,8 @@ export type StoreNode = {
     [STORE_FIREWALL]?: Computed<any>;
     [STORE_OPTIMISTIC]?: boolean;
     [STORE_SNAPSHOT_PROPS]?: Record<PropertyKey, any>;
+    [STORE_PARENT]?: StoreNode;
+    [STORE_DESC]?: boolean;
 };
 export declare namespace SolidStore {
     interface Unwrappable {
@@ -91,7 +95,7 @@ export declare function visibleNodeValue(node: DataNode): any;
  *
  * @internal
  */
-export declare function witnessAffectsMark(target: StoreNode): void;
+export declare function witnessAffectsMark(target: StoreNode, property?: PropertyKey): void;
 /**
  * Resolves the store nodes an `affects()` declaration marks: with a `key`,
  * the named slot's leaf node (upserted so the mark has an addressable
@@ -114,6 +118,8 @@ export declare function notifySelf(target: StoreNode): void;
  */
 export declare function mergedOverlay(target: StoreNode): Record<PropertyKey, any> | undefined;
 export declare function getKeys(source: Record<PropertyKey, any>, override: Record<PropertyKey, any> | undefined, enumerable?: boolean): PropertyKey[];
+export declare function getStoreKeys(source: Record<PropertyKey, any>, override: Record<PropertyKey, any> | undefined): PropertyKey[];
+export declare function getStoreSymbols(source: Record<PropertyKey, any>, override: Record<PropertyKey, any> | undefined): symbol[];
 export declare function getPropertyDescriptor(source: Record<PropertyKey, any>, override: Record<PropertyKey, any> | undefined, property: PropertyKey): PropertyDescriptor | undefined;
 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/affects.d.cts

@@ -1,5 +1,5 @@
-import { type Store } from "./store/store.cjs";
 import type { Accessor } from "./signals.cjs";
+import { type Store } from "./store/store.cjs";
 /**
  * Declares that in-flight work will change the targeted data: the named
  * slot(s) — and everything DERIVED from them — read as pending

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

@@ -20,7 +20,7 @@ export declare class RevealController {
     _evaluating: boolean;
     constructor(order: OrderAccessor, collapsed: BoolAccessor);
     _forEachOwnedSlot(fn: (slot: RevealSlot) => boolean | void): boolean;
-    isReady(): 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.
@@ -28,10 +28,10 @@ export declare class RevealController {
      * - `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;
+    _isMinimallyReady(): boolean;
+    _register(slot: RevealSlot): void;
+    _unregister(slot: RevealSlot): void;
+    _evaluate(disabledOverride?: boolean, collapsedOverride?: boolean): void;
 }
 export declare class CollectionQueue extends Queue {
     _collectionType: number;
@@ -48,7 +48,7 @@ export declare class CollectionQueue extends Queue {
     constructor(type: number);
     run(type: number): void;
     notify(node: Effect<any>, type: number, flags: number, error?: any): boolean;
-    checkSources(): void;
+    _checkSources(): void;
 }
 /**
  * Lower-level primitive that backs the `<Loading>` flow control. Catches

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

@@ -4,10 +4,22 @@
  * surrounding UI sees one atomic update per yielded step; nothing is committed
  * until the action either completes or the next `yield` resolves.
  *
- * Yield promises (or any awaitable) inside the generator — the action waits
- * for each before continuing, but the writes you made beforehand are already
- * visible (or held by `<Loading>` if optimistic). Yield bare values for
- * synchronous batched steps.
+ * `yield` is the transaction-safe suspension point: the action waits for a
+ * yielded promise and re-enters the transaction before running the code after
+ * it. A plain `await` does NOT — the runtime has no hook into an async
+ * generator's internal await continuations, so writes to fresh signals
+ * between an `await` and the next `yield` escape the transaction and commit
+ * immediately. `await` is still the ergonomic choice for typed results; just
+ * put a bare `yield` before any writes that follow it:
+ *
+ * ```ts
+ * const saved = await api.createTodo(text); // typed result
+ * yield; // re-enter the transaction before writing
+ * setTodos(t => { ... });
+ * ```
+ *
+ * (For the same reason, don't call `flush()` inside an action body — it
+ * drains the transaction mid-step.)
  *
  * Each call returns a `Promise` that resolves with the generator's return
  * value, or rejects if it throws. Pair with `createOptimistic` /
@@ -18,10 +30,11 @@
  * ```ts
  * const [todos, setTodos] = createOptimisticStore<Todo[]>([]);
  *
- * const addTodo = action(function* (text: string) {
+ * const addTodo = action(async function* (text: string) {
  *   const tempId = crypto.randomUUID();
  *   setTodos(t => { t.push({ id: tempId, text, pending: true }); }); // optimistic
- *   const saved = yield api.createTodo(text); // network round-trip
+ *   const saved = await api.createTodo(text); // network round-trip, typed
+ *   yield; // re-enter the transaction
  *   setTodos(t => {
  *     const i = t.findIndex(x => x.id === tempId);
  *     if (i >= 0) t[i] = saved;

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

@@ -1,44 +1,10 @@
 import { type OptimisticLane } from "./lanes.cjs";
-import type { Computed, Signal } from "./types.cjs";
+import type { Computed, Link } from "./types.cjs";
+export declare function addPendingSource(el: Computed<any>, source: Computed<any>): boolean;
+export declare function setPendingError(el: Computed<any>, source?: Computed<any>, error?: any): void;
+export declare function forEachDependent(el: Computed<any>, fn: (node: Computed<any>, link: Link) => void): void;
 export declare function settlePendingSource(el: Computed<any>, source?: Computed<any>, snap?: boolean): 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;
-/**
- * The pending-source identity of a live `affects()` mark on `node` (lazy,
- * one per node, shared by overlapping registrations via the refcount).
- *
- * A mark rides the SAME status rails as real in-flight async — downstream
- * subscribers hold the sentinel in `_pendingSources` — but under its own
- * identity so the two channels can't clear each other:
- * - `_reask` is permanently `false`: a mark is by definition a declared
- *   value change, so `quietPending` never silences a window it participates
- *   in — even when the mark rides over an otherwise-quiet `refresh()`
- *   re-ask of the same node (the whole point of declaring one).
- * - A landing on the marked node settles only the node's OWN source entry;
- *   the sentinel entry survives until the mark's transaction releases it.
- * - The sentinel itself never carries `STATUS_PENDING`, so
- *   `transitionComplete` never counts a mark as a blocker of its own
- *   transaction (release happens AT settle — self-blocking would deadlock),
- *   and reads of the marked node never throw (marks are value-transparent
- *   at the source; pendingness is what propagates).
- */
-export declare function getAffectsSentinel(node: Signal<any> | Computed<any>): Computed<any>;
-/**
- * Push a live mark's pendingness downstream from the marked node through the
- * normal status rails. Runs on every registration (dedup in `notifyStatus`
- * stops re-descent at already-covered subscribers). Subscribers that
- * recompute mid-window shed this via `clearStatus` and re-acquire it through
- * the read path (`applyAffectsReads`) — the same shape as real async, where
- * the re-throw on read re-establishes the source.
- */
-export declare function propagateAffectsMark(node: Signal<any> | Computed<any>): void;
-/**
- * Re-establish mark pendingness on a computed that read marked sources
- * during its recompute (`clearStatus` at the top of the commit path wiped
- * any sentinel entries it held). Called by `recompute` after the commit —
- * not before, because setting `_error` earlier would make the commit path
- * treat the node as errored and skip the value write.
- */
-export declare function applyAffectsReads(el: Computed<any>, sources: (Signal<any> | Computed<any>)[]): void;

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

@@ -35,6 +35,18 @@ export declare const EFFECT_USER = 2;
 export declare const EFFECT_TRACKED = 3;
 export declare const NOT_PENDING: {};
 export declare const NO_SNAPSHOT: {};
+/**
+ * Stand-in stored in `_overrideValue` for an optimistic write of literal
+ * `undefined` (#2898). The slot doubles as the optimistic-node brand
+ * (`undefined` = not optimistic, `NOT_PENDING` = at rest), so the raw value
+ * would erase the node's optimistic identity: the write turns invisible and
+ * follow-up writes route off the optimistic path and commit permanently.
+ * Same shape as NO_SNAPSHOT. Sites that surface the override VALUE unwrap
+ * via `visibleOverrideValue`; slot identity tests stay raw.
+ */
+export declare const OVERRIDE_UNDEFINED: {};
+/** Unwrap an active override's stored value for surfacing to readers (#2898). */
+export declare function unwrapOverride<T = any>(v: unknown): T;
 export declare const STORE_SNAPSHOT_PROPS = "sp";
 export declare const SUPPORTS_PROXY: boolean;
 export declare const defaultContext: {};

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

@@ -5,6 +5,12 @@ export declare const PRIMITIVE_IN_FORBIDDEN_SCOPE_MESSAGE = "[PRIMITIVE_IN_FORBI
 export declare const REACTIVE_WRITE_IN_OWNED_SCOPE_SIGNAL_MESSAGE: string;
 export declare const REACTIVE_WRITE_IN_OWNED_SCOPE_REFRESH_MESSAGE: string;
 export declare let tracking: boolean;
+/** @internal verdict-module glue */
+export declare function setPendingCheckActive(v: boolean): void;
+/** @internal verdict-module glue */
+export declare function setLatestReadActive(v: boolean): void;
+/** @internal verdict-module glue */
+export declare function setContextInternal(v: Owner | null): void;
 export declare let stale: boolean;
 export declare let pendingCheckActive: boolean;
 export declare let latestReadActive: boolean;
@@ -60,6 +66,12 @@ export declare function setStrictRead(v: string | false): string | false;
  * ```
  */
 export declare function untrack<T>(fn: () => T, strictReadLabel?: string | false): T;
+/**
+ * Bring a computed to a readable state: lazy/disposed nodes are (re)computed;
+ * an isPending() probe (`refresh`) additionally pulls the node fully up to
+ * date so its status flags reflect the current graph.
+ */
+export declare function prepareComputed(comp: Computed<unknown>, refresh: boolean): void;
 export declare function read<T>(el: Signal<T> | Computed<T>): T;
 export declare function setSignal<T>(el: Signal<T> | Computed<T>, v: T | ((prev: T) => T)): T;
 /**
@@ -97,85 +109,7 @@ 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;
-/**
- * Adds a node to the active isPending() probe without reading it. The store's
- * untracked-probe fallback (`witnessAffectsMark`) calls this with `affects()`
- * carrier nodes: an untracked read through a marked record may touch no real
- * signal node at all, so the probe collects the mark's carrier directly.
- *
- * @internal
- */
-export declare function witnessAffects(node: Signal<any> | Computed<any>): void;
-/**
- * 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.
- * always returns the most-recently-committed value, even when newer reads
- * inside `fn` are still in flight.
- *
- * Useful inside a `<Loading>` boundary's children when you want to keep
- * showing the previous resolved data instead of the fallback while the next
- * value loads.
- *
- * @example
- * ```tsx
- * <Loading fallback={<Skeleton />}>
- *   {/* During a transition, render the previous user instead of skeleton: *\/}
- *   <UserCard user={latest(() => user())} />
- * </Loading>
- * ```
- */
-export declare function latest<T>(fn: () => T): T;
-/**
- * Returns `true` if any reactive read inside `fn` is showing a stale value
- * while newer async work is pending. Does not subscribe — pair with a tracked
- * memo if you want to react to pending status changes.
- *
- * Useful for showing inline transition indicators alongside the previous
- * value (rather than swapping to a `<Loading>` fallback).
- * Because `fn` is read normally, `isPending` participates in Loading/SSR
- * readiness the same way the read itself would.
- *
- * @example
- * ```tsx
- * const pending = createMemo(() => isPending(() => user()));
- *
- * <button disabled={pending()}>{pending() ? "Saving…" : "Save"}</button>
- *
- * <button disabled={isPending(() => user())}>Save</button>
- * ```
- */
-export declare function isPending(fn: () => any): boolean;
 /**
  * Invalidates one reactive source, forcing it to re-execute even if its inputs
  * haven't changed.

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

@@ -48,6 +48,13 @@ export declare const DEV: Dev;
  */
 export declare function assertInvariant(condition: boolean, name: string, message: string): void;
 export declare function emitDiagnostic(event: Omit<DiagnosticEvent, "sequence">): DiagnosticEvent;
+/**
+ * Shared strict-read diagnostics for core read() and the store proxy traps.
+ * Single source for the message text — the #2897 safeguard parity between
+ * memos and stores is exactly these firing identically from both paths.
+ */
+export declare function throwPendingUntrackedRead(strictReadLabel: string, fields?: Partial<Omit<DiagnosticEvent, "sequence" | "data">>): never;
+export declare function warnStrictReadUntracked(strictReadLabel: string, fields?: Partial<Omit<DiagnosticEvent, "sequence">>): void;
 export declare function registerGraph(value: any, owner: Owner | null): void;
 export declare function clearSignals(node: Owner): void;
 export declare function getChildren(owner: Owner): Owner[];

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

@@ -11,35 +11,5 @@ export declare let externalSourceConfig: {
     factory: ExternalSourceFactory;
     untrack: <T>(fn: () => T) => T;
 } | null;
-/**
- * Registers a factory that bridges external reactive systems (e.g. MobX, Vue refs)
- * into Solid's tracking graph. Every computation will be wrapped so that the
- * external library can track its own dependencies alongside Solid's.
- *
- * Multiple calls pipe together: each new factory wraps the previous one.
- *
- * @param config.factory receives `(fn, trigger)` — wrap fn execution in external tracking,
- *   call trigger when external deps change. Return `{ track, dispose }`.
- * @param config.untrack optional wrapper for `untrack` — disables external tracking too.
- *
- * @example
- * ```ts
- * // Bridge an external "subscribe / notify" library into Solid's graph.
- * // `factory` wraps every Solid compute so the external library can attach
- * // its own dependency tracker; `trigger` re-runs the compute on external
- * // change. `untrack` mirrors Solid's `untrack()` into the external library
- * // so that reads inside `untrack(...)` don't get tracked twice.
- * enableExternalSource({
- *   factory: (compute, trigger) => {
- *     const sub = externalLib.subscribe(trigger);
- *     return {
- *       track: prev => externalLib.run(() => compute(prev)),
- *       dispose: () => sub.unsubscribe()
- *     };
- *   },
- *   untrack: fn => externalLib.untracked(fn)
- * });
- * ```
- */
 export declare function enableExternalSource(config: ExternalSourceConfig): void;
 export declare function _resetExternalSourceConfig(): void;