@solidjs/signals 2.0.0-rc.0 → 2.0.0-rc.2

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

@@ -9,7 +9,6 @@ export declare let clock: number;
 export declare let activeTransition: Transition | null;
 export declare let projectionWriteActive: boolean;
 export declare let _hitUnhandledAsync: boolean;
-export declare function registerTransientStoreNode(node: Signal<any>): void;
 export declare function resetUnhandledAsync(): void;
 /**
  * Toggles the dev-mode "must be inside a `<Loading>` boundary" enforcement
@@ -22,6 +21,7 @@ export declare function resetUnhandledAsync(): void;
 export declare function enforceLoadingBoundary(enabled: boolean): void;
 export declare function setProjectionWriteActive(value: boolean): void;
 export declare function setTrackedQueueCallback(value: boolean): void;
+export declare function setEffectCallback(value: boolean): void;
 export type QueueCallback = (type: number) => void;
 type QueueStub = {
     _queues: [QueueCallback[], QueueCallback[]];
@@ -97,6 +97,7 @@ export declare class GlobalQueue extends Queue {
     static _applyReask: ((el: Computed<any>, hadReask: boolean) => boolean) | null;
     static _repollVerdicts: ((el: Computed<any>, snap?: boolean) => void) | null;
     static _witnessAffects: ((node: OptimisticNode) => void) | null;
+    static _wakeSuppressedProbes: ((transition: Transition) => void) | null;
     static _optimisticWrite: (<T>(el: Signal<T> | Computed<T>, v: T | ((prev: T) => T)) => T) | null;
     static _resolveOptimistic: ((nodes: OptimisticNode[]) => void) | null;
     static _transitionBlocked: ((transition: Transition) => boolean) | null;
@@ -105,7 +106,7 @@ export declare class GlobalQueue extends Queue {
     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 _recomputeLane: ((el: Computed<any>, own: boolean) => OptimisticLane | null | false) | null;
     static _laneAsyncPending: ((el: Computed<any>) => void) | null;
     static _laneAsyncSettled: ((el: Computed<any>) => void) | null;
     static _trackOptimisticStore: ((store: any) => void) | null;
@@ -114,8 +115,17 @@ export declare class GlobalQueue extends Queue {
     initTransition(transition?: Transition | null): void;
 }
 export declare function queuePendingNode(node: Signal<any>): void;
+export declare let reaskArmed: boolean;
+/** §12d: bumped by every recompute and every new subscriber edge. A node's
+ * staged-rewrite skip is sound only while NOTHING recomputed or linked since
+ * its last notify — a mid-batch pull can clean a marked subscriber, and a
+ * skipped re-write would leave it stale. */
+export declare let notifyEpoch: number;
+export declare function bumpNotifyEpoch(): void;
 export declare function armReaskClear(): void;
 export declare function insertSubs(node: Signal<any> | Computed<any>, optimistic?: boolean): void;
+export declare let storeCommitHook: (() => void) | null;
+export declare function setStoreCommitHook(fn: () => void): void;
 export declare function finalizePureQueue(completingTransition?: Transition | null, incomplete?: boolean): void;
 /**
  * Count of live `affects()` registrations across the system (including

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

@@ -41,19 +41,19 @@ export interface NodeOptions<T> {
      */
     loadingValue?: T;
 }
-export interface RawSignal<T> {
-    _subs: Link | null;
-    _subsTail: Link | null;
-    _value: T;
-    _snapshotValue?: any;
-    _name?: string;
-    _equals: false | ((a: T, b: T) => boolean);
-    _config: number;
-    _unobserved?: () => void;
-    _time: number;
-    _transition: Transition | null;
-    _pendingValue: T | typeof NOT_PENDING;
-    _overrideValue?: T | typeof NOT_PENDING;
+/**
+ * Cold node extension (stage-3 §12): optional machinery that most nodes
+ * never touch lives one hop away so the CORE node literal stays under V8's
+ * in-object property boundary (~39 fields measured: past it, every literal
+ * allocation spills to an out-of-object backing store and creation cost
+ * roughly quadruples — the create0to1 cliff). Allocated lazily by `ext()`
+ * on first installer write; ONE shape shared by signals and computeds so
+ * `_x` access stays monomorphic. Presence bits on `_config`
+ * (CONFIG_OPTIMISTIC / HAS_COMPANIONS / HAS_LANE / HAS_SNAPSHOT) remain the
+ * hot-path gates — a bit says "consult _x", never the reverse.
+ */
+export interface NodeExtension {
+    _overrideValue: unknown | 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
@@ -62,21 +62,66 @@ export interface RawSignal<T> {
      * 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>;
-    _parentSource?: Signal<any> | Computed<any>;
+    _overrideOwner: Transition | null | undefined;
+    _optimisticLane: OptimisticLane | undefined;
+    _pendingSignal: Signal<boolean> | undefined;
+    _latestValueComputed: Computed<any> | undefined;
+    _parentSource: Signal<any> | Computed<any> | undefined;
     /**
      * Live `affects()` marks on this node (refcount). Non-zero is declared
-     * motion: the node — and, via the verdict layer's dep-graph coverage walk,
-     * everything derived from it — reads pending regardless of graph state,
-     * until every declaring transaction settles/reverts and releases its mark.
-     * This count is the mark's ONLY graph state: the dedicated channel stores
-     * nothing downstream and never touches status flags, errors, or pending
-     * sources.
+     * motion — see affects(); the count is the mark's only graph state.
      */
-    _affectsCount?: number;
+    _affectsCount: number;
+    _inFlight: PromiseLike<any> | AsyncIterable<any> | null;
+    _error: unknown;
+    _blocked: boolean | undefined;
+    _pendingSources: Set<Computed<any>> | undefined;
+    _notifyStatus: ((status?: number, error?: any) => void) | undefined;
+    /** Question-scoped re-ask classification of the current pending window
+     * (see the former Computed._x?._reask doc): set by recompute from
+     * REACTIVE_REASK, cleared on landing; meaningless while not pending. */
+    _reask: boolean;
+    _child: FirewallSignal<any> | null;
+    _unobserved: (() => void) | undefined;
+    _snapshotValue: any;
+    /** Zombie staging (staged disposal): a recompute of an owner that HAS
+     * children/disposal parks them here until the flush commits (or a
+     * transition reverts). Childless nodes — the common case — never write
+     * these. */
+    _pendingDisposal: Disposable | Disposable[] | null;
+    _pendingFirstChild: Owner | null;
+    /** #3038: the firewall children that actually carry isPending()/latest()
+     * companions. The post-recompute companion snap iterates THIS set —
+     * O(companions asked for) — never the full `_child` chain (one entry per
+     * materialized leaf). Populated at companion creation; entries live as
+     * long as their companions (which are permanent once created). */
+    _companionChildren: Set<FirewallSignal<any>> | undefined;
+}
+export interface RawSignal<T> {
+    _subs: Link | null;
+    _subsTail: Link | null;
+    /**
+     * DEV-only live subscriber count. Maintained by `link`/`unlinkSubs` for
+     * graph-size diagnostics; undefined in production.
+     */
+    _subCount?: number;
+    _value: T;
+    _name?: string;
+    _equals: false | ((a: T, b: T) => boolean);
+    _config: number;
+    _time: number;
+    /** IN CORE, not the extension (stage-3 §12c): consulted on EVERY write
+     * (setSignal's transition-init check) and on recompute scheduling — the
+     * per-write extension chase measurably taxed propagation chains. */
+    _transition: Transition | null;
+    /** Notify-epoch stamp of the last subscriber walk (§12d). A re-write to an
+     * already-staged node whose stamp still equals the global epoch skips the
+     * whole walk — marking is idempotent, and the epoch bumps on every
+     * recompute and new subscriber edge (either can invalidate the skip). */
+    _notifiedAt: number;
+    _pendingValue: T | typeof NOT_PENDING;
+    /** Cold extension — see NodeExtension. */
+    _x: NodeExtension | null;
 }
 export interface FirewallSignal<T> extends RawSignal<T> {
     _firewall: Computed<any>;
@@ -97,35 +142,33 @@ export interface Owner {
     _firstChild: Owner | null;
     _nextSibling: Owner | null;
     _prevSibling: Owner | null;
-    _pendingDisposal: Disposable | Disposable[] | null;
-    _pendingFirstChild: Owner | null;
+    /** Cold extension — see NodeExtension (owners use the zombie-pair slots). */
+    _x: NodeExtension | null;
 }
 export interface Computed<T> extends RawSignal<T>, Owner {
     _deps: Link | null;
     _depsTail: Link | null;
+    /**
+     * DEV-only live source count. Maintained by `link`/`unlinkSubs` for
+     * graph-size diagnostics; undefined in production.
+     */
+    _depCount?: number;
     /** Recompute-pass counter; bumped when dep revalidation starts. */
     _depGen: number;
     _flags: number;
-    _blocked?: boolean;
-    _pendingSources?: Set<Computed<any>>;
-    _error?: unknown;
     _statusFlags: number;
     _height: number;
     _nextHeap: Computed<any> | undefined;
     _prevHeap: Computed<any>;
     _fn: (prev?: T) => T;
-    _inFlight: PromiseLike<T> | AsyncIterable<T> | null;
-    _child: FirewallSignal<any> | null;
-    _notifyStatus?: (status?: number, error?: any) => void;
     /**
-     * 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.
+     * Clock tick at which REACTIVE_MANUAL_WRITE was last applied
+     * (`suppressComputedRecompute`). Lets `refresh()` distinguish a same-tick
+     * manual write (which wins over the refresh, #2692) from a mask carried
+     * across ticks by a transaction (which an explicit refresh lifts, #3026).
+     * Only meaningful while REACTIVE_MANUAL_WRITE is set.
      */
-    _reask: boolean;
+    _manualWriteTime?: number;
     /**
      * True while a `loadingValue` node's first real answer hasn't landed: the
      * node was born committed (commit #0 = the loading value) and `handleAsync`
@@ -137,7 +180,8 @@ export interface Computed<T> extends RawSignal<T>, Owner {
      * return, sync-resolved promise, first iterator yield, async settle); a
      * real error leaves it set — errors answer reads but don't enter the value
      * lineage, so a retry serves the loading value again. Once cleared, normal
-     * pending/refetch semantics apply forever.
+     * pending/refetch semantics apply forever. (Stays in CORE: written
+     * unconditionally by recompute and every commit.)
      */
     _loading: boolean;
 }

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

@@ -414,6 +414,12 @@ export declare function createRenderEffect<T>(compute: ComputeFunction<undefined
  * may run multiple times for a single change or show tearing (reading inconsistent
  * state). Use only when dynamic subscription patterns require same-scope tracking.
  *
+ * The callback runs during the flush itself: writes made inside it are queued
+ * into the same flush's continuation and are never visible to the callback's
+ * own reads (reads return settled values, as in every effect-phase scope), and
+ * `flush()` cannot be called from inside it (dev throws; production is a
+ * no-op) — defer with `queueMicrotask(() => flush())` if needed.
+ *
  * ```typescript
  * createTrackedEffect(compute, options?: { name?: string });
  * ```
@@ -542,6 +548,19 @@ export declare function createOptimistic<T>(fn: ComputeFunction<T>, options?: Si
  * Reactive reads inside the callback are *not* tracked — to react to
  * subsequent settles, register a new `onSettled` each time.
  *
+ * The callback runs during the settle flush itself, which gives it the same
+ * write semantics as every other effect-phase scope (the effect half of
+ * `createEffect`, event handlers):
+ *
+ * - **Writes** are queued into the same flush's continuation — dependent memos
+ *   and effects update before the flush returns — but reads inside the
+ *   callback keep returning the settled (pre-write) values. A callback never
+ *   observes its own unsettled write. Functional setters still compose:
+ *   `set(v => v + 1)` twice increments twice.
+ * - **`flush()` cannot be called** from inside the callback — the flush is
+ *   already running (dev throws; production is a no-op). To force a drain
+ *   after this settle, defer it: `queueMicrotask(() => flush())`.
+ *
  * `onCleanup` is **not** allowed inside the callback — return a cleanup
  * function instead. The returned cleanup runs on owner disposal.
  *

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

@@ -1,9 +1,19 @@
 export type { Store, StoreReturn, ProjectionStoreReturn, StoreSetter, StoreNode, StoreOptions, ProjectionOptions, NotWrappable, SolidStore } from "./store.cjs";
 export type { Merge, Omit } from "./utils.cjs";
-export { isWrappable, createStore, $TRACK, $PROXY, $TARGET } from "./store.cjs";
-export { createProjection } from "./projection.cjs";
-export { createOptimisticStore } from "./optimistic.cjs";
-export { reconcile } from "./reconcile.cjs";
+export { isWrappable, $TRACK, $PROXY, $TARGET } from "./store.cjs";
+import type { NoFn, ProjectionOptions, Store, StoreOptions, StoreSetter } from "./store.cjs";
+import type { Refreshable } from "../core/index.cjs";
+export { createProjectionNext as createProjection } from "./next/projection.cjs";
+export { createOptimisticStoreNext as createOptimisticStore } from "./next/optimistic.cjs";
+/** Public createStore: plain form `(init, options?)` and derived writable
+ * form `(fn, seed, options?)`. */
+export declare function createStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>, options?: StoreOptions & {
+    shallow?: boolean;
+}): [get: Store<T>, set: StoreSetter<T>];
+export declare function createStore<T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Refreshable<Store<T>>, set: StoreSetter<T>];
+export declare function reconcile<T extends U, U>(value: T, key?: string | ((item: NonNullable<any>) => any) | null): (state: U) => T;
+export declare function snapshot<T>(value: T): T;
+export declare function deep<T>(value: T): T;
 export { storePath } from "./storePath.cjs";
 export type { PathSetter, Part, StorePathRange, ArrayFilterFn, CustomPartial } from "./storePath.cjs";
-export { snapshot, deep, merge, omit } from "./utils.cjs";
+export { merge, omit } from "./utils.cjs";

package/dist/types-cjs/store/next/optimistic.d.cts

@@ -0,0 +1,20 @@
+import { type NoFn, type ProjectionOptions, type Store, type StoreSetter } from "../store.cjs";
+import type { StoreNextFamily, StoreNextTarget } from "./target.cjs";
+export declare function createOptimisticStoreNext<T extends object = {}>(first: T | ((store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>), second?: NoFn<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Store<T>, set: StoreSetter<T>];
+/** Diff the draft against the current OPTIMISTIC VIEW (committed + active
+ * overrides — the same view the draft was seeded from) and emit engine writes
+ * for exactly the changed keys. Visible-view diffing keeps no-op writes from
+ * entangling lanes (RUL-10 / opt R38). */
+export declare function notifyOptimisticWrites(t: StoreNextTarget, pb: Record<PropertyKey, any>): void;
+/**
+ * Landing consumption (RUL-2): fresh authoritative data supersedes every
+ * tentative override in the family. Mirrors legacy clearProjectionOverride —
+ * drop the override, clear lane/ownership, notify subscribers whose visible
+ * value changes (reversion effects go to regular queues via the projection
+ * write posture the caller holds).
+ */
+export declare function consumeOverridesNext(fam: StoreNextFamily): void;
+/** Optimistic-view composition for snapshot/deep (O1: snapshot is the CURRENT
+ * view, lane values included; a fresh copy per call during pending windows —
+ * RUL-12). Returns `src` untouched when no override is active on `t`. */
+export declare function optimisticView(t: StoreNextTarget, src: Record<PropertyKey, any>): Record<PropertyKey, any>;

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

@@ -0,0 +1,8 @@
+import { type Computed, type Refreshable } from "../../core/index.cjs";
+import { type NoFn, type ProjectionOptions, type Store } from "../store.cjs";
+export declare function createProjectionNext<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>>;
+/** Derived writable store (legacy parity): a projection whose public setter
+ * masks the recompute for the tick (core R31 — the manual write wins over a
+ * same-flush dependency change). */
+export declare function createStoreDerivedNext<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>>, (f: (draft: T) => T | void) => void];
+export declare function runProjectionComputedNext<T extends object>(wrappedStore: Store<T>, fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, key: string | ((item: NonNullable<any>) => any) | null, wrapCommit?: (write: () => void) => void, onDraftWrite?: () => void): Computed<void | T>;

package/dist/types-cjs/store/next/reconcile.d.cts

@@ -0,0 +1,3 @@
+type KeyFn = (item: any) => any;
+export declare function reconcileNextState(value: any, state: any, key: string | KeyFn | null | undefined, replace?: boolean): void;
+export {};

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

@@ -0,0 +1,77 @@
+import type { Signal } from "../../core/types.cjs";
+import { type StoreNextFamily, type StoreNextTarget } from "./target.cjs";
+export declare function wrapNext<T extends Record<PropertyKey, any>>(value: T, parent?: StoreNextTarget | null, parentKey?: PropertyKey | null, fam?: StoreNextFamily | null): T;
+/** Unwrap our own proxies to their current backing; leave everything else. */
+export declare function unwrapValue(v: any): any;
+export declare function getNode(target: StoreNextTarget, key: PropertyKey, current: any): Signal<any>;
+export declare function getHasNode(target: StoreNextTarget, key: PropertyKey, present: boolean): Signal<boolean>;
+export declare function getKeySetNode(target: StoreNextTarget): Signal<number>;
+/** Deep-witness bump: any value/shape change on a record with a live deep()
+ * subscriber notifies it. One null check when unused. */
+export declare function bumpDeep(t: StoreNextTarget): void;
+/** Downgrade a prototype-overlay pending backing to the clone path: builds
+ * the real container (committed + overlay writes − deletes) that fold will
+ * SWAP in as the committed backing, exactly as if the draft had started on
+ * the clone path. Consumers that need a complete container (reconcile's
+ * diff walks, drafts escaping into other storage) call this. */
+export declare function materializePB(target: StoreNextTarget): void;
+/**
+ * Adoption (2026-08-16c): the incoming object becomes the committed backing
+ * IMMEDIATELY — reconcile is eagerly visible to every reader (shipped
+ * contract; only its notifications batch), unlike setter writes which stay
+ * pending until flush. Ownership resets (incoming is unowned/user data). Any
+ * staged draft clone folds into the diff and is discarded — next is the
+ * authoritative base (R21/R32).
+ */
+export declare function adoptPB(target: StoreNextTarget, incoming: Record<PropertyKey, any>, eager?: boolean): void;
+/** Same logical slot: both values resolve to one (re-pointed) child target —
+ * adoption preserved identity, so the slot did not change (R9). */
+export declare function targetsEqual(ov: any, nv: any): boolean;
+/**
+ * The fold diff walks SUBSCRIPTION KEYS ONLY (legacy parity: `for key in
+ * nodes`): nodes exist exactly where something tracked, so unobserved data
+ * costs nothing here regardless of object size. Accessor safety rides the
+ * sticky `t.a` flag — a node's key was necessarily read, so the get trap has
+ * already seen whether it is an accessor.
+ */
+/** One node's fold notification (shared by notifyFold's walk and the fused
+ * adoption walk): accessor-aware compare + equality/identity-gated setSignal. */
+export declare function notifyKeyDiff(node: Signal<any>, key: PropertyKey, old: Record<PropertyKey, any>, neu: Record<PropertyKey, any>, probe?: boolean): void;
+/** Accessor-flag probe for the fused walk's early-continue (accessor keys
+ * can never identity-skip: their VALUE is the descriptor's product). */
+export declare function hasAccessorFlag(node: Signal<any>): boolean;
+/** Fused-walk per-key notification with values already in hand: the caller
+ * fetched both sides and handled the identity skip; this applies the
+ * accessor branch (cached flag only — reconcile channel) or the plain
+ * equality/identity-gated write. */
+export declare function notifyKeyValue(node: Signal<any>, key: PropertyKey, ov: any, nv: any, old: Record<PropertyKey, any>, neu: Record<PropertyKey, any>): void;
+/** Presence + membership halves of a fold notification (shared tail). */
+export declare function notifyFoldTail(t: StoreNextTarget, old: Record<PropertyKey, any>, neu: Record<PropertyKey, any>): void;
+export declare function notifyFold(t: StoreNextTarget, old: Record<PropertyKey, any>, neu: Record<PropertyKey, any>): void;
+/** Authoritative-write wrapper exported for the optimistic module: sets the
+ * scheduler's projectionWriteActive through THIS module's binding (proven to
+ * share the instance core reads — cross-module live-binding writes from other
+ * store modules were observed not to propagate under the test transform). */
+export declare function runAuthoritative<T>(fn: () => T): T;
+/** Active optimistic override on an armed node (armed slot idles at
+ * NOT_PENDING; undefined = unarmed plain node). */
+export declare function hasActiveOverride(node: Signal<any>): boolean;
+export type SetStoreNextFunction<T> = (fn: (draft: T) => T | void) => void;
+/** Low-level setter primitive: opens write mode on a next proxy, runs `fn`,
+ * emits write-time notifications at outermost exit, applies returned
+ * replacements as adoptions. `guard=false` skips the owned-scope dev guard —
+ * projection recomputes legitimately write from inside their computed. */
+export declare function storeSetterNext<T>(proxy: T, fn: (draft: T) => T | void, guard?: boolean): void;
+export declare function createStoreNext<T extends Record<PropertyKey, any>>(init: T, shallow?: boolean): [T, SetStoreNextFunction<T>];
+/** Tracking deep snapshot (`deep()` for next targets): subscribes to the
+ * key-set and every property node at every reachable level, then returns the
+ * plain view. Shared references and cycles handled via the visited set. */
+export declare function deepNext<T>(value: T): T;
+/**
+ * Snapshot with per-object registration resolution (RUL-12 DAG ruling): every
+ * reachable wrappable resolves through its target's CURRENT backing, so
+ * privatized subtrees are seen through any parent path. Identity-preserving:
+ * a subtree with no substitutions below returns its own object (zero copy for
+ * settled, never-diverged graphs).
+ */
+export declare function snapshotNext<T>(value: T): T;

package/dist/types-cjs/store/next/target.d.cts

@@ -0,0 +1,117 @@
+/**
+ * Store rewrite — target & ownership (INTERNALS-STORE-STATE.md §1, §5b).
+ *
+ * The proxy wraps this internal target, never the raw (proxy-target
+ * indirection, decision 2026-08-16d). `b` is the single committed home; `pb`
+ * is the per-target pending backing (RUL-1's pending home): the CoW clone
+ * created at first draft write, mutated natively by the draft, folded into
+ * `b` at flush commit. Adoption (setter replacement / reconcile) parks an
+ * UNOWNED incoming object in `pb` — fold swaps it in and ownership resets.
+ *
+ * Creation budget (§5b): one minimal target + one proxy + one storeLookup
+ * entry per read-through object; zero layer slots; nodes, has-nodes, and the
+ * key-set node are lazy, materialized only by subscription.
+ */
+import type { Computed, Signal } from "../../core/types.cjs";
+/** Projection family (§7b): children wrap into the family's own map (writes
+ * land in the projection, never the source family), and every node created
+ * under the family carries the projection computed as its firewall. */
+export interface StoreNextFamily {
+    /** Optimistic family: nodes are born armed (`_overrideValue` slot) so every
+     * write rides the core optimistic engine — lanes, per-transaction ownership,
+     * reverts all core-native (§3, RUL-3). */
+    opt?: boolean;
+    /** Root proxy (registered with the scheduler's optimistic-store set for the
+     * transitionBlocked store-half, #2951). */
+    px?: any;
+    /** Targets currently carrying active node overrides (landing-consumption
+     * walk, RUL-2: visible landed truth replaces optimism). */
+    overlaid?: Set<any>;
+    map: WeakMap<object, StoreNextTarget>;
+    /** The projection computed — assigned after creation (accessor pattern). */
+    node: Computed<any> | null;
+    shallow?: boolean;
+}
+export interface StoreNextTarget {
+    /** Committed backing: source object (shared) or owned clone. */
+    v: Record<PropertyKey, any>;
+    /** Pending backing for the current flush (null when settled). */
+    pb: Record<PropertyKey, any> | null;
+    /** cached: committed backing is another store's proxy (§7b chained). */
+    ch: boolean;
+    /** live value-node count (deleted-key sweep fast-out in the fused walk). */
+    nc: number;
+    /** Lazy per-property subscription nodes (real core signals). */
+    n: Record<PropertyKey, Signal<any>> | null;
+    /** Lazy per-key presence nodes (`in` tracks presence, not value — R13). */
+    h: Record<PropertyKey, Signal<boolean>> | null;
+    /** Lazy key-set node: membership/iteration/$TRACK subscriptions (§6). */
+    k: Signal<number> | null;
+    /** Lazy deep-witness node: `deep()` subscribes ONE node per record instead
+     * of one per path; write paths bump it only when it exists. Separate from
+     * `k` so $TRACK/mapArray never rerun on leaf value changes (R9). */
+    dk: Signal<number> | null;
+    /** Parent target (path copying walks this at commit). */
+    u: StoreNextTarget | null;
+    /** Property key of this target in the parent's backing. */
+    pk: PropertyKey | null;
+    /** The proxy for this target (stable outward identity). */
+    px: any;
+    /** Sticky descendants flag (§6d). */
+    d: boolean;
+    /** Sticky accessors-seen flag: an own accessor property was observed on
+     * this target (first-read scan, defineProperty, or clone scan). Gates the
+     * fold diff's descriptor-safe path and the get trap's descriptor path. */
+    a: boolean;
+    /** Accessor scan performed (scan-once on first trap read; adopted data is
+     * not rescanned — legacy-parity behavior). */
+    sc: boolean;
+    /** Backing was swapped by adoption this batch (fold diff-notifies it). */
+    adopted: boolean;
+    /** Pending backing is a prototype-chain OVERLAY of the committed backing
+     * (`Object.create(v)` — own keys are this batch's writes, everything else
+     * reads through). O(written) per flush instead of O(container) clones
+     * (#3044); commit flattens own keys onto an owned committed backing in
+     * place. Only plain-data non-array non-family containers qualify;
+     * `materializePB` downgrades to the clone path when a consumer needs a
+     * real container (reconcile, draft escape). */
+    ovl: boolean;
+    /** Keys deleted in the overlay window (a prototype overlay cannot shadow
+     * a delete); null when none. */
+    del: Set<PropertyKey> | null;
+    /** Keys written through the traps since the last fold commit. Bounds the
+     * setter notify/hold-check to O(written) instead of O(subscribed nodes) —
+     * a record with thousands of per-key subscriptions (selection maps) would
+     * otherwise pay a full node scan on every write. null = no trap writes
+     * this batch (bulk paths fall back to the full scan); WK_ALL sentinel =
+     * bound unusable this batch (array length write implies index deletes). */
+    wk: Set<PropertyKey> | null;
+    /** Projection family, null for plain stores (§7b). */
+    fam: StoreNextFamily | null;
+    /** Shallow store root (values served raw). */
+    s: boolean;
+}
+/**
+ * Ownership (first cut, decision 2026-08-16d): one WeakSet of store-owned
+ * backings serving both the production identity-skip guard and the __TEST__
+ * no-mutation oracle.
+ */
+export declare const ownedRaw: WeakSet<object>;
+/** raw → target. The only raw-keyed lookup; boundary mechanism (O8). */
+export declare const storeNextLookup: WeakMap<object, StoreNextTarget>;
+/** __TEST__ oracle: every object ingested from a user (never mutate). */
+export declare const ingestedRaw: WeakSet<object> | null;
+export declare function devAssertNeverUserMutation(target: object): void;
+/** Injection table for optimistic-only store machinery (next/optimistic.ts).
+ * Every call site is gated on `fam?.opt`, and optimistic families can only
+ * be created by createOptimisticStore — whose install populates this — so
+ * the non-null assertions at the sites hold by construction. Keeping the
+ * implementations out of next/store.ts lets plain-store bundles tree-shake
+ * the optimistic channel entirely. */
+export interface OptStoreHooks {
+    notifyOptimisticWrites(t: any, pb: Record<PropertyKey, any>): void;
+    optimisticView(t: any, src: Record<PropertyKey, any>): Record<PropertyKey, any>;
+    applyTentative(t: any, incoming: any, keyFn: ((item: any) => any) | null): void;
+}
+export declare let optHooks: OptStoreHooks | null;
+export declare function setOptHooks(h: OptStoreHooks): void;