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

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

@@ -0,0 +1,99 @@
+/**
+ * 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;
+    /** 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;

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

@@ -1,5 +1,5 @@
-import { STORE_SNAPSHOT_PROPS, type Computed, type Refreshable, type Signal } from "../core/index.cjs";
-import { type Transition } from "../core/scheduler.cjs";
+import { type Signal } from "../core/index.cjs";
+import type { Refreshable } from "../core/index.cjs";
 /** 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>;
 /**
@@ -58,21 +58,14 @@ 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 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 +75,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 +85,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).
+ * 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 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.
- */
-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 +135,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 {};

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

@@ -1,43 +1,3 @@
-/**
- * Returns a plain (non-proxy, non-reactive) deep copy of a store value.
- * Reading via `snapshot` does **not** subscribe to changes — use this when you
- * need to hand a stable plain object to non-reactive code (logging,
- * serialization, structured-clone, network payloads, etc.).
- *
- * Returns the original object identity for any sub-tree that wasn't modified
- * relative to the proxy's underlying source.
- *
- * @example
- * ```ts
- * const [state] = createStore({ user: { name: "Ada" }, todos: [] });
- *
- * console.log(JSON.stringify(snapshot(state))); // safe, non-reactive copy
- * ```
- */
-export declare function snapshot<T>(item: T): T;
-export declare function snapshot<T>(item: T, map?: Map<unknown, unknown>, lookup?: WeakMap<any, any>): T;
-/**
- * Returns a plain (non-proxy) deep copy **and** subscribes the current
- * tracking scope to every nested change in the source store. Any write
- * anywhere in the subtree invalidates the consumer.
- *
- * Use this when you need plain data inside a reactive scope and want to
- * react to deep mutations (e.g. passing a snapshot to `reconcile()` or to a
- * memo that should rerun on any nested change). For most read paths, prefer
- * direct property access — Solid stores already track per-property reads
- * with no `deep()` wrapper needed.
- *
- * @example
- * ```ts
- * const [state] = createStore({ a: { b: { c: 1 } } });
- *
- * createEffect(
- *   () => deep(state),                  // reruns on any nested change
- *   plain => sendToWorker(plain)        // worker gets a non-proxy copy
- * );
- * ```
- */
-export declare function deep<T extends object>(store: T): T;
 type DistributeOverride<T, F> = T extends undefined ? F : T;
 type Override<T, U> = T extends any ? U extends any ? {
     [K in keyof T]: K extends keyof U ? DistributeOverride<U[K], T[K]> : T[K];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/signals",
-  "version": "2.0.0-rc.0",
+  "version": "2.0.0-rc.1",
   "description": "Solid's reactive primitives: signals, memos, effects, stores, and async-aware computations.",
   "author": "Ryan Carniato",
   "license": "MIT",
@@ -40,6 +40,7 @@
     "./package.json": "./package.json"
   },
   "devDependencies": {
+    "@codspeed/vitest-plugin": "^5.4.0",
     "@ianvs/prettier-plugin-sort-imports": "^4.1.1",
     "@rollup/plugin-replace": "^6.0.3",
     "@rollup/plugin-typescript": "^12.3.0",

package/dist/prod/store/optimistic.js

@@ -1,217 +0,0 @@
-import { STATUS_PENDING, CONFIG_AUTO_DISPOSE, NOT_PENDING } from "../core/constants.js";
-
-import { computed } from "../core/core.js";
-
-import { GlobalQueue, schedule, currentTransition, insertSubs, setProjectionWriteActive, projectionWriteActive } from "../core/scheduler.js";
-
-import "../core/invariants.js";
-
-import "../core/verdict.js";
-
-import "../core/effect.js";
-
-import { installOptimisticEngine } from "../core/optimistic.js";
-
-import { runProjectionComputed } from "./projection.js";
-
-import { $TARGET, STORE_FIREWALL, storeSetter, STORE_OPTIMISTIC_OVERRIDE, STORE_NODE, STORE_OPTIMISTIC_OWNERS, getOverlayLayer, STORE_VALUE, $DELETED, isWrappable, wrap, visibleNodeValue, $TRACK, notifySelf, STORE_WRAP, createStoreProxy, storeTraps, STORE_LOOKUP, STORE_SHALLOW, markRawIngest, STORE_OPTIMISTIC } from "./store.js";
-
-function createOptimisticStore(e, t, i) {
-    // Register clear function with scheduler; store nodes marked
-    // STORE_OPTIMISTIC take the engine's write path, so install it before any
-    // node can be created.
-    installOptimisticEngine();
-    if (!GlobalQueue.Dt) {
-        GlobalQueue.Dt = clearOptimisticStores;
-        // Store half of the engine's override blockage (#2951): signal-form
-        // createOptimistic carries the pending async and the override on ONE node,
-        // so transitionBlocked sees both; a derived optimistic STORE splits them —
-        // the layer sits on store targets while the in-flight truth lives on the
-        // firewall computed. Without this, the transition adopting a bare store
-        // write settled in the same flush that started the refetch and its settle
-        // consumed the layer mid-flight (follow-up writes then drafted from base,
-        // clobbering instead of composing). Optimistic state clears when truth
-        // lands or its transaction ends — never mid-refetch. Wrapped here (engine
-        // is already installed above) so store-free apps never carry the check.
-                const e = GlobalQueue.Tn;
-        GlobalQueue.Tn = t => {
-            for (const e of t.cn) {
-                if ((e[$TARGET]?.[STORE_FIREWALL]?.S ?? 0) & STATUS_PENDING) return true;
-            }
-            return e(t);
-        };
-    }
-    const r = typeof e === "function";
-    // Plain form: the second slot carries options.
-        if (!r && i === undefined) i = t;
-    const o = r ? t : e;
-    const n = r ? e : undefined;
-    // Create optimistic projection store
-        const {store: c} = createOptimisticProjectionInternal(n, o, i);
-    return [ c, e => storeSetter(c, e) ];
-}
-
-// Clear the optimistic overrides of a settling batch of stores and notify
-// signals. Owns the whole batch (iterate + clear + reschedule) so the
-// scheduler's flush tail carries only a size-guarded hook call. The
-// completing transition scopes each clear to its own layer keys (#2899).
-function clearOptimisticStores(e, t) {
-    for (const i of e) {
-        const e = i[$TARGET];
-        if (e?.[STORE_OPTIMISTIC_OVERRIDE]) clearOptimisticOverride(e, t);
-    }
-    e.clear();
-    schedule();
-}
-
-/**
- * Consume optimistic layer entries and reset their backing nodes to base.
- * With `completing` (settle path, #2899) only entries the settling
- * transaction owns are consumed — the layer is store-wide but concurrent
- * actions revert independently, so keys stamped by a still-in-flight
- * transition survive (node-level overrides already have this granularity via
- * _optimisticNodes; this is the layer's half). `null` consumes ambient
- * (transaction-less) entries at plain flush end. Omitted (projection landing:
- * fresh authoritative data) consumes everything — the correction supersedes
- * every tentative layer.
- */ function clearOptimisticOverride(e, t) {
-    const i = e[STORE_OPTIMISTIC_OVERRIDE];
-    if (!i) return;
-    const r = e[STORE_NODE];
-    const o = e[STORE_OPTIMISTIC_OWNERS];
-    const n = t !== undefined;
-    let c = false;
-    let s = false;
-    // Use projectionWriteActive to bypass optimistic signal behavior (no lane creation)
-    // This ensures reversion effects go to regular queues, not lane queues
-        const O = projectionWriteActive;
-    setProjectionWriteActive(true);
-    try {
-        for (const O of Reflect.ownKeys(i)) {
-            if (n) {
-                let e = o?.[O] ?? null;
-                // Resolve merge chains (entangled actions settle as one); path-compress
-                // so later keys skip the walk. A dead owner (`_done === true`) settled
-                // through some other path — never strand its entry. A null owner is an
-                // ambient write: its batch belongs to whichever transaction adopted it
-                // (initTransition mid-batch) or to the plain flush, so it clears on
-                // whichever clear call reaches this store first.
-                                if (e) {
-                    if (typeof e.fn === "object") e = o[O] = currentTransition(e);
-                    if (e !== t && e.fn !== true) {
-                        s = true;
-                        continue;
-                    }
-                }
-            }
-            delete i[O];
-            if (o) delete o[O];
-            c = true;
-            const T = r?.[O];
-            if (T) {
-                // Clear lane association so effects go to regular queue
-                T.Ke = undefined;
-                // Re-read from base — this key left the optimistic layer above, so the
-                // overlay resolves to STORE_OVERRIDE or STORE_VALUE.
-                                const t = getOverlayLayer(e, O);
-                const i = t ? t[O] : e[STORE_VALUE][O];
-                const r = i === $DELETED ? undefined : i;
-                const o = isWrappable(r) ? wrap(r, e) : r;
-                const n = visibleNodeValue(T);
-                T._e = NOT_PENDING;
-                T.sn = null;
-                T.De = NOT_PENDING;
-                T.Ue = o;
-                if (!T.be || !T.be(n, o)) {
-                    insertSubs(T, true);
-                    schedule();
-                }
-            }
-        }
-        if (!s) {
-            // Assignment, not delete: StoreNode targets share one pre-initialized
-            // hidden class (see createStoreProxy) and a delete would demote it.
-            e[STORE_OPTIMISTIC_OVERRIDE] = undefined;
-            e[STORE_OPTIMISTIC_OWNERS] = undefined;
-        }
-        // Notify $TRACK
-                if (c && r?.[$TRACK]) {
-            r[$TRACK].Ke = undefined;
-            notifySelf(e);
-        }
-    } finally {
-        setProjectionWriteActive(O);
-    }
-}
-
-function createOptimisticProjectionInternal(e, t, i) {
-    let r;
-    const o = new WeakMap;
-    const n = !!i?.shallow;
-    const wrapper = e => {
-        e[STORE_WRAP] = wrapProjection;
-        e[STORE_LOOKUP] = o;
-        if (n) {
-            e[STORE_SHALLOW] = true;
-            markRawIngest(e[STORE_VALUE]);
-        }
-        e[STORE_OPTIMISTIC] = true;
- // Mark as optimistic store
-                Object.defineProperty(e, STORE_FIREWALL, {
-            get() {
-                return r;
-            },
-            configurable: true
-        });
-    };
-    const wrapProjection = e => {
-        if (o.has(e)) return o.get(e);
-        if (e[$TARGET]?.[STORE_WRAP] === wrapProjection) return e;
-        const t = createStoreProxy(e, storeTraps, wrapper);
-        o.set(e, t);
-        return t;
-    };
-    const c = wrapProjection(t);
-    // If there's a projection function, create a computed to drive it
-        if (e) {
-        // All writes inside firewall recompute must go to STORE_OVERRIDE (base), not
-        // STORE_OPTIMISTIC_OVERRIDE. The outer wrap covers the sync body (including
-        // `fn(draft)` and the initial commit); `wrapCommit` re-applies the flag for
-        // async yields because they fire outside any enclosing try/finally. It also
-        // consumes stale optimistic overlays once fresh projected data lands.
-        const clearProjectionOverride = () => {
-            const e = c[$TARGET];
-            if (e?.[STORE_OPTIMISTIC_OVERRIDE]) clearOptimisticOverride(e);
-        };
-        const wrapCommit = e => {
-            const t = projectionWriteActive;
-            setProjectionWriteActive(true);
-            try {
-                e();
-                clearProjectionOverride();
-            } finally {
-                setProjectionWriteActive(t);
-            }
-        };
-        // seedLoadingValue: born-committed firewall, same as createProjection.
-                let t;
-        if (i?.seedLoadingValue) t = {
-            loadingValue: undefined
-        };
-        r = computed(() => {
-            setProjectionWriteActive(true);
-            try {
-                runProjectionComputed(c, e, i?.key === undefined ? "id" : i.key, wrapCommit, clearProjectionOverride);
-            } finally {
-                setProjectionWriteActive(false);
-            }
-        }, t);
-        r.T &= ~CONFIG_AUTO_DISPOSE;
-    }
-    return {
-        store: c,
-        node: r
-    };
-}
-
-export { createOptimisticStore };