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

package/dist/types/affects.d.ts

@@ -0,0 +1,47 @@
+import { type Store } from "./store/store.js";
+import type { Accessor } from "./signals.js";
+/**
+ * Declares that in-flight work will change the targeted data: the named
+ * slot(s) — and everything DERIVED from them — read as pending
+ * (`isPending` → `true`) from the declaration until the surrounding
+ * transaction settles or reverts. Marks ride the same status rails as real
+ * in-flight async, so pendingness flows through memos and effects like any
+ * other pending source, while the marked values themselves stay readable
+ * (a mark is a promise of change, not an absence of value). This is the
+ * declaration verb of the pending model — additive only. A mark can turn
+ * pending ON for data the graph can't see changing yet; nothing can turn
+ * pending OFF while a real change is in flight — a quiet `refresh()`
+ * re-ask under a mark still reads pending (declaring the reload is what
+ * makes it a real question).
+ *
+ * Targets:
+ * - `affects(store)` — a store proxy (any record, root or nested): every
+ *   record reachable from it at declaration time reads pending, including
+ *   through captured child proxies (e.g. `<For>` rows). Siblings are
+ *   untouched; records added after the declaration are not covered.
+ * - `affects(record, key)` — exactly the named slot of the record. One key
+ *   per call (keys do NOT form a path — target the owning record directly).
+ * - `affects(accessor)` — a source accessor (signal or memo): the source
+ *   reads pending.
+ *
+ * Typically called at the top of an `action` alongside optimistic writes —
+ * both are up-front declarations about the same mutation. Outside any
+ * transaction the mark is released at the end of the current flush.
+ *
+ * @example
+ * ```ts
+ * const send = action(function* (text: string) {
+ *   setState(s => { s.messages.push({ text, status: "sending" }); });
+ *   affects(state.messages.at(-1)!, "status"); // this slot pends until settle
+ *   yield api.send(text);
+ * });
+ *
+ * const reload = action(function* () {
+ *   affects(thing);      // the whole store pends…
+ *   refresh(thing);      // …over this otherwise-quiet re-ask
+ *   yield api.done();
+ * });
+ * ```
+ */
+export declare function affects(target: Accessor<unknown> | Store<object>): void;
+export declare function affects<T extends object>(target: Store<T>, key: keyof T): void;

package/dist/types/boundaries.d.ts

@@ -24,7 +24,7 @@ export declare class RevealController {
     /**
      * "Minimally ready" = this group has something visible to show under its own policy.
      * Used by an enclosing `together` group to decide when it can release.
-     * - `together`: fully ready (atomic).
+     * - `together`: every direct slot is minimally ready.
      * - `sequential`: the first owned slot is minimally ready (frontier can advance).
      * - `natural`: any owned slot is minimally ready.
      */
@@ -128,7 +128,7 @@ export declare function createErrorBoundary<T, U>(fn: () => T, fallback: (error:
  *   own minimal signal).
  * - `together` — every direct slot is minimally ready.
  * - `natural` — any direct slot has visible content (leaves on resolve; nested
- *   composites when fully ready, since natural treats composites as atomic).
+ *   composites via their own minimal signal).
  *
  * @example
  * ```ts

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

@@ -1,7 +1,44 @@
 import { type OptimisticLane } from "./lanes.js";
-import type { Computed } from "./types.js";
-export declare function settlePendingSource(el: Computed<any>): void;
+import type { Computed, Signal } from "./types.js";
+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/core/constants.d.ts

@@ -10,6 +10,14 @@ export declare const REACTIVE_OPTIMISTIC_DIRTY: number;
 export declare const REACTIVE_SNAPSHOT_STALE: number;
 export declare const REACTIVE_LAZY: number;
 export declare const REACTIVE_MANUAL_WRITE: number;
+/**
+ * The pending recompute is a re-ask of the same question: `refresh()` dirtied
+ * the node while no tracked input changed value. Cleared whenever a real
+ * value-change notification arrives (`insertSubs`), and consumed by
+ * `recompute` into the node's `_reask` classification — a quiet (re-ask)
+ * pending window does not read as pending (question-scoped pending model).
+ */
+export declare const REACTIVE_REASK: number;
 export declare const CONFIG_OWNED_WRITE: number;
 export declare const CONFIG_NO_SNAPSHOT: number;
 export declare const CONFIG_TRANSPARENT: number;

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

@@ -97,6 +97,15 @@ 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

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

@@ -6,7 +6,7 @@ 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" | "ACTION_CALLED_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 DiagnosticCode = "STRICT_READ_UNTRACKED" | "PENDING_ASYNC_UNTRACKED_READ" | "PENDING_ASYNC_FORBIDDEN_SCOPE" | "REACTIVE_WRITE_IN_OWNED_SCOPE" | "ACTION_CALLED_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" | "INVALID_AFFECTS_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;

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, updatePendingSignal, updateChildCompanions, refresh, staleValues, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots } from "./core.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 { 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";

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

@@ -26,6 +26,7 @@ export declare const InvariantHooks: {
 export declare function devTrackHeldPending(node: AnyNode): void;
 export declare function devTrackCompanionOwner(node: AnyNode): void;
 export declare function devTrackOptimistic(node: AnyNode): void;
+export declare function devTrackAffects(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.
@@ -33,6 +34,15 @@ export declare function devTrackOptimistic(node: AnyNode): void;
 export declare function beginAsyncReporterWrites(): void;
 export declare function endAsyncReporterWrites(): void;
 export declare function createAsyncReporters(): Map<Computed<any>, Set<Computed<any>>>;
+/**
+ * INV-2: a node with an *active* override must be registered for reversion in
+ * the queue's or a transition's `_optimisticNodes`. An unregistered active
+ * override would survive transition completion forever. Runs at the end of
+ * every flush (not just quiescence — the invariant holds mid-transition).
+ * (There is no revert-target requirement: authoritative values commit
+ * silently into `_value` under the override mask — A17 — so reverting is
+ * just dropping the override.)
+ */
 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;

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

@@ -34,6 +34,7 @@ export interface Transition {
     _asyncReporters: Map<Computed<any>, Set<Computed<any>>>;
     _pendingNodes: Signal<any>[];
     _optimisticNodes: OptimisticNode[];
+    _affectsNodes: OptimisticNode[];
     _optimisticStores: Set<any>;
     _actions: Array<Generator<any, any, any> | AsyncGenerator<any, any, any>>;
     _queueStash: QueueStub;
@@ -78,19 +79,61 @@ export declare class GlobalQueue extends Queue {
     _pendingNode: Signal<any> | null;
     _pendingNodes: Signal<any>[];
     _optimisticNodes: OptimisticNode[];
+    _affectsNodes: OptimisticNode[];
     _optimisticStores: Set<any>;
     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 _releaseAffectsScope: ((node: OptimisticNode) => void) | null;
+    static _propagateAffects: ((node: OptimisticNode) => void) | null;
+    static _settleAffects: ((node: OptimisticNode) => void) | null;
     flush(): void;
     notify(node: Computed<any>, mask: number, flags: number, error?: any): boolean;
     initTransition(transition?: Transition | null): void;
 }
 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
+ * graphs that never use the feature pay one integer compare.
+ */
+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.
+ *
+ * @internal
+ */
+export declare function releaseAffectsMark(node: OptimisticNode): 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

@@ -48,6 +48,21 @@ export interface RawSignal<T> {
     _pendingSignal?: Signal<boolean>;
     _latestValueComputed?: Computed<T>;
     _parentSource?: Signal<any> | Computed<any>;
+    /**
+     * Live `affects()` marks on this node (refcount). Non-zero is declared
+     * motion: the node reads pending regardless of graph state, until every
+     * declaring transaction settles/reverts and releases its mark.
+     */
+    _affectsCount?: number;
+    /**
+     * The mark's identity on the pending-source rails (lazy, see
+     * `getAffectsSentinel`). Downstream subscribers hold it in
+     * `_pendingSources` exactly like a real in-flight source, but with its own
+     * identity so a landing or quiet re-ask on the node itself can't clear it.
+     */
+    _affectsSentinel?: Computed<any>;
+    /** Set only on sentinels: the marked node this sentinel stands for. */
+    _affectsFor?: Signal<any> | Computed<any>;
 }
 export interface FirewallSignal<T> extends RawSignal<T> {
     _firewall: Computed<any>;
@@ -90,12 +105,14 @@ export interface Computed<T> extends RawSignal<T>, Owner {
     _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).
+     * Question-scoped pending classification of the node's CURRENT pending
+     * window: `true` means the in-flight recompute is a re-ask of the same
+     * question (refresh/poll/confirm — no tracked input changed value), so the
+     * shown answer still answers the question and the node reads NOT pending.
+     * Set by `recompute` from `REACTIVE_REASK`, cleared on landing
+     * (`clearStatus`). Meaningless while not STATUS_PENDING.
      */
-    _optimisticMask?: number;
+    _reask: boolean;
 }
 export interface Root extends Owner {
     _root: true;

package/dist/types/index.d.ts

@@ -4,6 +4,7 @@ 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";
 export { createSignal, createMemo, createEffect, createRenderEffect, createTrackedEffect, createReaction, createOptimistic, resolve, onSettled, onCleanup } from "./signals.js";
 export type { Accessor, SourceAccessor, Setter, Signal, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, SignalOptions, MemoOptions, NoInfer } from "./signals.js";
+export { affects } from "./affects.js";
 export { mapArray, repeat, type Maybe } from "./map.js";
 export * from "./store/index.js";
 export { createLoadingBoundary, createErrorBoundary, createRevealOrder, flatten, type RevealOrder } from "./boundaries.js";

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

@@ -40,8 +40,8 @@ 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", STORE_MASKED = "m";
+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 type StoreNode = {
     [$PROXY]: any;
     [STORE_VALUE]: Record<PropertyKey, any>;
@@ -54,8 +54,6 @@ 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 {
@@ -83,20 +81,40 @@ export declare function getOverlayLayer(target: StoreNode, property: PropertyKey
  * override, else held pending value, else committed value.
  */
 export declare function visibleNodeValue(node: DataNode): any;
+/**
+ * Witness live mark coverage of a record into the active isPending() probe.
+ * Tracked reads don't need this — they go through real signal nodes, which
+ * carry marks directly (declaration walk or birth inheritance). This covers
+ * UNTRACKED probes reading through records whose nodes never materialized
+ * (no observer ever subscribed, so no node exists to carry the mark).
+ * Callers guard on `pendingCheckActive`, so plain reads never pay for this.
+ *
+ * @internal
+ */
+export declare function witnessAffectsMark(target: StoreNode): 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
+ * carrier); without, the record's $AFFECTS carrier plus every LIVE node in
+ * its subtree (the edges existing readers subscribed through), with the
+ * subtree's identities snapshotted into the mark's scope so nodes created
+ * during the window — and untracked probes over captured proxies — resolve
+ * against it (#2882).
+ *
+ * @internal
+ */
+export declare function getStoreAffectsNodes(target: StoreNode, key?: PropertyKey): DataNode[];
 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.
+ * The write overlay a walk must read through: optimistic writes shadow
+ * regular pending writes, the same resolution order as every proxy trap and
+ * `reconcile` (#2850). Merging allocates only in the rare both-present case
+ * (a derived optimistic store with an in-flight projection commit).
  */
-export declare function maskStoreTarget(target: StoreNode, on: boolean): 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 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

@@ -0,0 +1,47 @@
+import { type Store } from "./store/store.cjs";
+import type { Accessor } from "./signals.cjs";
+/**
+ * Declares that in-flight work will change the targeted data: the named
+ * slot(s) — and everything DERIVED from them — read as pending
+ * (`isPending` → `true`) from the declaration until the surrounding
+ * transaction settles or reverts. Marks ride the same status rails as real
+ * in-flight async, so pendingness flows through memos and effects like any
+ * other pending source, while the marked values themselves stay readable
+ * (a mark is a promise of change, not an absence of value). This is the
+ * declaration verb of the pending model — additive only. A mark can turn
+ * pending ON for data the graph can't see changing yet; nothing can turn
+ * pending OFF while a real change is in flight — a quiet `refresh()`
+ * re-ask under a mark still reads pending (declaring the reload is what
+ * makes it a real question).
+ *
+ * Targets:
+ * - `affects(store)` — a store proxy (any record, root or nested): every
+ *   record reachable from it at declaration time reads pending, including
+ *   through captured child proxies (e.g. `<For>` rows). Siblings are
+ *   untouched; records added after the declaration are not covered.
+ * - `affects(record, key)` — exactly the named slot of the record. One key
+ *   per call (keys do NOT form a path — target the owning record directly).
+ * - `affects(accessor)` — a source accessor (signal or memo): the source
+ *   reads pending.
+ *
+ * Typically called at the top of an `action` alongside optimistic writes —
+ * both are up-front declarations about the same mutation. Outside any
+ * transaction the mark is released at the end of the current flush.
+ *
+ * @example
+ * ```ts
+ * const send = action(function* (text: string) {
+ *   setState(s => { s.messages.push({ text, status: "sending" }); });
+ *   affects(state.messages.at(-1)!, "status"); // this slot pends until settle
+ *   yield api.send(text);
+ * });
+ *
+ * const reload = action(function* () {
+ *   affects(thing);      // the whole store pends…
+ *   refresh(thing);      // …over this otherwise-quiet re-ask
+ *   yield api.done();
+ * });
+ * ```
+ */
+export declare function affects(target: Accessor<unknown> | Store<object>): void;
+export declare function affects<T extends object>(target: Store<T>, key: keyof T): void;

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

@@ -24,7 +24,7 @@ export declare class RevealController {
     /**
      * "Minimally ready" = this group has something visible to show under its own policy.
      * Used by an enclosing `together` group to decide when it can release.
-     * - `together`: fully ready (atomic).
+     * - `together`: every direct slot is minimally ready.
      * - `sequential`: the first owned slot is minimally ready (frontier can advance).
      * - `natural`: any owned slot is minimally ready.
      */
@@ -128,7 +128,7 @@ export declare function createErrorBoundary<T, U>(fn: () => T, fallback: (error:
  *   own minimal signal).
  * - `together` — every direct slot is minimally ready.
  * - `natural` — any direct slot has visible content (leaves on resolve; nested
- *   composites when fully ready, since natural treats composites as atomic).
+ *   composites via their own minimal signal).
  *
  * @example
  * ```ts

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

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

@@ -10,6 +10,14 @@ export declare const REACTIVE_OPTIMISTIC_DIRTY: number;
 export declare const REACTIVE_SNAPSHOT_STALE: number;
 export declare const REACTIVE_LAZY: number;
 export declare const REACTIVE_MANUAL_WRITE: number;
+/**
+ * The pending recompute is a re-ask of the same question: `refresh()` dirtied
+ * the node while no tracked input changed value. Cleared whenever a real
+ * value-change notification arrives (`insertSubs`), and consumed by
+ * `recompute` into the node's `_reask` classification — a quiet (re-ask)
+ * pending window does not read as pending (question-scoped pending model).
+ */
+export declare const REACTIVE_REASK: number;
 export declare const CONFIG_OWNED_WRITE: number;
 export declare const CONFIG_NO_SNAPSHOT: number;
 export declare const CONFIG_TRANSPARENT: number;

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

@@ -97,6 +97,15 @@ 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

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

@@ -6,7 +6,7 @@ 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" | "ACTION_CALLED_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 DiagnosticCode = "STRICT_READ_UNTRACKED" | "PENDING_ASYNC_UNTRACKED_READ" | "PENDING_ASYNC_FORBIDDEN_SCOPE" | "REACTIVE_WRITE_IN_OWNED_SCOPE" | "ACTION_CALLED_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" | "INVALID_AFFECTS_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;

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, updatePendingSignal, updateChildCompanions, refresh, staleValues, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots } from "./core.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 { 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";

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

@@ -26,6 +26,7 @@ export declare const InvariantHooks: {
 export declare function devTrackHeldPending(node: AnyNode): void;
 export declare function devTrackCompanionOwner(node: AnyNode): void;
 export declare function devTrackOptimistic(node: AnyNode): void;
+export declare function devTrackAffects(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.
@@ -33,6 +34,15 @@ export declare function devTrackOptimistic(node: AnyNode): void;
 export declare function beginAsyncReporterWrites(): void;
 export declare function endAsyncReporterWrites(): void;
 export declare function createAsyncReporters(): Map<Computed<any>, Set<Computed<any>>>;
+/**
+ * INV-2: a node with an *active* override must be registered for reversion in
+ * the queue's or a transition's `_optimisticNodes`. An unregistered active
+ * override would survive transition completion forever. Runs at the end of
+ * every flush (not just quiescence — the invariant holds mid-transition).
+ * (There is no revert-target requirement: authoritative values commit
+ * silently into `_value` under the override mask — A17 — so reverting is
+ * just dropping the override.)
+ */
 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;