@solidjs/signals 2.0.0-rc.6 → 2.0.0-rc.8

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

@@ -1,204 +0,0 @@
-import type { NOT_PENDING } from "./constants.cjs";
-import type { OptimisticLane } from "./lanes.cjs";
-import type { IQueue, Transition } from "./scheduler.cjs";
-export interface Disposable {
-    (): void;
-}
-export interface Link {
-    _dep: Signal<unknown> | Computed<unknown>;
-    _sub: Computed<unknown>;
-    _nextDep: Link | null;
-    _prevSub: Link | null;
-    _nextSub: Link | null;
-    /**
-     * `_sub._depGen` at the time this link was created or last revalidated
-     * in-order. A link stamped with the subscriber's current pass generation is
-     * inside the validated `[deps.._depsTail]` prefix — an O(1) replacement for
-     * scanning the dep list to answer membership (see `link()`).
-     */
-    _gen: number;
-    _pendingObserver?: boolean;
-}
-export interface NodeOptions<T> {
-    id?: string;
-    name?: string;
-    transparent?: boolean;
-    equals?: ((prev: T, next: T) => boolean) | false;
-    ownedWrite?: boolean;
-    /** Exclude this signal from snapshot capture (internal — not part of public API) */
-    _noSnapshot?: boolean;
-    /** Extra CONFIG_* bits OR'd into the node's config at creation (internal —
-     * not part of public API). Used by resolve()/until() for
-     * CONFIG_DIRECT_COMMIT / CONFIG_AUTHORITATIVE_READ, keeping the per-flag
-     * option arms out of the core creation path. */
-    _extraConfig?: number;
-    unobserved?: () => void;
-    lazy?: boolean;
-    sync?: boolean;
-    /**
-     * Commit #0. When present (checked with `in`, so an explicit `undefined`
-     * counts), the node is born committed with this value instead of
-     * STATUS_UNINITIALIZED: reads serve it everywhere, nothing suspends to
-     * Loading boundaries, transitions are never held, and the window is
-     * verdict-quiet (`isPending` stays false — commit #0 answers the question
-     * by declaration; first-load affordances live in the value itself). After
-     * the first real answer lands, normal refetch/pending semantics apply.
-     */
-    loadingValue?: T;
-}
-/**
- * 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
-     * _transition is a scheduling affinity that a shared subscriber can merge
-     * across transactions (#2912) — following it would let one action's settle
-     * 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 | 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 — see affects(); the count is the mark's only graph state.
-     */
-    _affectsCount: number;
-    _inFlight: PromiseLike<any> | AsyncIterable<any> | null;
-    /** Cancellation for the CURRENT iterator flight (#3122): closes the
-     * iterator (`it.return()`), idempotent. Fired at the sites that release
-     * `_inFlight` so a superseded stream stops at supersede time — its owner
-     * cleanup registration may ride the zombie-disposal channel, which a held
-     * transition defers until the SUPERSEDING flight settles. Null for plain
-     * promise flights (no cancellation hook exists). */
-    _flightTeardown: (() => void) | 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>;
-    _nextChild: FirewallSignal<unknown> | null;
-}
-export type Signal<T> = RawSignal<T> | FirewallSignal<T>;
-export interface Owner {
-    id?: string;
-    _config: number;
-    _snapshotScope?: boolean;
-    /** Effect-returned cleanup; managed across reruns, invoked at true disposal */
-    _cleanup?: () => void;
-    _disposal: Disposable | Disposable[] | null;
-    _parent: Owner | null;
-    _context: Record<symbol | string, unknown>;
-    _childCount: number;
-    _queue: IQueue;
-    _firstChild: Owner | null;
-    _nextSibling: Owner | null;
-    _prevSibling: 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;
-    _statusFlags: number;
-    _height: number;
-    _nextHeap: Computed<any> | undefined;
-    _prevHeap: Computed<any>;
-    _fn: (prev?: T) => T;
-    /**
-     * 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.
-     */
-    _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`
-     * serves that committed value instead of throwing NotReadyError, so first
-     * flights never suspend readers, trip boundaries, or hold transitions.
-     * The window is verdict-quiet: `isPending` stays false, because commit #0
-     * answers the question by declaration (first-load affordances belong to
-     * the value channel). Cleared by the first value landing on any path (sync
-     * 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. (Stays in CORE: written
-     * unconditionally by recompute and every commit.)
-     */
-    _loading: boolean;
-}
-export interface Root extends Owner {
-    _root: true;
-    _parentComputed: Computed<any> | null;
-    dispose(self?: boolean): void;
-}

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

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

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

@@ -1,10 +0,0 @@
-export { $REFRESH, ContextNotFoundError, NoOwnerError, NotReadyError, TimeoutError, action, createContext, createOwner, createRoot, runWithOwner, flush, getNextChildId, peekNextChildId, getContext, setContext, getOwner, isDisposed, getObserver, isEqual, untrack, isPending, latest, SUPPORTS_PROXY, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots, enforceLoadingBoundary, enableExternalSource, resetErrorHalt } from "./core/index.cjs";
-import { type Dev } from "./core/index.cjs";
-export declare const DEV: Dev | undefined;
-export type { Owner, Context, ContextRecord, IQueue, ExternalSourceFactory, ExternalSource, ExternalSourceConfig, Refreshable, Dev, DevHooks, DiagnosticCapture, DiagnosticCode, DiagnosticEvent, DiagnosticKind, Diagnostics, DiagnosticSeverity } from "./core/index.cjs";
-export { createSignal, createMemo, createEffect, createRenderEffect, createTrackedEffect, createReaction, createOptimistic, refresh, resolve, until, onSettled, onCleanup } from "./signals.cjs";
-export type { Truthy, UntilOptions, Accessor, SourceAccessor, Setter, Signal, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, SignalOptions, MemoOptions, NoInfer } from "./signals.cjs";
-export { affects } from "./affects.cjs";
-export { mapArray, repeat, type Maybe } from "./map.cjs";
-export * from "./store/index.cjs";
-export { createLoadingBoundary, createErrorBoundary, createRevealOrder, flatten, type RevealOrder } from "./boundaries.cjs";

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

@@ -1,69 +0,0 @@
-import { type Accessor } from "./signals.cjs";
-export type Maybe<T> = T | void | null | undefined | false;
-/**
- * Reactively maps an array, reusing the previously-mapped value for unchanged
- * items.
- *
- * The callback shape follows the keying mode:
- * - default / `keyed: true` receives `(item, index)` where `item` is the raw
- *   row value and `index` is an accessor.
- * - `keyed: false` receives `(item, index)` where `item` is an accessor and
- *   `index` is a stable number.
- * - `keyed: item => key` receives accessors for both arguments.
- *
- * This is the underlying helper that powers `<For>`. App code should use
- * `<For>` directly; reach for `mapArray` when implementing custom list
- * components.
- *
- * - `options.keyed` — `true` (default for primitives) compares by identity;
- *   `false` falls back to index-only mapping; pass a function `(item) => key`
- *   for stable identity by extracted key.
- * - `options.fallback` — accessor returning a value to show when the input is
- *   empty.
- *
- * @example
- * ```ts
- * const view = mapArray(
- *   items,
- *   (item, index) => `${index()}: ${item.label}`,
- *   { fallback: () => "no items" }
- * );
- * ```
- *
- * @description https://docs.solidjs.com/reference/reactive-utilities/map-array
- */
-export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Item, index: Accessor<number>) => MappedItem, options?: {
-    keyed?: true;
-    fallback?: Accessor<any>;
-    name?: string;
-}): Accessor<MappedItem[]>;
-export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Accessor<Item>, index: number) => MappedItem, options: {
-    keyed: false;
-    fallback?: Accessor<any>;
-    name?: string;
-}): Accessor<MappedItem[]>;
-export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Accessor<Item>, index: Accessor<number>) => MappedItem, options: {
-    keyed: (item: Item) => any;
-    fallback?: Accessor<any>;
-    name?: string;
-}): Accessor<MappedItem[]>;
-/**
- * Reactively renders a callback `count` times, reusing previously-rendered
- * entries when only the count changes. Underlying helper for `<Repeat>`.
- *
- * - `options.from` — start index (default `0`); useful for offset/windowed
- *   rendering.
- * - `options.fallback` — accessor returning a value to show when count is `0`.
- *
- * @example
- * ```ts
- * const view = repeat(count, i => `Item ${i}`, { fallback: () => "empty" });
- * ```
- *
- * @description https://docs.solidjs.com/reference/reactive-utilities/repeat
- */
-export declare function repeat(count: Accessor<number>, map: (index: number) => any, options?: {
-    from?: Accessor<number | undefined>;
-    fallback?: Accessor<any>;
-    name?: string;
-}): Accessor<any[]>;

package/dist/types-cjs/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "commonjs"
-}

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

@@ -1,21 +0,0 @@
-export type { Store, StoreReturn, ProjectionStoreReturn, StoreSetter, StoreNode, StoreOptions, ProjectionOptions, NotWrappable, SolidStore } from "./store.cjs";
-export type { Merge, Omit } from "./utils.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 { registerPatch, registerRowOps, registerSlotPatchNext as registerSlotPatch, patchableRaw } from "./next/patch.cjs";
-export { storeIsShallow, storeHasFamily, storeHasOptimisticFamily } from "./next/store.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 { merge, omit } from "./utils.cjs";

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

@@ -1,23 +0,0 @@
-import { type Transition } from "../../core/scheduler.cjs";
-import { type NoFn, type ProjectionOptions, type Store, type StoreSetter } from "../store.cjs";
-import type { StoreNextTarget } from "./target.cjs";
-/** #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 = {}>(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;
-/** 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>): Record<PropertyKey, any>;

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

@@ -1,41 +0,0 @@
-import type { StoreNextTarget } from "./target.cjs";
-import type { RowOps } from "./patch.cjs";
-/**
- * Patch-channel emission seams (pay-for-use). The store/reconcile/optimistic
- * write paths emit through these installed hook objects instead of importing
- * `patch.js` statically, so the channel tree-shakes out of apps that never
- * register a patch consumer.
- *
- * TWO TIERS, armed at registration (patch.js installs them; it is retained
- * only through its registration exports, which only compiled patch-mode
- * output — via the web runtime's driver module — imports):
- * - VALUE hooks (`patchHooks`): record patches. Armed by `registerPatch` —
- *   present in any bundle with one eligible template under patch mode.
- * - ROW hooks (`rowHooks`): list structure (row ops, slot ticks, the
- *   identity/keyed diff builders in reconcile.js they drag in). Armed by
- *   `registerRowOps`/`registerSlotPatchNext` — the LIST driver's
- *   registrations, so value-only bundles never retain the row machinery.
- *
- * Soundness: every emission site is guarded by the matching `pc` channel
- * (`pc.p` for value, `pc.ro`/`pc.sp` for rows), and a target can only
- * acquire that channel through the corresponding registration — so each
- * hook object is installed by the time any guard passes. Type-only imports
- * from `patch.js` are erased.
- */
-export interface PatchValueHooks {
-    emitPatch(t: StoreNextTarget, next: any, prev: any): void;
-    emitPatchLocal(t: StoreNextTarget, next: any, prev: any): void;
-    emitPatchOptimistic(t: StoreNextTarget, next: any, prev: any): void;
-    hasPatches(): boolean;
-    demoteToEffects(t: StoreNextTarget): void;
-}
-export interface PatchRowHooks {
-    emitRowOps(t: StoreNextTarget, next: any[], ops: RowOps): void;
-    emitSlotPatch(t: StoreNextTarget, index: number, next: any, prev: any): void;
-    emitSetterRowOps(t: StoreNextTarget, prevRows: any[], nextRows: any[]): void;
-    emitRowOpsOptimistic(t: StoreNextTarget, next: any[] | null, ops: RowOps | null): void;
-}
-export declare let patchHooks: PatchValueHooks | null;
-export declare let rowHooks: PatchRowHooks | null;
-export declare function installPatchHooks(hooks: PatchValueHooks): void;
-export declare function installRowHooks(hooks: PatchRowHooks): void;

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

@@ -1,91 +0,0 @@
-import type { Owner } from "../../core/types.cjs";
-import { type StoreNextTarget } from "./target.cjs";
-export type PatchFn = (next: any, prev: any, force?: boolean) => void;
-interface PatchEntry {
-    fn: PatchFn;
-    owner: Owner | null;
-}
-/**
- * Emit a record's visibility transition. Callers gate on `hasPatches()` and
- * `t.d` cheaply; this function re-checks and walks ancestors (§4b).
- */
-export declare function emitPatch(t: StoreNextTarget, next: any, prev: any): void;
-/** Emission for sites that already stand at the record with both sides in
- * hand and have already handled ancestors (the adoption walk descends —
- * parents were visited first), so no bubbling walk. */
-export declare function emitPatchLocal(t: StoreNextTarget, next: any, prev: any): void;
-export declare function emitPatchOptimistic(t: StoreNextTarget, next: any, prev: any): void;
-/** Row-ops emission at OPTIMISTIC (lane) timing: user drafts on an
- * optimistic family must show structure IN FLIGHT — bypassing the
- * transition stash exactly like emitPatchOptimistic. Two forms:
- * - `ops` given (write site): `nextRows` is the draft's intended visible
- *   list, ops the identity diff against the pre-write optimistic view.
- * - `ops === null` (revert site): RESYNC — the consumer rebuilds retention
- *   by row identity against the live post-revert view, resolved from the
- *   target at drain time (overrides are gone by then, so `pb ?? v` IS the
- *   committed truth). */
-export declare function emitRowOpsOptimistic(t: StoreNextTarget, nextRows: any[] | null, ops: RowOps | null): void;
-/** Test-only accounting probe: the live registration count must return to
- * baseline across register/unbind/demote cycles. @internal */
-export declare function patchCountForTests(): number;
-export declare function hasPatches(): boolean;
-export declare function registerPatch(record: any, fn: PatchFn): () => void;
-/** Dual-driver bind probe (compiler runtime contract): when `record` is a
- * patchable store record, returns its CURRENT raw backing (the driver's
- * initial force-apply reads it directly — no proxy traffic, no tracking);
- * returns undefined otherwise (driver falls back to the effect path).
- * Not patchable: non-records, non-proxies, accessor-bearing records
- * (patches read raw — getters need tracked evaluation), broken chains. */
-export declare function patchableRaw(record: any): Record<PropertyKey, any> | undefined;
-/** Accessor demotion (design §5): a record that acquires an accessor after
- * registration stops being patchable — reads must go through tracked
- * evaluation. Clears patches and repairs the global count; callers re-drive
- * the pulled bodies (demoteToEffects). */
-export declare function demotePatches(t: StoreNextTarget): PatchEntry[] | null;
-/** The demotion re-drive (re-audit blocker 3): each pulled body becomes the
- * SAME dual-driver effect fallback the web runtime would have chosen had the
- * record carried the accessor at bind — a tracked compute pass (next === prev
- * short-circuits every compare into a pure read THROUGH THE PROXY, so getter
- * dependencies track) plus an untracked force-apply at effect timing.
- *
- * Creation is DEFERRED to the effect phase: the trap that discovers the
- * accessor runs mid-draft, and an effect's initial pass must not read
- * through the proxy inside the write window. The record's own transition
- * for that draft is covered by the new effect's initial force-apply.
- *
- * Known edge (documented): a demoted LIST-ROW body re-drives under its
- * registering owner (the list owner), so per-row severing on removal is
- * lost for demoted rows — the effect lives until the LIST disposes. Rows
- * only demote when user code defines an accessor on a row record at
- * runtime. */
-export declare function demoteToEffects(t: StoreNextTarget): void;
-/** Structural ops for one keyed-array transition. `prefix` rows key-matched
- * in place; for each later index i (absolute), `sources[i - prefix]` is the
- * OLD index its row retained from, or -1 for a new row. `removed` holds the
- * dropped old row values (unbind/teardown handles). Aligned value ticks emit
- * NOTHING — ops exist only when structure changed. */
-export interface RowOps {
-    prefix: number;
-    sources: number[];
-    removed: any[];
-}
-/** `ops === null` is the RESYNC form (optimistic revert): the consumer
- * rebuilds retention by row identity against `next` (the live view). */
-export type RowOpsFn = (next: any[], ops: RowOps | null) => void;
-/** Register a structural-ops consumer on a keyed store array (the list
- * container's channel — what `For` consumes through the seam). */
-export declare function registerRowOps(array: any, fn: RowOpsFn): () => void;
-/** Slot patches (shallow arrays) ride the same apply queue: the walk emits
- * per aligned value-replaced slot; application happens at effect phase under
- * the registration owner's lifetime. */
-export declare function emitSlotPatch(t: StoreNextTarget, index: number, next: any, prev: any): void;
-/** Slot patch for shallow arrays: the reconcile walk emits (index, next,
- * prev) for KEY-ALIGNED value-replaced slots (structure rides row ops), and
- * the emission queues through the patch apply queue — effect-phase timing,
- * transition stamping, disposed-owner drop — like every other channel. */
-export declare function registerSlotPatchNext(arr: any, fn: (index: number, next: any, prev: any) => void): () => void;
-/** Row-ops ride the SAME apply queue/timing as record patches: transition-
- * stamped, applied at effect phase, in emission order (structure before the
- * new rows' own patches can exist; retained rows' value patches commute). */
-export declare function emitRowOps(t: StoreNextTarget, next: any[], ops: RowOps): void;
-export {};

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

@@ -1,8 +0,0 @@
-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, value: T) => void, aroundDraftWrite?: (op: () => void) => void): Computed<void | T>;

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

@@ -1,17 +0,0 @@
-import type { RowOps } from "./patch.cjs";
-import { type StoreNextTarget } from "./target.cjs";
-type KeyFn = (item: any) => any;
-export declare function reconcileNextState(value: any, state: any, key: string | KeyFn | null | undefined, replace?: boolean): void;
-/** Key equality for EVERY key comparison in this module (re-audit 2, P1-5):
- * SameValueZero, matching the Map-based matchers (buildRowOps, the adoption
- * window) — NaN keys are equal to themselves, so aligned NaN rows stay
- * aligned in the prefix walk instead of forever misaligning. Adoption and
- * row ops MUST agree on key equality or retained DOM rows go stale. */
-export declare function sameKey(a: any, b: any): boolean;
-export declare function emitSetterRowOps(t: StoreNextTarget, prevRows: any[], nextRows: any[]): void;
-/** Identity-keyed structural diff, returned rather than emitted: shared by
- * the setter channel (regular queue) and the OPTIMISTIC write channel (lane
- * queue) — same retention semantics, different dispatch timing. Returns
- * null when the lists are identity-aligned (no structure changed). */
-export declare function buildIdentityRowOps(prevRows: any[], nextRows: any[]): RowOps | null;
-export {};

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

@@ -1,127 +0,0 @@
-import type { Signal } from "../../core/types.cjs";
-import { type StoreNextFamily, type StoreNextTarget, type PatchChannel } from "./target.cjs";
-/** Lazily allocate the patch-channel extension (one literal shape). */
-export declare function pcOf(t: StoreNextTarget): PatchChannel;
-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;
-/** Scanned plainness for patch admission (patchableRaw): runs the one-time
- * accessor scan if it hasn't happened yet — the sticky `a` flag alone is not
- * trustworthy before a scan (it starts false and is discovered lazily). */
-export declare function targetIsPlain(target: StoreNextTarget): boolean;
-/** 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;
-/** 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;
-/** 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;
-/** 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;
-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>];
-/** 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;