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

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

@@ -0,0 +1,143 @@
+import { hasActiveOverride, visibleOverride } from "../../core/core.js";
+import type { Computed, Signal } from "../../core/types.js";
+import { type StoreNextFamily, type StoreNextTarget } from "./target.js";
+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, accKnown?: -1 | 0 | 1): Signal<any>;
+/** Record a store proxy's declared name for attribution labels (observe tiers). */
+export declare function nameStore(proxy: any, name: string | undefined): void;
+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;
+/** Resolve the held committed view (#3074): answers the masked old backing
+ * while the hold is live, and lazily clears a hold whose transition has
+ * committed (transitions merge — resolve through currentTransition, same as
+ * foldHeld's node stamps). */
+export declare function heldMaskView(t: StoreNextTarget): Record<PropertyKey, any> | null;
+/**
+ * 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;
+/** Parked truth-staged pending backings (#3164 fold): a tentative draft that
+ * opens while a folded landing's backing is live moves the staged container
+ * here (see ensurePB); the tentative discard in notifyOptimisticWrites
+ * restores it in place of the usual null. */
+export declare const stagedTruthPB: WeakMap<StoreNextTarget, Record<PropertyKey, any>>;
+/** 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;
+export declare function arrayStructureChanged(old: any[], neu: any[]): boolean;
+export declare function membershipChanged(old: Record<PropertyKey, any>, neu: Record<PropertyKey, 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;
+export { hasActiveOverride, visibleOverride };
+/** The reading computation is until()'s authoritative-view predicate — same
+ * source of truth as core read()'s A17 carve-out (`context`, which persists
+ * under untrack). optimisticView()'s composition gate consults exactly this:
+ * write-side machinery (patch emission, tentative re-application) must keep
+ * composing even when it runs inside an authoritative-write bracket. */
+export declare function authoritativeRead(): boolean;
+/** Serve-side authoritative gate: until()'s predicate PLUS truth authors —
+ * the projection derive's draft (wrapDraft trap brackets, runAuthoritative;
+ * the same posture pair ensurePB classifies drafts by). A source computing
+ * the next truth must never read its callers' tentative overlays: a derive
+ * continuation's `store.push` computing its index from an action's
+ * optimistic row landed truth in the wrong slot and corrupted committed
+ * state (#3108). Trap-level overlay serves gate on this so values, length,
+ * membership, and keys leave the authoritative view together. */
+export declare function authoritativeServe(): boolean;
+/** The override a composed READER view (keys, descriptors, snapshot/deep,
+ * optimisticView) takes from an armed node whose override is active — the
+ * override itself, unless the node's own source superseded it (#3331,
+ * CONFIG_OVERRIDE_SUPERSEDED): then the reader-aware selection `serve`
+ * makes through nodeValue, so the composed view agrees with what `get`,
+ * `in` and `length` serve the same reader (a deriving pass: the staged
+ * truth; a lane pass or a context-free read: the override, A18). Composing
+ * the raw override left Object.keys / snapshot() / deep() one row behind the
+ * traps at a landing whose shape differed from the optimistic frame (F5
+ * parity cases). Draft and authoritative callers never reach here — the
+ * writer composes on hasActiveOverride, truth authors on the backing. */
+export declare function readerOverride(node: Signal<any>, committed: any): any;
+export type SetStoreNextFunction<T> = (fn: (draft: T) => T | void) => void;
+/** The derived store's setter (CS-R31): within a synchronous frame the manual
+ * write wins — the projection's recompute is masked for the tick. Across a
+ * hold the write is not a proposal: a leaf the fold staged under another
+ * transaction re-runs the fold under it, the write being the draft's prior
+ * state (#3612). Decided from the leaf notifications, so the mask lands
+ * after them (in the `finally`: a throwing setter's writes before the throw
+ * were notified, and are masked as before). */
+export declare function derivedStoreWrite<T>(node: Computed<unknown>, proxy: T, fn: (draft: T) => T | void): void;
+export declare function storeSetterNext<T>(proxy: T, fn: (draft: T) => T | void, guard?: boolean): void;
+export declare function createStoreNext<T extends Record<PropertyKey, any>>(initialValue: T, shallow?: boolean): [T, SetStoreNextFunction<T>];
+/** True when `proxy` is a SHALLOW store (children served verbatim, slots
+ * replaced by reference — #2932). The list driver uses this to choose the
+ * slot-patch channel (collected row bodies) over per-record registration. */
+export declare function storeIsShallow(proxy: any): boolean;
+/** True when `proxy` belongs to a projection/optimistic FAMILY. The list
+ * driver must DECLINE family arrays (external audit finding): family
+ * structural changes never emit row/slot ops (the setter channel is
+ * fam-gated; optimistic writes ride node overrides), and the proxy identity
+ * is stable so the each-watch cannot catch the change either — an engaged
+ * list would freeze on optimistic/projection structural updates. Record-
+ * level family patches are unaffected (they have their own emission). */
+export declare function storeHasFamily(proxy: any): boolean;
+/** True when `proxy` belongs to an OPTIMISTIC family specifically. The list
+ * driver declines these (audit finding, narrowed): optimistic user writes
+ * ride node-level overrides — they never enter the reconcile walk, so no
+ * row/slot ops are emitted and an engaged list would freeze on optimistic
+ * structural changes. PROJECTION (non-optimistic) families are drivable:
+ * their recomputes go through the reconcile walk, whose emissions are
+ * transition-stamped in the apply queue like any other (equivalence-matrix
+ * gated). Re-admitting optimistic families requires a lane-timed structural
+ * emission mirroring emitPatchOptimistic, plus revert resync. */
+export declare function storeHasOptimisticFamily(proxy: any): boolean;
+/** Tracking deep snapshot (`deep()` for next targets): subscribes to the
+ * key-set and deep-witness 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/store/next/target.d.ts

@@ -0,0 +1,196 @@
+/**
+ * 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.js";
+/** 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>;
+    /** Retaining transactions (#3164 fold ruling): every transaction that made
+     * an optimistic setter call on this family and may still be open. While
+     * any member is live, truth landings FOLD — they stage into the retaining
+     * transaction and reveal atomically at its settle, exactly like a signal
+     * landing under an active override. Dead members prune lazily at each
+     * landing (retainingTransition). */
+    rt?: Set<any>;
+    /** Flight-owned transaction (#3146): declared when a truth-flight
+     * registers (the ask's transaction — created by the flight's own pending
+     * throw when none was ambient, the causing write's when one was), renewed
+     * per settle event once the previous reveal committed. Bare optimistic
+     * writes and landings route into it BY DECLARATION; the transitionBlocked
+     * store-half checks it for ownership instead of reconstructing it from
+     * `_optimisticStores` membership. null = no flight declared one (sync
+     * derive, or a loading-window flight — the loading rail is
+     * transaction-invisible, #2933). */
+    ft?: any;
+    /** Normalized row-key fn (same resolution as the projection channels:
+     * `options.key`, "id" default, null = unkeyed). The staged-landing walk
+     * reads it: key-matched rows keep their proxy identity across a fold. */
+    key?: ((item: any) => any) | null;
+    map: WeakMap<object, StoreNextTarget>;
+    /** The projection computed — assigned after creation (accessor pattern). */
+    node: Computed<any> | null;
+    shallow?: boolean;
+    /** Derive run counter (proj R37): the run whose draft is live. A draft
+     * compares its own run against this — the next run's start supersedes it. */
+    run?: number;
+}
+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;
+    /** 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 = bound
+     * unusable (array length write). LOAD-BEARING SHAPE RULE: array proxy
+     * targets carry their fields as named properties on a real array, and V8
+     * normalizes an array to dictionary properties as the named count grows
+     * (empirically at counts ≡ 0 mod 3 from 18 up on V8 13.x) — every trap
+     * field read then becomes a hash lookup (~15% uibench, tree suites
+     * worst). Future write-side state MUST ride an extension object, not new
+     * named fields. */
+    wk: Set<PropertyKey> | 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 grade: 0 = not yet scanned (adoption resets — adopted data
+     * is not rescanned until the next draft), 1 = scanned, 2 = scanned and
+     * PLAIN DATA — `Object.prototype` with every own key an enumerable data
+     * property. Grade 2 unlocks the spread clone (cloneRaw), bare-assignment
+     * overlay writes and flatten (#3360); a non-plain defineProperty through
+     * the draft downgrades it to 1. */
+    sc: 0 | 1 | 2;
+    /** Own-key count: exact at scan, then bumped by set-trap writes of keys new
+     * to the container (never decremented — an estimate for the overlay/clone
+     * choice only, #3360). */
+    kc: number;
+    /** Adoption diff base, non-null when the backing was swapped by adoption
+     * this batch: the view the nodes were LAST TOLD — the pre-batch committed
+     * backing, or the draft's pending backing when a draft preceded the
+     * adoption (its setter-exit notifications already moved the nodes, #3296).
+     * The deferred fold diffs incoming against this, never against committed. */
+    ab: Record<PropertyKey, any> | null;
+    /** 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. Plain-data non-array containers qualify, including projection
+     * and derived-store families (#3352); optimistic families, chained
+     * backings, and accessor containers keep the descriptor clone.
+     * `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;
+    /** Projection family, null for plain stores (§7b). */
+    fam: StoreNextFamily | null;
+    /** Shallow store root (values served raw). */
+    s: boolean;
+    /** Held committed view (#3074/#3075): the pre-hold committed backing,
+     * served to committed-visibility readers while `ht` is live. Adoption is
+     * eager by contract, but a projection recompute deriving from uncommitted
+     * inputs (a transition-held source, or a latest()-pull ahead of the flush)
+     * swaps the backing SPECULATIVELY — the old view must stay servable until
+     * the hold resolves. */
+    hv: Record<PropertyKey, any> | null;
+    /** The holder for `hv`: a live transition (cleared lazily when it is done)
+     * or the PLAIN_HOLD sentinel (a latest()-pull staging — cleared by the
+     * fold commit). null = no hold. */
+    ht: any;
+}
+/**
+ * Ownership stamp (#3360): every backing the store ALLOCATES (CoW clones,
+ * privatized committed backings) carries its owning target under this
+ * enumerable symbol. One property write replaces the two weak-collection
+ * registrations (ownership set + raw→target map) a fresh object used to pay
+ * per draft — V8's identity-hash + ephemeron cost dominated the one-key
+ * write floor. Enumerable so a spread copy (the plain-data clone path) stays
+ * on the fast path and carries the stamp along.
+ *
+ * Owned backings are never user-reachable (`snapshot` copies them, the traps
+ * hide the key), so every raw key walk in the store must skip `$OWNER`, and
+ * ownership is answered by `isOwned` — a user object never carries it.
+ * Overlay drafts (`Object.create(v)` over an owned `v`) inherit the stamp.
+ */
+export declare const $OWNER: unique symbol;
+/** raw → target for UNOWNED backings (user-ingested, adopted); owned
+ * backings resolve through their `$OWNER` stamp. Boundary mechanism (O8). */
+export declare const storeNextLookup: WeakMap<object, StoreNextTarget>;
+/** A backing the store allocated and may mutate in place. */
+export declare function isOwned(raw: object): boolean;
+/** raw → target within a family (`null` = plain stores / the global map).
+ * The stamp answers for backings owned by a target OF THAT FAMILY; anything
+ * else (user objects, adoptees, another family's backings the family
+ * re-registered for its own wrapper) resolves through the family's map. */
+export declare function lookupTarget(raw: object, fam: StoreNextFamily | null): StoreNextTarget | undefined;
+/** __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>, draft?: boolean): Record<PropertyKey, any>;
+    applyTentative(t: any, incoming: any, keyFn: ((item: any) => any) | null): void;
+    /** #3164 fold: does this live transaction still retain optimism (armed
+     * nodes or tracked stores)? Backs the held-truth masks in next/store.ts so
+     * plain-store bundles don't carry the transition-optimism probe. */
+    retainsOptimism(t: any): boolean;
+}
+export declare let optHooks: OptStoreHooks | null;
+export declare function setOptHooks(h: OptStoreHooks): void;
+/** Sticky descendants flag walk (§6d): reconcile's keyed pruning descends
+ * only where subscriptions exist at/below. Nodes AND patches count. */
+export declare function markDescendants(target: StoreNextTarget): void;

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

@@ -1,7 +1,7 @@
-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>;
+import { type Signal } from "../core/index.js";
+import type { Refreshable } from "../core/index.js";
+/** A reactive view of a store's value. Update it through the paired `StoreSetter`. */
+export type Store<T> = T;
 /**
  * A store setter. The callback receives a writable **draft** of the store.
  *
@@ -14,25 +14,34 @@ export type Store<T> = Readonly<T>;
  *
  * The setter does **not** perform keyed reconciliation. If you need surviving
  * items to keep their store identity across full-array replacement, use the
- * projection form — `createStore(fn, seed, { key })` or `createProjection` —
- * whose derive function reconciles its return by `options.key`.
+ * projection form — `createStore(fn, seed, { key })` or
+ * `createProjection(fn, seed, { key })` — whose derive function reconciles
+ * its return by `options.key`.
  */
 export type StoreSetter<T> = (fn: (state: T) => T | void) => void;
-/** Tuple returned by the plain `createStore(initialValue)` form. */
+/** Tuple returned by the plain `createStore(initialValue, options?)` form. */
 export type StoreReturn<T> = [get: Store<T>, set: StoreSetter<T>];
 /** Tuple returned by the derived `createStore(fn, seed, options?)` form. */
 export type ProjectionStoreReturn<T> = [get: Refreshable<Store<T>>, set: StoreSetter<T>];
-/** Base options for store primitives. */
+/** Options shared by all store primitives. */
 export interface StoreOptions {
-    /** Debug name (dev mode only) */
+    /**
+     * Debug name (dev and observe builds). Property nodes are labelled
+     * `<name>.<key>` in attribution output (`todos.title`); a derived store's
+     * projection node carries the name itself.
+     */
     name?: string;
+    /** Single-layer store: root keys reactive, values raw records replaced by reference */
+    shallow?: boolean;
 }
-/** Options for derived/projected stores created with `createStore(fn)`, `createProjection`, or `createOptimisticStore(fn)`. */
+/**
+ * Options for derived/projected stores created with
+ * `createStore(fn, seed, options?)`, `createProjection(fn, seed, options?)`,
+ * or `createOptimisticStore(fn, seed, options?)`.
+ */
 export interface ProjectionOptions extends StoreOptions {
     /** Key property name or function for reconciliation identity; `null` merges positionally */
     key?: string | ((item: NonNullable<any>) => any) | null;
-    /** Single-layer store: root keys reactive, values raw records replaced by reference */
-    shallow?: boolean;
     /**
      * Treat the seed as commit #0: the store is born committed with the seed's
      * contents, shown until the derive's first real answer lands. While that
@@ -57,22 +66,15 @@ 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", STORE_OPTIMISTIC_OWNERS = "t", STORE_PARENT = "u", STORE_DESC = "d", STORE_SHALLOW = "s";
+export declare const $TRACK: unique symbol, $TARGET: unique symbol, $PROXY: unique symbol, $RECORD: unique symbol, $DELETED: unique symbol, $AFFECTS: unique symbol;
+export declare const STORE_VALUE = "v", STORE_NODE = "n", STORE_HAS = "h", STORE_PARENT = "u", STORE_DESC = "d", STORE_SHALLOW = "s";
+/** Structural view of a store target as shared machinery sees it (the real
+ * shape is `StoreNextTarget` in ./next/target.ts). */
 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;
-    [STORE_WRAP]?: (value: any, target?: StoreNode) => any;
-    [STORE_LOOKUP]?: WeakMap<any, any>;
-    [STORE_FIREWALL]?: Computed<any>;
-    [STORE_OPTIMISTIC]?: boolean;
-    [STORE_SNAPSHOT_PROPS]?: Record<PropertyKey, any>;
     [STORE_PARENT]?: StoreNode;
     [STORE_SHALLOW]?: boolean;
     [STORE_DESC]?: boolean;
@@ -82,10 +84,6 @@ export declare namespace SolidStore {
     }
 }
 export type NotWrappable = string | number | bigint | symbol | boolean | Function | null | undefined | SolidStore.Unwrappable[keyof SolidStore.Unwrappable];
-export declare function createStoreProxy<T extends object>(value: T, traps?: ProxyHandler<StoreNode>, extend?: (target: StoreNode) => void): any;
-export declare const storeLookup: WeakMap<WeakKey, any>;
-export declare const symbolKeyedRecords: WeakSet<object>;
-export declare function lookupTarget(value: any, lookup?: WeakMap<any, any>): StoreNode | undefined;
 /**
  * Marks a value as raw: no store will ever wrap it — every store presents it
  * as-is, tracked by reference at whatever slot holds it and updated by
@@ -96,25 +94,33 @@ export declare function lookupTarget(value: any, lookup?: WeakMap<any, any>): St
 export declare let rawValuesUsed: boolean;
 export declare function isRawValue(value: any): boolean;
 export declare function markRaw<T>(value: T): T;
+export declare function markRawOne(v: any): void;
 export declare function markRawIngest(container: any): void;
-export declare function wrap<T extends Record<PropertyKey, any>>(value: T, target?: StoreNode): T;
-export declare function wrapShallow<T extends Record<PropertyKey, any>>(value: T): T;
 export declare function isWrappable<T>(obj: T | NotWrappable): obj is T;
 export declare function setWriteOverride(value: boolean): void;
+export declare function getWriteOverride(): boolean;
 export declare function ownEnumerableKeys(o: object): (string | symbol)[];
 /**
- * Single chokepoint for the store's layered value resolution: returns the
- * override layer (optimistic first, then regular) that shadows `property`, or
- * `undefined` when the base `STORE_VALUE` is authoritative. Every trap must
- * resolve through this — hand-inlining the layer order is how the optimistic
- * layer gets missed (#2850).
- */
-export declare function getOverlayLayer(target: StoreNode, property: PropertyKey): Record<PropertyKey, any> | undefined;
-/**
- * The value a store leaf's backing signal currently shows to readers: active
- * override, else held pending value, else committed value.
+ * Scope inheritance for late-created nodes: every live mark whose identity
+ * scope contains the owning record's raw — and, for keyed marks, whose key
+ * is this property — gets counted on the new node. Inherited marks live
+ * exactly as long as the scope's carrier — the release hook below drops
+ * them with the entry.
  */
-export declare function visibleNodeValue(node: DataNode): any;
+export declare function inheritAffectsMarks(node: DataNode, raw: object, property: PropertyKey): void;
+/** Next-store node factory for affects carriers/slots: injected by the
+ * rewrite module (next targets alias the legacy field names, so everything
+ * here EXCEPT node creation works on them structurally). */
+export declare let nextAffectsNodeResolver: ((target: any, key: PropertyKey) => DataNode) | null;
+export declare function setNextAffectsNodeResolver(fn: (target: any, key: PropertyKey) => DataNode): void;
+/** Next-store optimistic view for the declaration walk (optimistic rows
+ * pushed before the declaration are in motion too — legacy reads its write
+ * overlays; next composes armed-node overrides). */
+export declare let nextOptimisticViewResolver: ((target: any, raw: any) => any) | null;
+export declare function setNextOptimisticViewResolver(fn: (target: any, raw: any) => any): void;
+/** @internal birth inheritance for nodes created inside a live mark window —
+ * exported for the rewrite's node factories. */
+export declare function affectsScopesLive(): boolean;
 /**
  * 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
@@ -138,76 +144,4 @@ export declare function witnessAffectsMark(target: StoreNode, property?: Propert
  * @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;
-/**
- * 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 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;
-/**
- * Creates a deeply-reactive store backed by a Proxy. Reads track each property
- * accessed; only the parts that change trigger updates.
- *
- * Store properties hold **plain values**, not accessors. The proxy already
- * tracks reads per-property — wrapping a value in `() => state.foo` produces
- * a getter that *won't* track when called, which looks like a reactivity bug
- * but is just a category error. If you have a signal-shaped piece of state,
- * make it a property of the store (`{ foo: 1 }`) rather than nesting an
- * accessor inside (`{ foo: () => signal() }`).
- *
- * The setter takes a **draft-mutating** function — mutate the draft in place
- * (canonical). The callback may also return a new value: arrays are replaced
- * by index (length adjusted), objects are shallow-diffed at the top level
- * (keys present in the returned value are written, missing keys deleted). Use
- * the return form for shapes where mutation is awkward — most commonly
- * removing items via `filter`. The setter does **not** do keyed reconciliation;
- * for that, use the derived/projection form (or `createProjection`).
- *
- * - Plain form: `createStore(initialValue)` — wraps a value in a reactive
- *   proxy.
- * - Derived form: `createStore(fn, seed, options?)` — a *projection store*
- *   whose contents are computed by `fn(draft)`. `fn` may be sync, async, or
- *   an `AsyncIterable`; the projection's result reconciles against the
- *   existing store by `options.key` (default `"id"`) for stable identity.
- *
- * @example
- * ```ts
- * const [state, setState] = createStore({
- *   user: { name: "Ada", age: 36 },
- *   todos: [] as { id: string; text: string; done: boolean }[]
- * });
- *
- * // Canonical: mutate the draft in place.
- * setState(s => { s.user.age = 37; });
- * setState(s => { s.todos.push({ id: "1", text: "x", done: false }); });
- *
- * // Return form: reach for it when mutation is awkward.
- * setState(s => s.todos.filter(t => !t.done));               // remove items
- * setState(s => ({ ...s, user: { name: "Grace", age: 85 } })); // shallow replace
- * ```
- *
- * @example
- * ```ts
- * // Derived store — auto-fetches & reconciles by `id`.
- * const [users] = createStore(
- *   async () => fetch("/users").then(r => r.json()),
- *   [] as User[]
- * );
- * ```
- *
- * @returns `[store: Store<T>, setStore: StoreSetter<T>]`
- */
-export declare function createStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>, options?: StoreOptions & {
-    shallow?: boolean;
-}): StoreReturn<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): ProjectionStoreReturn<T>;
 export {};