bireactive 0.3.0 → 0.3.2

package/dist/core/cell.d.ts

@@ -1,19 +1,3 @@
-/** Multi-out / stateful back-write sentinel: "leave this parent untouched."
- *  A `bwd` returning per-parent updates yields `SKIP` for a parent it declines
- *  to write; every other slot value is written verbatim — INCLUDING `undefined`,
- *  which is a first-class cell value, not a hole. A SHORT array skips the trailing
- *  parents (so writing only the leading few needs no `SKIP` padding); `[]` skips
- *  all. (Single-out 1→1 `put` has no skip notion: it always writes its one parent,
- *  so it stays `undefined`-safe by construction.) */
-export declare const SKIP: unique symbol;
-export type Skip = typeof SKIP;
-/** Per-parent back-write result over parents `T`: any PREFIX of the full update
- *  tuple. A shorter array skips the trailing parents; each present slot is a
- *  value or `SKIP`. For a fixed tuple this is the prefix union, so `[a]` /
- *  `[a, SKIP]` / `[]` all type against `[A, B]` while a bare `undefined` in a
- *  non-undefined slot stays an error (the footgun the `SKIP`/short-array split
- *  removes); for a variable-length array of parents it's just that array. */
-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 [];
 interface ReactiveNode {
     flags: number;
     deps: Link | undefined;
@@ -33,50 +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 type MergeFold<T> = (values: readonly T[]) => T;
 declare class MergeNode<T> {
     readonly foldFn: MergeFold<T> | undefined;
-    /** Contributions gathered as this merge's cone resolves; folded and cleared
-     *  in `foldMerge` (the merge-owned buffer, mutated in place). The parent it
-     *  writes to is just `b.parent` (a merge's `b.parent` IS its fold target), so
-     *  this node carries only the policy + buffer — no duplicate edge. */
+    /** 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`). A 1→1 / multi-out
-     *  lens is called as `put(target)` (a source-reading lens reads the current
-     *  parent(s) at walk time, untracked); multi-out returns a per-parent update
-     *  array. Stateful is the spec's `bwd`, called `put(target, sources, c)`. */
+    /** 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;
+    /** `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;
-    /** Advance the complement: `step(sources, complement, external)`. (The
-     *  forward projection `fwd` is captured directly in the getter closure — it
-     *  is only ever read there — so it costs no slot here.) */
-    step: (sources: any, complement: any, external: boolean) => any;
-    /** Sources this lens last committed back (the own-vs-external test compares
-     *  live sources against these); `undefined` until the first back-write. A
-     *  back-write reads the live sources into a fresh array, builds the committed
-     *  candidate in place, and keeps it as `last` for the next own-vs-external
-     *  comparison. */
-    last: unknown[] | undefined;
-    constructor(complement: unknown, 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. */
@@ -97,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. */
@@ -116,6 +126,19 @@ 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 */
@@ -142,12 +165,27 @@ export declare class Cell<T = unknown> implements ReactiveNode {
     pendingValue: T;
     /** @internal Backward sidecar; `undefined` iff read-only. Writability is `_bwd !== undefined`. */
     _bwd: BwdSpec | undefined;
-    /** @internal Backward dual of `subs`: direct lens-children for back-write cone traversal. */
-    _lensSubs: Cell<unknown>[] | 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 Guards against `linkBack` re-registering a duplicate in `_lensSubs`. */
-    _linkedBack: boolean;
+    /** @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;
     /** @internal Single write-commit point; self-excludes the active network. */
@@ -165,48 +203,42 @@ export declare class Cell<T = unknown> implements ReactiveNode {
     /** 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 fan-in node. Forward, the identity view of its parent;
-     *  backward, the convergence point where N contributors (upstream lenses
-     *  and direct writes) fold into one value for the parent. `fold` is handed
-     *  every live push at once; omitted, it is last-writer-wins. */
+    /** 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: forwards its parent's value unchanged; on write, folds N
+     *  contributors 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;
-    }) => BackUpdates<{
-        [K in keyof P]: (P[K] extends Read<infer V> ? V : never) | Skip;
-    }>): 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>;
+    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 coerce<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>>;
+    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 new (...args: never[]) => Cell<any>>(parent: Cell<any>, key: string | number | symbol, Cls: C): InstanceType<C>;
+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> {
     /** Per-parent updates: a value (written verbatim, `undefined` included) or
      *  `SKIP` to leave that parent. A short array skips the trailing parents. */
@@ -217,43 +249,53 @@ export interface StatefulBwd<S extends readonly unknown[], 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) | Skip;
-}): 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 (tests,
- *  imperative call sites) that must observe effect side-effects before yielding
- *  to the microtask queue. Reads never need it — they pull current values. */
+/** 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` — a sync
- *  barrier. Effects coalesce on the microtask turn anyway (see `schedule`), so
- *  `batch` is no longer needed for that; reach for it only when you must run the
- *  woken effects before the call returns (and don't want a `settle()`). */
+/** 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. */
@@ -267,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 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).
  *
  *      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 {};