bireactive 0.2.4 → 0.3.1

package/dist/core/cell.d.ts

@@ -17,58 +17,66 @@ interface Link {
     prevDep: Link | undefined;
     nextDep: Link | undefined;
 }
+interface LensLink {
+    index: number;
+    parent: Cell<unknown>;
+    child: Cell<unknown>;
+    /** Spliced into `parent.childEdges` yet? The down-list (`parentEdges`) is
+     *  eager at construction; the up-list is lazy on first back-mark so the
+     *  parent's child order is arm-order (co-writer resolution is last-write-wins). */
+    linked: boolean;
+    nextParent: LensLink | undefined;
+    prevChild: LensLink | undefined;
+    nextChild: LensLink | undefined;
+}
 /** Install a hook fired on every source value-change; returns a restore fn. */
 export declare function setCellWriteHook(fn: ((cell: Cell<unknown>) => void) | undefined): () => void;
-export interface MergePolicy<T> {
-    readonly identity: T;
-    combine(acc: T, x: T): T;
-    /** Optional inverse for incremental fold. */
-    remove?(acc: T, x: T): T;
-}
-export declare const DIRECT_SLOT: unique symbol;
+export type MergeFold<T> = (values: readonly T[]) => T;
 declare class MergeNode<T> {
-    readonly parent: Cell<T>;
-    readonly policy: MergePolicy<T>;
-    readonly slots: Map<unknown, T>;
-    readonly hasIncrementalAcc: boolean;
-    acc: T;
-    constructor(parent: Cell<T>, policy: MergePolicy<T>);
-    receive(slot: unknown, next: T): void;
-    fold(): T;
-    reset(): void;
+    readonly foldFn: MergeFold<T> | undefined;
+    /** Contributions gathered as the cone resolves; folded and cleared in `foldMerge`. */
+    contributions: T[];
+    constructor(fold: MergeFold<T> | undefined);
 }
 declare class BwdSpec {
-    /** Backward target(s): one `Cell` (1→1 / merge) or `Cell[]` (multi-out). */
-    parent: Cell<unknown> | Cell<unknown>[] | undefined;
-    /** Lens `put` — backward derivation (dual of `getter`). Always called by
-     *  the engine in 1-arg form `put(target)`; a source-reading lens bakes
-     *  `settled(parent)` into this closure at build time. Multi-output:
-     *  returns a per-parent update array. Stateful: the spec's `bwd`. */
+    /** Lens `put` (dual of `getter`): `put(target)` for 1→1 / multi-out (a
+     *  source-reading lens reads its parents at walk time), `put(target, sources, c)`
+     *  for stateful. `undefined` for a merge (folds) or pin (absorbs). */
     put: ((target: any, current?: any) => any) | undefined;
-    /** Backward aggregation node; presence IS the merge-mode discriminant. */
+    /** Fold payload; present ⇒ a fan-in merge. */
     merge: MergeNode<unknown> | undefined;
-    /** Complement machinery; presence IS the stateful-mode discriminant. */
+    /** Complement state; present ⇒ a complement-carrying (stateful) lens. */
     stateful: StatefulCore | undefined;
-    /** Index in `bwdQueue` of this cell's latest push; the drain skips stale
-     *  entries so each cell propagates backward once per flush, last-write. */
-    queueIdx: number;
+    /** `put` yields a per-parent tuple (split / stateful) vs a scalar (1→1). The
+     *  only discriminant not derivable from topology (a 1-parent split is a tuple). */
+    scatter: boolean;
 }
-/** Runtime state of a stateful (complement-carrying) lens — the rare
- *  backward mode, kept off `BwdSpec` so plain lenses don't carry its slots.
- *  `put` (the spec's `bwd`) and `parent` stay on `BwdSpec`; this holds the
- *  complement and the closures that project from / advance it. */
+/** Runtime state of a symmetric-lens complement, kept off `BwdSpec` so plain
+ *  lenses don't carry its slots. See the stateful-lens header for the theory
+ *  (symmetric/edit lenses) and the version-stamp provenance. */
 declare class StatefulCore {
     /** Engine-owned memory the view discards. */
     complement: unknown;
-    /** Forward projection `fwd(sources, complement) → view`. */
-    fwd: (sources: any, complement: any) => any;
-    /** Advance the complement: `step(sources, complement, external)`. */
-    step: (sources: any, complement: any, external: boolean) => any;
-    /** Source values last written back (own-vs-external test); `undefined`
-     *  until the first back-write. */
-    lastBwd: unknown[] | undefined;
-    constructor(complement: unknown, fwd: (sources: any, complement: any) => any, step: (sources: any, complement: any, external: boolean) => any);
+    /** Advance the complement: `step(sources, complement)`. Run only when the
+     *  sources actually moved (the engine gates it; see the stateful header). */
+    step: (sources: any, complement: any) => any;
+    /** Sum of the parents' `version`s as of the last sync. Sources moved iff the
+     *  live sum differs — the lazy own-vs-external provenance that replaces a value
+     *  witness. A read syncs it after stepping; a back-write re-stamps it post-order
+     *  (own writes don't re-step, so `bwd` must leave the complement consistent).
+     *  Seeded to `-1` (sums are ≥ 0) so the first use always folds the sources in. */
+    stamp: number;
+    constructor(complement: unknown, step: (sources: any, complement: any) => any);
 }
+/** Multi-out / stateful back-write sentinel: "leave this parent untouched."
+ *  Every non-`SKIP` slot is written verbatim, `undefined` included; a short array
+ *  skips the trailing parents. (1→1 `put` always writes its one parent.) */
+export declare const SKIP: unique symbol;
+export type Skip = typeof SKIP;
+/** Per-parent back-write result: any prefix of the update tuple, each slot a value
+ *  or `SKIP` (so `[a]` / `[a, SKIP]` / `[]` all type against `[A, B]`, while a bare
+ *  `undefined` in a non-undefined slot stays an error). */
+export type BackUpdates<T extends readonly unknown[]> = number extends T["length"] ? T : T extends readonly [infer H, ...infer R] ? readonly [] | readonly [H, ...BackUpdates<R>] : readonly [];
 /** Plain T or any read-shape; snapshot via `readNow`, close via `reader`. */
 export type Val<T> = T | Read<T>;
 /** Covariant read-only surface. */
@@ -89,6 +97,16 @@ export type Writable<R> = R & WritableBrand & {
 };
 /** Strict factory input: a literal, or an existing `Writable<Cls>`. */
 export type Init<C extends Cell<any>> = Inner<C> | Writable<C>;
+/** Per-position value types behind a tuple of read shapes (the tuple form of {@link Inner}). */
+type ReadValues<P extends readonly Read<unknown>[]> = {
+    [K in keyof P]: Inner<P[K]>;
+};
+/** {@link ReadValues} with each slot also admitting `SKIP` — the per-parent back-update shape. */
+type ReadValuesOrSkip<P extends readonly Read<unknown>[]> = {
+    [K in keyof P]: Inner<P[K]> | Skip;
+};
+/** Any `Cell` subclass constructor — the constraint for polymorphic-`this` statics. */
+type AnyCellCtor = new (...args: never[]) => Cell<any>;
 /** Snapshot a `Val<T>` to plain `T` (one-shot, no tracking). */
 export declare function readNow<T>(v: Val<T>): T;
 /** Resolve a `Val<T>` to a `() => T` closure that unwraps on each call. */
@@ -108,129 +126,176 @@ export interface CellOptions<T = unknown> {
     unwatched?: () => void;
     /** Per-instance value equality; defaults to `Object.is`. */
     equals?: (a: T, b: T) => boolean;
+    /** Debug label; surfaces in cyclic-read errors and graph dumps (see debug.ts). */
+    name?: string;
+}
+/** A lens as a first-class value, unbound from any source: `get` projects A→B,
+ *  `put` writes B back into an A. Apply with `cell.through(optic)`; build with
+ *  `optic` / `iso` / `atKey` / `compose` (optic.ts). `readsSource` is `false`
+ *  only for an `iso`, letting `through` bind a cheaper 1-arg backward. */
+export interface Optic<A, B> {
+    readonly get: (a: A) => B;
+    readonly put: (b: B, a: A) => A;
+    readonly readsSource: boolean;
+    /** Compose with a following optic (this first, then `next`). */
+    through<C>(next: Optic<B, C>): Optic<A, C>;
 }
 export declare class Cell<T = unknown> implements ReactiveNode {
+    /** @internal */
     flags: number;
+    /** @internal */
     subs: Link | undefined;
+    /** @internal */
     subsTail: Link | undefined;
+    /** @internal */
     deps: Link | undefined;
+    /** @internal */
     depsTail: Link | undefined;
-    /** Forward derivation (computed/lens/merge). `undefined` ⇒ source. */
+    /** @internal Forward derivation (computed/lens/merge). `undefined` ⇒ source. */
     getter: (() => T) | undefined;
-    /** Per-instance equality, always defined (defaults to `Object.is` at
-     *  construction) so hot paths call it without an `undefined` branch. */
+    /** @internal Per-instance equality; always defined (defaults to `Object.is`). */
     _equals: (a: T, b: T) => boolean;
-    /** First-subscriber / last-subscriber lifecycle hooks. */
+    /** @internal First-subscriber / last-subscriber lifecycle hooks. */
     _watched: (() => void) | undefined;
+    /** @internal */
     _unwatchedHook: (() => void) | undefined;
-    /** Source: `currentValue` = committed, `pendingValue` = staged write.
-     *  Getter cell: `currentValue` = last derived cache, `pendingValue`
-     *  reused as the deferred backward target (see `set value`). The two
-     *  roles never coexist, so two fields suffice for four. */
+    /** @internal Source: committed value + staged write. */
     currentValue: T;
+    /** @internal */
     pendingValue: T;
-    /** Backward sidecar: target(s) + lens closures + queue slot, or
-     *  `undefined` for a read-only cell (source or computed). Allocated only
-     *  for writable derived cells, keeping the common node lean. Writability
-     *  is exactly `_bwd !== undefined`. See `BwdSpec`. */
+    /** @internal Backward sidecar; `undefined` iff read-only. Writability is `_bwd !== undefined`. */
     _bwd: BwdSpec | undefined;
+    /** @internal Lens-edges to my back-targets (down); dual of `deps`. `markDown`/
+     *  `backResolve` descend this toward sources. Index-ordered. */
+    parentEdges: LensLink | undefined;
+    /** @internal */
+    parentEdgesTail: LensLink | undefined;
+    /** @internal Lens-edges to my lens-children (up); dual of `subs`. `resolveCone`
+     *  ascends this toward the armed views. */
+    childEdges: LensLink | undefined;
+    /** @internal */
+    childEdgesTail: LensLink | undefined;
+    /** @internal Backward flag word (`BF`), dual of forward `flags`. */
+    bflags: number;
+    /** @internal Visit epoch for `backResolve`'s collect phase (dedups diamonds
+     *  without a Set; compared against the global `backCycle`). */
+    bEpoch: number;
+    /** @internal Monotone committed-change counter. A stateful lens sums its
+     *  parents' versions to detect "did my sources move since I last synced?" —
+     *  the lazy provenance that replaces a value witness (see the stateful header). */
+    version: number;
+    /** Optional debug label (`cell(0, { name })`); used by errors and graph dumps. */
+    name: string | undefined;
     constructor(initial: T, opts?: CellOptions<T>);
     readonly value: T;
-    _enqueueBwd(): void;
-    /** Source write (alien's signal setter). Self-excludes the active
-     *  network so a body writing its own dep doesn't re-trigger itself. */
+    /** @internal Single write-commit point; self-excludes the active network. */
     _writeSource(next: T): void;
+    /** @internal */
     _update(): boolean;
+    /** @internal */
     _notify(): void;
+    /** @internal */
     _unwatched(): void;
     peek(): T;
-    /** Guard: silent coercion to string/number is almost always a bug. */
-    [Symbol.toPrimitive](hint: string): never;
     /** Endomorphic lens. A 2-arg `bwd(view, current)` consults the current
      *  source; a 1-arg `bwd(view)` reconstructs it from the view alone. */
     lens(this: Cell<T>, fwd: (v: T) => T, bwd: (target: T, current: T) => T): this;
     /** Read-only same-type view: the RO dual of the endo `.lens`. For a cross-type view use the typed static
      *  `Target.derive(src, fn)`. */
     derive(this: Cell<T>, fn: (v: T) => T): this;
-    /** Backward-aggregating node — bwd dual of computed. Forward, the
-     *  identity view of its parent; backward, folds contributions from
-     *  upstream lenses (slot-keyed) and direct writes (DIRECT_SLOT). */
-    merge(this: Cell<T>, policy: MergePolicy<T>): Cell<T>;
+    /** Apply optic value(s) as a writable lens: `c.through(o)` ≡ `lens(c, o.get,
+     *  o.put)`; multiple optics compose left-to-right (`c.through(a, b)` = `a`
+     *  then `b`). Cross-type, unlike the endomorphic instance `.lens`. */
+    through<B>(this: Cell<T>, o: Optic<T, B>): Writable<Cell<B>>;
+    through<B, C>(this: Cell<T>, o1: Optic<T, B>, o2: Optic<B, C>): Writable<Cell<C>>;
+    through<B, C, D>(this: Cell<T>, o1: Optic<T, B>, o2: Optic<B, C>, o3: Optic<C, D>): Writable<Cell<D>>;
+    /** Backward fan-in: forward the identity view of its parent, backward the point
+     *  where N contributors fold into one value. `fold` defaults to last-writer-wins. */
+    merge(this: Cell<T>, fold?: MergeFold<T>): Cell<T>;
     /** Read-only typed view. `Cls.derive(parent, fn)` (1-input),
      *  `Cls.derive(parents, fn)` (N-input), or `Cls.derive(fn)` (closure).
      *  Polymorphic-`this`: `Vec.derive(...)` → `Vec`. */
-    static derive<C extends new (...args: never[]) => Cell<any>, P>(this: C, parent: Read<P>, fn: (v: P) => Inner<InstanceType<C>>): InstanceType<C>;
-    static derive<C extends new (...args: never[]) => Cell<any>, P extends readonly Read<unknown>[]>(this: C, parents: P, fn: (vals: {
-        [K in keyof P]: P[K] extends Read<infer V> ? V : never;
-    }) => Inner<InstanceType<C>>): InstanceType<C>;
-    static derive<C extends new (...args: never[]) => Cell<any>>(this: C, fn: () => Inner<InstanceType<C>>): InstanceType<C>;
+    static derive<C extends AnyCellCtor, P>(this: C, parent: Read<P>, fn: (v: P) => Inner<InstanceType<C>>): InstanceType<C>;
+    static derive<C extends AnyCellCtor, P extends readonly Read<unknown>[]>(this: C, parents: P, fn: (vals: ReadValues<P>) => Inner<InstanceType<C>>): InstanceType<C>;
+    static derive<C extends AnyCellCtor>(this: C, fn: () => Inner<InstanceType<C>>): InstanceType<C>;
     /** Writable lens. `Cls.lens(parent, fwd, bwd)` for one input,
      *  `Cls.lens(parents, fwd, bwd)` for N; a 2-arg `bwd` reads the source,
      *  a 1-arg `bwd` reconstructs it. `Cls.lens(parent(s), spec)` builds a
      *  complement-carrying lens from `{ init, step, fwd, bwd }`. */
-    static lens<C extends new (...args: never[]) => Cell<any>, P>(this: C, parent: Read<P>, fwd: (v: P) => Inner<InstanceType<C>>, bwd: (target: Inner<InstanceType<C>>, v: P) => P): Writable<InstanceType<C>>;
-    static lens<C extends new (...args: never[]) => Cell<any>, P extends readonly Read<unknown>[]>(this: C, parents: P, fwd: (vals: {
-        [K in keyof P]: P[K] extends Read<infer V> ? V : never;
-    }) => Inner<InstanceType<C>>, bwd: (target: Inner<InstanceType<C>>, vals: {
-        [K in keyof P]: P[K] extends Read<infer V> ? V : never;
-    }) => {
-        [K in keyof P]?: P[K] extends Read<infer V> ? V : never;
-    }): Writable<InstanceType<C>>;
-    static lens<C extends new (...args: never[]) => Cell<any>, P, Cm>(this: C, parent: Read<P>, spec: StatefulLensSpec<readonly [P], Inner<InstanceType<C>>, Cm>): Writable<InstanceType<C>>;
-    static lens<C extends new (...args: never[]) => Cell<any>, P extends readonly Read<unknown>[], Cm>(this: C, parents: P, spec: StatefulLensSpec<{
-        [K in keyof P]: P[K] extends Read<infer V> ? V : never;
-    }, Inner<InstanceType<C>>, Cm>): Writable<InstanceType<C>>;
+    static lens<C extends AnyCellCtor, P>(this: C, parent: Read<P>, fwd: (v: P) => Inner<InstanceType<C>>, bwd: (target: Inner<InstanceType<C>>, v: P) => P): Writable<InstanceType<C>>;
+    static lens<C extends AnyCellCtor, P extends readonly Read<unknown>[]>(this: C, parents: P, fwd: (vals: ReadValues<P>) => Inner<InstanceType<C>>, bwd: (target: Inner<InstanceType<C>>, vals: ReadValues<P>) => BackUpdates<ReadValuesOrSkip<P>>): Writable<InstanceType<C>>;
+    static lens<C extends AnyCellCtor, P, Cm>(this: C, parent: Read<P>, spec: StatefulLensSpec1<P, Inner<InstanceType<C>>, Cm>): Writable<InstanceType<C>>;
+    static lens<C extends AnyCellCtor, P extends readonly Read<unknown>[], Cm>(this: C, parents: P, spec: StatefulLensSpec<ReadValues<P>, Inner<InstanceType<C>>, Cm>): Writable<InstanceType<C>>;
     /** Type predicate against this class: `Vec.is(x)` narrows `x` to `Vec`.
      *  Inherited static; works for any subclass via polymorphic `this`. */
-    static is<C extends new (...args: never[]) => Cell<any>>(this: C, v: unknown): v is InstanceType<C>;
-    /** Lift `Val<Inner<Cls>>` → `Cls`: instance → identity, RO cell →
+    static is<C extends AnyCellCtor>(this: C, v: unknown): v is InstanceType<C>;
+    /** Coerce `Val<Inner<Cls>>` → `Cls`: instance → identity, RO cell →
      *  tracked `derive`, literal → fresh seed. */
-    static from<C extends new (...args: never[]) => Cell<any>>(this: C, v: Val<Inner<InstanceType<C>>>): InstanceType<C>;
+    static coerce<C extends AnyCellCtor>(this: C, v: Val<Inner<InstanceType<C>>>): InstanceType<C>;
     /** Writable-shaped constant: always reads `v`, absorbs writes
      *  (parentless sink lens), for APIs demanding bidirectionality. */
-    static pin<C extends new (...args: never[]) => Cell<any>>(this: C, v: Inner<InstanceType<C>>): Writable<InstanceType<C>>;
-    /** Typed field lens onto `parent.value[key]`. A read-only computed
-     *  parent yields a RO derive view; any writable parent yields a
-     *  bidirectional field lens with spread-replace `put`. */
-    static fieldOf<C extends new (...args: never[]) => Cell<any>>(parent: Cell<any>, key: string | number | symbol, Cls: C): InstanceType<C>;
+    static pin<C extends AnyCellCtor>(this: C, v: Inner<InstanceType<C>>): Writable<InstanceType<C>>;
 }
+/** Typed field lens onto `parent.value[key]`. RO parent → RO derive;
+ *  writable parent → bidirectional lens with spread-replace `put`. */
+export declare function fieldOf<C extends AnyCellCtor>(parent: Cell<any>, key: string | number | symbol, Cls: C): InstanceType<C>;
 export interface StatefulBwd<S extends readonly unknown[], C> {
-    updates: {
-        readonly [K in keyof S]: S[K] | undefined;
-    };
+    /** Per-parent updates: a value (written verbatim, `undefined` included) or
+     *  `SKIP` to leave that parent. A short array skips the trailing parents. */
+    updates: BackUpdates<{
+        [K in keyof S]: S[K] | Skip;
+    }>;
     complement: C;
 }
 export interface StatefulLensSpec<S extends readonly unknown[], V, C> {
     init: (sources: S) => C;
-    step: (sources: S, complement: C, external: boolean) => C;
+    /** Advance the complement on an outside change. Optional — defaults to `init`
+     *  (the memoryless refresh); the engine runs it only when sources actually move. */
+    step?: (sources: S, complement: C) => C;
     fwd: (sources: S, complement: C) => V;
     bwd: (target: V, sources: S, complement: C) => StatefulBwd<S, C>;
 }
+/** Single-source `bwd` result: a scalar `update` (or `SKIP`) plus the complement. */
+export interface StatefulBwd1<S, C> {
+    update: S | Skip;
+    complement: C;
+}
+/** Single-source stateful spec — the scalar fast-path of `StatefulLensSpec`: one
+ *  parent, so `init`/`step`/`fwd`/`bwd` take the source value directly, not a tuple. */
+export interface StatefulLensSpec1<S, V, C> {
+    init: (source: S) => C;
+    step?: (source: S, complement: C) => C;
+    fwd: (source: S, complement: C) => V;
+    bwd: (target: V, source: S, complement: C) => StatefulBwd1<S, C>;
+}
 /** Writable source; passes an existing `Writable` through (idempotent). */
 export declare function cell<T>(initial: T | Writable<Cell<T>>, opts?: CellOptions<T>): Writable<Cell<T>>;
 /** Untyped read-only view: `derive(parent, fn)`, `derive(parents, fn)`,
  *  or `derive(fn)` (closure). */
 export declare function derive<P, R>(parent: Read<P>, fn: (v: P) => R): Cell<R>;
-export declare function derive<P extends readonly Read<unknown>[], R>(parents: P, fn: (vals: {
-    [K in keyof P]: P[K] extends Read<infer V> ? V : never;
-}) => R): Cell<R>;
+export declare function derive<P extends readonly Read<unknown>[], R>(parents: P, fn: (vals: ReadValues<P>) => R): Cell<R>;
 export declare function derive<R>(fn: () => R): Cell<R>;
 /** Untyped lens, inferring `R` from the closures. A 2-arg `bwd` reads the
  *  source, a 1-arg `bwd` reconstructs it; `lens(parent(s), spec)` builds a
  *  complement-carrying lens. */
 export declare function lens<P, R>(parent: Read<P>, fwd: (v: P) => R, bwd: (target: R, v: P) => P): Writable<Cell<R>>;
-export declare function lens<P extends readonly Read<unknown>[], R>(parents: P, fwd: (vals: {
-    [K in keyof P]: P[K] extends Read<infer V> ? V : never;
+export declare function lens<P extends readonly Read<unknown>[], R>(parents: P, fwd: (vals: ReadValues<P>) => R, bwd: (target: R, vals: ReadValues<P>) => ReadValuesOrSkip<P>): Writable<Cell<R>>;
+export declare function lens<S extends Record<string, Read<unknown>>, R>(parents: S, fwd: (vals: {
+    [K in keyof S]: Inner<S[K]>;
 }) => R, bwd: (target: R, vals: {
-    [K in keyof P]: P[K] extends Read<infer V> ? V : never;
-}) => {
-    [K in keyof P]?: P[K] extends Read<infer V> ? V : never;
-}): Writable<Cell<R>>;
-export declare function lens<P, R, C>(parent: Read<P>, spec: StatefulLensSpec<readonly [P], R, C>): Writable<Cell<R>>;
-export declare function lens<P extends readonly Read<unknown>[], R, C>(parents: P, spec: StatefulLensSpec<{
-    [K in keyof P]: P[K] extends Read<infer V> ? V : never;
-}, R, C>): Writable<Cell<R>>;
+    [K in keyof S]: Inner<S[K]>;
+}) => Partial<{
+    [K in keyof S]: Inner<S[K]> | Skip;
+}>): Writable<Cell<R>>;
+export declare function lens<P, R, C>(parent: Read<P>, spec: StatefulLensSpec1<P, R, C>): Writable<Cell<R>>;
+export declare function lens<P extends readonly Read<unknown>[], R, C>(parents: P, spec: StatefulLensSpec<ReadValues<P>, R, C>): Writable<Cell<R>>;
 export declare function effect(fn: () => (() => void) | void): () => void;
+/** Run all pending effects now, synchronously — the escape hatch for code that
+ *  must observe effect side-effects before yielding. Reads never need it. */
+export declare function settle(): void;
+/** Group writes and flush effects synchronously at the end of `fn`. Effects
+ *  coalesce on the microtask turn anyway; reach for `batch` only to run the woken
+ *  effects before the call returns. */
 export declare function batch<R>(fn: () => R): R;
 export declare function untracked<R>(fn: () => R): R;
 /** Handle to a `network` invocation. */
@@ -244,34 +309,28 @@ export interface Network {
     /** Remove cells from the topology (idempotent; does NOT fire). */
     unsubscribe(...cells: Cell<any>[]): void;
 }
-/** Build a reactive sub-DAG node with explicit topology. The body fires
- *  when any subscribed dep changes (`dirty` = the changed subset), runs
- *  inside `batch()`, and self-excludes its own writes. Topology is the
- *  deps array + later subscribe/unsubscribe (body reads add no deps).
- *  `flush()` from inside the body throws; `manual: true` defers
- *  auto-firing so only `flush()` advances. */
-export declare function network(deps: readonly Cell<any>[], body: (dirty: ReadonlySet<Cell<unknown>>, handle: Network) => void, opts?: {
+type NetworkBody = (dirty: ReadonlySet<Cell<unknown>>, handle: Network) => void;
+/** Build a reactive sub-DAG. The body fires when any subscribed dep changes
+ *  (`dirty` = the changed subset), self-excludes its own writes, and (auto mode)
+ *  resolves synchronously. `manual: true` defers firing so only `flush()` advances;
+ *  `flush()` from inside the body throws. Network-specific state (last-values,
+ *  handle) lives in this closure, so the shared `Effect` carries none of it. */
+export declare function network(deps: readonly Cell<any>[], body: NetworkBody, opts?: {
     manual?: boolean;
 }): Network;
-/** Bidirectional field lens onto `parent.value[key]`; write spread-
- *  replaces the composite. Cached per (instance, key). Return type is
- *  conditional: `Writable<Cls>` on a writable parent, bare `Cls` on RO.
+/** Bidirectional field lens onto `parent.value[key]` (write spread-replaces),
+ *  cached per (instance, key). `Writable<Cls>` on a writable parent, bare `Cls` on RO.
  *
- *      get x() { return field(this, "x", Num); } */
-export declare function field<S extends Cell<any>, K extends keyof Inner<S>, C extends new (...args: never[]) => Cell<Inner<S>[K]>>(parent: S, key: K, Cls: C): S extends WritableBrand ? Writable<InstanceType<C>> : InstanceType<C>;
+ *      get x() { return fieldLens(this, "x", Num); } */
+export declare function fieldLens<S extends Cell<any>, K extends keyof Inner<S>, C extends new (...args: never[]) => Cell<Inner<S>[K]>>(parent: S, key: K, Cls: C): S extends WritableBrand ? Writable<InstanceType<C>> : InstanceType<C>;
 /** Read-only derived view via `Cls.derive(parent, fn)`, memoized per
- *  (instance, key); always bare `Cls` (RO). The cache is the point — the
- *  getter form, not a new kind of cell.
+ *  (instance, key). The cache is the point.
  *
  *      get magnitude() {
  *        return cachedDerive(this, "magnitude", Num, v => Math.hypot(v.x, v.y));
  *      } */
-export declare function cachedDerive<S extends Cell<any>, C extends new (...args: never[]) => Cell<any>>(parent: S, key: string | symbol, Cls: C, fn: (v: Inner<S>) => Inner<InstanceType<C>>): InstanceType<C>;
-/** Every cell `s` transitively depends on, including itself. Raw cells
- *  return `{s}`; lens chains return the chain plus all parents. BFS,
- *  peeking each Computed to populate deps; the `seen` set breaks cycles.
- *  Used by `Propagators` to expand declared reads into their transitive
- *  parent set. Inspection is safe: it only reads engine state and peeks
- *  `.value` (idempotent for lazy Computeds). */
+export declare function cachedDerive<S extends Cell<any>, C extends AnyCellCtor>(parent: S, key: string | symbol, Cls: C, fn: (v: Inner<S>) => Inner<InstanceType<C>>): InstanceType<C>;
+/** Every cell `s` transitively depends on, including itself (BFS, peeking each
+ *  computed to populate deps; `seen` breaks cycles). */
 export declare function transitiveDeps(s: Cell<unknown>): Set<Cell<unknown>>;
 export {};