@solidjs/signals 2.0.0-rc.13 → 2.0.0-rc.14

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

@@ -1,6 +0,0 @@
-/**
- * Installs the engine's hooks. Idempotent; called by every module that can
- * create optimistic state (verdict.ts at module top level, createOptimistic
- * and createOptimisticStore at first call) BEFORE any optimistic node exists.
- */
-export declare function installOptimisticEngine(): void;

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

@@ -1,25 +0,0 @@
-import { type Refreshable } from "../../core/index.js";
-import { type Transition } from "../../core/scheduler.js";
-import { type NoFn, type ProjectionOptions, type Store, type StoreOptions, type StoreSetter } from "../store.js";
-import type { StoreNextTarget } from "./target.js";
-/** #3164 fold: a stamped truth is HELD (masked from ordinary readers until
- * the reveal) only while its transition is live AND retaining optimism —
- * overrides are what make partial-coverage composition a tear. A plain
- * async transition carries no overrides, so downstream computes must see
- * staged values to converge (normal speculation). Resolves merges first:
- * merge unions optimistic nodes/stores into the target. */
-export declare function transitionHoldsOptimism(transition: Transition): boolean;
-export declare function createOptimisticStoreNext<T extends object = {}>(initialValue: NoFn<T> | Store<NoFn<T>>, options?: StoreOptions): [get: Store<T>, set: StoreSetter<T>];
-export declare function createOptimisticStoreNext<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Refreshable<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;
-/** 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`.
- * Authoritative-view reads (until()'s predicate) skip composition entirely:
- * the predicate observes authoritative truth, never the caller's tentative
- * overlay. (Write-side emission callers never run under such a compute.) */
-export declare function optimisticView(t: StoreNextTarget, src: Record<PropertyKey, any>, draft?: boolean): Record<PropertyKey, any>;

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

@@ -1,27 +0,0 @@
-/**
- * Store rewrite — projections (§7/§7b): a projection is a computed store.
- * The derive runs inside a computed whose recompute merges its output into
- * the projection's backing through the adoption channel (replace-mode root:
- * entity changes merge in place, the root proxy is stable for life). Children
- * wrap into the projection's own FAMILY (writes land here, never in a source
- * family), and every family node carries the projection computed as its
- * firewall — reads link the derive's status and lifecycle natively. The §6c
- * status gate in the traps makes an uninitialized async derive's seed
- * unobservable through every read surface.
- *
- * Mirrors the legacy runProjectionComputed shape (shadow runs for open
- * loading windows, handleAsync landings, commit-through-setter) on next
- * primitives; the generic draft write-traps are reused from the legacy
- * module unchanged.
- */
-import { type Computed, type Refreshable } from "../../core/index.js";
-import { type NoFn, type ProjectionOptions, type Store } from "../store.js";
-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). Across a hold the write is not a proposal:
- * a leaf another transaction holds as the fold's result re-runs the fold
- * under it, the write being the draft's prior state (A34 amendment, #3612;
- * core derivedWrite). */
-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, value: T) => void, aroundDraftWrite?: (op: () => void) => void): Computed<void | T>;

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

@@ -1,10 +0,0 @@
-type KeyFn = (item: any) => any;
-export declare function reconcileNextState(value: any, state: any, key: string | KeyFn | null | undefined, replace?: boolean): void;
-/** Setter-channel row ops (the fold site calls this for array targets with
- * ops consumers): structural mutation through the setter — push/splice/index
-/** Key equality for EVERY key comparison in this module (re-audit 2, P1-5):
- * SameValueZero, matching the adoption window's Map-based matcher — NaN keys
- * are equal to themselves, so aligned NaN rows stay aligned in the prefix
- * walk instead of forever misaligning. */
-export declare function sameKey(a: any, b: any): boolean;
-export {};

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

@@ -1,145 +0,0 @@
-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, and so does the
- * commit itself when the fold changed the key set (overlayRebuilds). Returns
- * the pending backing (the clone, or the pb as-is when not an overlay). */
-export declare function materializePB(target: StoreNextTarget): Record<PropertyKey, any>;
-/** 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

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