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

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

@@ -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-cjs/core/owner.d.cts

@@ -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-cjs/core/scheduler.d.cts

@@ -1,5 +1,5 @@
 import { type Heap } from "./heap.cjs";
-import { activeLanes, assignOrMergeLane, findLane } from "./lanes.cjs";
+import { activeLanes, assignOrMergeLane, findLane, type OptimisticLane } from "./lanes.cjs";
 import type { Computed, Signal } from "./types.cjs";
 export { activeLanes, assignOrMergeLane, findLane };
 export { getOrCreateLane, hasActiveOverride, mergeLanes, resolveLane } from "./lanes.cjs";
@@ -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;
@@ -34,6 +33,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;
@@ -46,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 {
@@ -78,19 +78,67 @@ 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 _clearOptimisticStores: ((stores: Set<any>) => void) | null;
+    static _releaseAffectsScope: ((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;
 }
 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;
+/**
+ * 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 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-cjs/core/types.d.cts

@@ -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-cjs/core/verdict.d.cts

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

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

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

package/dist/types-cjs/store/projection.d.cts

@@ -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-cjs/store/store.d.cts

@@ -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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/signals",
-  "version": "2.0.0-beta.17",
+  "version": "2.0.0-beta.19",
   "description": "Solid's reactive primitives: signals, memos, effects, stores, and async-aware computations.",
   "author": "Ryan Carniato",
   "license": "MIT",
@@ -14,7 +14,9 @@
     "access": "public"
   },
   "main": "./dist/node.cjs",
-  "module": "./dist/prod.js",
+  "module": "./dist/prod/index.js",
+  "unpkg": "./dist/prod/index.js",
+  "jsdelivr": "./dist/prod/index.js",
   "types": "./dist/types/index.d.ts",
   "type": "module",
   "sideEffects": false,
@@ -28,7 +30,7 @@
         "types": "./dist/types/index.d.ts",
         "test": "./dist/dev.js",
         "development": "./dist/dev.js",
-        "default": "./dist/prod.js"
+        "default": "./dist/prod/index.js"
       },
       "require": {
         "types": "./dist/types-cjs/index.d.cts",
@@ -40,12 +42,12 @@
   "devDependencies": {
     "@ianvs/prettier-plugin-sort-imports": "^4.1.1",
     "@rollup/plugin-replace": "^6.0.3",
-    "@rollup/plugin-terser": "^0.4.4",
     "@rollup/plugin-typescript": "^12.3.0",
     "@types/node": "^25.0.8",
     "rimraf": "^5.0.1",
     "rollup": "^4.53.4",
     "rollup-plugin-prettier": "^4.1.2",
+    "terser": "^5.49.0",
     "tslib": "^2.8.1",
     "typescript": "^6.0.3",
     "vite": "^7.0.0",
@@ -53,8 +55,8 @@
   },
   "scripts": {
     "build": "npm-run-all -nl build:* && pnpm types",
-    "build:clean": "rimraf dist/dev.js dist/prod.js dist/node.cjs",
-    "build:js": "rollup -c",
+    "build:clean": "rimraf dist/dev dist/prod dist/node dist/dev.js dist/prod.js dist/node.cjs",
+    "build:js": "rollup -c && node ./scripts/mangle-props.mjs dist/prod dist/node.cjs && node ./scripts/check-pure.mjs dist/prod",
     "types": "tsc -p tsconfig.build.json && node ../../scripts/sync-dual-types.mjs ./dist/types ./dist/types-cjs",
     "test": "vitest run",
     "test:watch": "vitest watch tests",