bireactive 0.2.0 → 0.2.2

package/dist/core/{signal.js → cell.js}

@@ -1,4 +1,4 @@
-// signal.ts — symmetric bidirectional reactive engine.
+// cell.ts — symmetric bidirectional reactive engine.
 //
 // Forward propagation is alien-signals verbatim (link/propagate/
 // checkDirty/shallowPropagate, Dirty/Pending/Recursed flags, lazy pull).
@@ -25,7 +25,7 @@
 //
 // Mode table — a cell's role is fully determined by which fields are set:
 //   source      getter undefined                 (truth in currentValue)
-//   computed    getter, no _bwd                   (read-only derived)
+//   derived    getter, no _bwd                   (read-only derived)
 //   lens 1→1    getter + _bwd{ put, parent: Cell }
 //   multi-out   getter + _bwd{ put, parent: Cell[] }   (1→N / N→M bwd)
 //   merge       getter + _bwd{ merge }            (N→1 backward fold)
@@ -411,8 +411,8 @@ export function lazy(self, key, make) {
 export const isCell = (v) => v instanceof Cell;
 /** Lens mode: a derived cell that can be written back (has a backward sidecar). */
 export const isLens = (v) => v instanceof Cell && v.getter !== undefined && v._bwd !== undefined;
-/** Computed mode: derived + read-only (no backward path). */
-export const isComputed = (v) => v instanceof Cell && v.getter !== undefined && v._bwd === undefined;
+/** Read-only mode: derived with no backward path. */
+export const isReadonly = (v) => v instanceof Cell && v.getter !== undefined && v._bwd === undefined;
 export class Cell {
     flags = F.Mutable;
     subs;
@@ -540,6 +540,11 @@ export class Cell {
     lens(fwd, bwd) {
         return buildLens1(this.constructor, this, fwd, bwd, bwd.length >= 2);
     }
+    /** 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(fn) {
+        return buildDerived(this.constructor, () => fn(this.value));
+    }
     /** 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). */
@@ -558,22 +563,11 @@ export class Cell {
     }
     // biome-ignore lint/suspicious/noExplicitAny: dispatch
     static derive(...args) {
-        if (args.length === 1)
-            return buildComputed(this, args[0]);
-        const [parent, fn] = args;
-        if (Array.isArray(parent))
-            return buildLensN(this, parent, fn, undefined, false);
-        return buildComputed(this, () => fn(parent.value));
+        return dispatchDerive(this, args);
     }
     // biome-ignore lint/suspicious/noExplicitAny: dispatch
     static lens(...args) {
-        const [parent, a, b] = args;
-        if (args.length === 2)
-            return buildStateful(this, Array.isArray(parent) ? parent : [parent], a);
-        const readsSource = b.length >= 2;
-        if (Array.isArray(parent))
-            return buildLensN(this, parent, a, b, readsSource);
-        return buildLens1(this, parent, a, b, readsSource);
+        return dispatchLens(this, args);
     }
     /** Type predicate against this class: `Vec.is(x)` narrows `x` to `Vec`.
      *  Inherited static; works for any subclass via polymorphic `this`. */
@@ -616,14 +610,14 @@ export class Cell {
         // Read-only ⇔ computed: a getter with no backward sidecar.
         const ro = parent.getter !== undefined && parent._bwd === undefined;
         if (ro) {
-            return buildComputed(ctor, () => get(parent.value));
+            return buildDerived(ctor, () => get(parent.value));
         }
         // Spread-replace reads the current source ⇒ source-reading (lens) form.
         return buildLens1(ctor, parent, get, (v, s) => ({ ...s, [key]: v }), true);
     }
 }
 // biome-ignore lint/suspicious/noExplicitAny: variance escape
-function buildComputed(Cls, getter) {
+function buildDerived(Cls, getter) {
     const cell = new Cls();
     cell.getter = getter;
     cell.flags = F.Mutable | F.Dirty;
@@ -701,7 +695,58 @@ spec) {
     });
     return cell;
 }
-// Install `value` on the prototype (V8 JITs it better than a class get/set).
+// Single-source stateful lens: the `buildLens1` of the complement path.
+// Drops the per-read copy/external loops to direct index-0 access; the
+// spec stays array-shaped (`init: ([s]) => …`), so a reused length-1
+// `vals` still feeds the closures and `b.parent` stays an array for the
+// shared split backward path.
+// biome-ignore lint/suspicious/noExplicitAny: variance escape
+function buildStateful1(Cls, parent, 
+// biome-ignore lint/suspicious/noExplicitAny: opaque spec
+spec) {
+    const cell = new Cls();
+    cell.flags = F.Mutable | F.Dirty;
+    const b = (cell._bwd = new BwdSpec());
+    const sc = (b.stateful = new StatefulCore(spec.init([parent.peek()]), spec.fwd, spec.step));
+    b.put = spec.bwd;
+    b.parent = [parent];
+    const vals = [undefined];
+    cell.getter = (() => {
+        const v = (vals[0] = parent.value);
+        const lb = sc.lastBwd;
+        const external = lb === undefined || lb[0] !== v;
+        sc.complement = sc.step(vals, sc.complement, external);
+        return sc.fwd(vals, sc.complement);
+    });
+    return cell;
+}
+// Shared runtime dispatch for `derive`/`lens`, parameterized by the cell
+// constructor: the polymorphic-`this` statics pass the typed subclass
+// (`Vec.derive` → Vec), the free functions pass the plain `Cell`. One body
+// each so the static and free forms can't drift (typed overloads live at
+// the call sites; only these `any` runtime bodies are shared).
+// biome-ignore lint/suspicious/noExplicitAny: dispatch
+function dispatchDerive(ctor, args) {
+    if (args.length === 1)
+        return buildDerived(ctor, args[0]);
+    const [parent, fn] = args;
+    if (Array.isArray(parent))
+        return buildLensN(ctor, parent, fn, undefined, false);
+    return buildDerived(ctor, () => fn(parent.value));
+}
+// biome-ignore lint/suspicious/noExplicitAny: dispatch
+function dispatchLens(ctor, args) {
+    const [parent, a, b] = args;
+    if (args.length === 2) {
+        const ps = Array.isArray(parent) ? parent : [parent];
+        return ps.length === 1 ? buildStateful1(ctor, ps[0], a) : buildStateful(ctor, ps, a);
+    }
+    const readsSource = b.length >= 2;
+    if (Array.isArray(parent))
+        return buildLensN(ctor, parent, a, b, readsSource);
+    return buildLens1(ctor, parent, a, b, readsSource);
+}
+// Install `value` on the prototype (for silly TypeScript inference reasons I'd like to avoid if we can figure it out).
 Object.defineProperty(Cell.prototype, "value", {
     get() {
         const flags = this.flags;
@@ -986,35 +1031,17 @@ export function cell(initial, opts) {
         return initial;
     return new Cell(initial, opts);
 }
-export function computed(fn) {
-    const cell = new Cell(undefined);
-    cell.flags = F.Mutable | F.Dirty;
-    cell.getter = fn;
-    return cell;
-}
 // Bare (untyped) factories. Construct a plain `Cell`, inferring `R`
 // from the closures (the polymorphic-`this` statics are for typed
 // subclasses like `Vec.lens`).
 const CELL_CTOR = Cell;
 // biome-ignore lint/suspicious/noExplicitAny: dispatch
 export function derive(...args) {
-    if (args.length === 1)
-        return buildComputed(CELL_CTOR, args[0]);
-    const [parent, fn] = args;
-    if (Array.isArray(parent))
-        return buildLensN(CELL_CTOR, parent, fn, undefined, false);
-    return buildComputed(CELL_CTOR, () => fn(parent.value));
+    return dispatchDerive(CELL_CTOR, args);
 }
 // biome-ignore lint/suspicious/noExplicitAny: dispatch
 export function lens(...args) {
-    const [parent, a, b] = args;
-    if (args.length === 2) {
-        return buildStateful(CELL_CTOR, Array.isArray(parent) ? parent : [parent], a);
-    }
-    const readsSource = b.length >= 2;
-    if (Array.isArray(parent))
-        return buildLensN(CELL_CTOR, parent, a, b, readsSource);
-    return buildLens1(CELL_CTOR, parent, a, b, readsSource);
+    return dispatchLens(CELL_CTOR, args);
 }
 // Effect — alien-signals verbatim.
 class Effect {
@@ -1240,11 +1267,11 @@ class _NetworkNode {
     }
     _computeDirty() {
         let dirty;
-        for (const [sig, lastVal] of this.lastValues) {
-            if (sig.peek() !== lastVal) {
+        for (const [cell, lastVal] of this.lastValues) {
+            if (cell.peek() !== lastVal) {
                 if (dirty === undefined)
                     dirty = new Set();
-                dirty.add(sig);
+                dirty.add(cell);
             }
         }
         return dirty ?? EMPTY_DIRTY;
@@ -1273,8 +1300,8 @@ class _NetworkNode {
             this.lastValues.clear();
             let l = this.deps;
             while (l !== undefined) {
-                const sig = l.dep;
-                this.lastValues.set(sig, sig.peek());
+                const cell = l.dep;
+                this.lastValues.set(cell, cell.peek());
                 l = l.nextDep;
             }
         }
@@ -1289,16 +1316,16 @@ class _NetworkNode {
         }
         this._runBody(this._computeDirty());
     }
-    subscribe(sigs) {
+    subscribe(cells) {
         if (this.disposed)
             return;
-        this._linkBatch(sigs);
+        this._linkBatch(cells);
     }
-    unsubscribe(sigs) {
+    unsubscribe(cells) {
         if (this.disposed)
             return;
         const set = this._depsSet;
-        for (const s of sigs) {
+        for (const s of cells) {
             if (!set.has(s))
                 continue;
             set.delete(s);
@@ -1312,7 +1339,7 @@ class _NetworkNode {
             }
         }
     }
-    _linkBatch(sigs) {
+    _linkBatch(cells) {
         const set = this._depsSet;
         let tail = this.deps;
         if (tail !== undefined) {
@@ -1320,7 +1347,7 @@ class _NetworkNode {
                 tail = tail.nextDep;
         }
         this.depsTail = tail;
-        for (const s of sigs) {
+        for (const s of cells) {
             if (set.has(s))
                 continue;
             set.add(s);
@@ -1341,9 +1368,63 @@ deps, body, opts) {
     const handle = {
         dispose: () => node._unwatched(),
         flush: () => node.flush(),
-        subscribe: (...sigs) => node.subscribe(sigs),
-        unsubscribe: (...sigs) => node.unsubscribe(sigs),
+        subscribe: (...cells) => node.subscribe(cells),
+        unsubscribe: (...cells) => node.unsubscribe(cells),
     };
     node._initWithHandle(handle, deps);
     return handle;
 }
+// MISC stuff used by a few places, to revisit...
+// ── value-class authoring helpers ──────────────────────────────────
+//
+// `field`/`cachedDerive` are the two getter forms a value class declares.
+// The choice between them IS the local declaration of writability at each
+// getter (mirroring `: this` invertible method returns). For arbitrary
+// cached views, use `lazy()` directly.
+/** 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.
+ *
+ *      get x() { return field(this, "x", Num); } */
+export function field(parent, key, Cls) {
+    return lazy(parent, key, () => Cell.fieldOf(parent, key, Cls));
+}
+/** 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.
+ *
+ *      get magnitude() {
+ *        return cachedDerive(this, "magnitude", Num, v => Math.hypot(v.x, v.y));
+ *      } */
+// biome-ignore lint/suspicious/noExplicitAny: variance escape, mirrors Cls.derive
+export function cachedDerive(parent, key, Cls, fn) {
+    // biome-ignore lint/suspicious/noExplicitAny: variance escape on Cls.derive
+    return lazy(parent, key, () => Cls.derive(parent, fn));
+}
+/** 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 function transitiveDeps(s) {
+    const seen = new Set();
+    const queue = [s];
+    while (queue.length > 0) {
+        const cur = queue.shift();
+        if (seen.has(cur))
+            continue;
+        seen.add(cur);
+        // Cast to reach engine fields the typed Cell<T> shape doesn't surface.
+        const c = cur;
+        if (c.getter !== undefined) {
+            void cur.value;
+            let l = c.deps;
+            while (l !== undefined) {
+                queue.push(l.dep);
+                l = l.nextDep;
+            }
+        }
+    }
+    return seen;
+}

package/dist/core/derived-geometry.d.ts

@@ -0,0 +1,11 @@
+import type { Cell } from "./cell.js";
+import { Vec } from "./values/vec.js";
+type V = {
+    x: number;
+    y: number;
+};
+/** Quadratic Bézier point at parameter `t`. RO. */
+export declare function bezier2(p0: Cell<V>, p1: Cell<V>, p2: Cell<V>, t: Cell<number>): Vec;
+/** Cubic Bézier point at parameter `t`. RO. */
+export declare function bezier3(p0: Cell<V>, p1: Cell<V>, p2: Cell<V>, p3: Cell<V>, t: Cell<number>): Vec;
+export {};

package/dist/core/derived-geometry.js

@@ -0,0 +1,32 @@
+// derived-geometry.ts — read-only geometric readouts over `Cls.derive`.
+//
+// One-way derives whose inverse is genuinely under-determined (a point
+// sampled at parameter `t` constrains the curve at one point, but the
+// control points have many DOF). They live here, off the lens surface,
+// to keep `lenses/` exclusively bidirectional. For the writable bezier
+// shape decomposition see `bezierGestalt` in `lenses/domain-aggregates`.
+import { Vec } from "./values/vec.js";
+/** Quadratic Bézier point at parameter `t`. RO. */
+export function bezier2(p0, p1, p2, t) {
+    return Vec.derive([p0, p1, p2, t], vals => {
+        const [a, b, c, tv] = vals;
+        const u = 1 - tv;
+        return {
+            x: u * u * a.x + 2 * u * tv * b.x + tv * tv * c.x,
+            y: u * u * a.y + 2 * u * tv * b.y + tv * tv * c.y,
+        };
+    });
+}
+/** Cubic Bézier point at parameter `t`. RO. */
+export function bezier3(p0, p1, p2, p3, t) {
+    return Vec.derive([p0, p1, p2, p3, t], vals => {
+        const [a, b, c, d, tv] = vals;
+        const u = 1 - tv;
+        const u2 = u * u;
+        const t2 = tv * tv;
+        return {
+            x: u2 * u * a.x + 3 * u2 * tv * b.x + 3 * u * t2 * c.x + t2 * tv * d.x,
+            y: u2 * u * a.y + 3 * u2 * tv * b.y + 3 * u * t2 * c.y + t2 * tv * d.y,
+        };
+    });
+}

package/dist/core/index.d.ts

@@ -1,25 +1,21 @@
-export { argminNum, argminVec, centroidLens, clampToDisc, meanLens, midpointLens, } from "./aggregates.js";
-export { type Animatable, attract, driven, every, loop, not, type Play, play, type SpringOpts, spring, Tween, toward, tween, untilChange, wave, when, } from "./anim.js";
-export { transitiveDeps } from "./introspect.js";
+export { batch, Cell, type CellOptions, cachedDerive, cell, derive, effect, field, type Init, type Inner, isCell, isLens, isReadonly, lazy, lens, type Network, network, type Read, reader, readNow, type StatefulBwd, type StatefulLensSpec, setCellWriteHook, transitiveDeps, untracked, type Val, type Writable, type WritableBrand, } from "./cell.js";
+export { bezier2, bezier3 } from "./derived-geometry.js";
 export * from "./lenses/index.js";
-export { each, type Lifecycle } from "./network-utils.js";
-export { reflectionLens } from "./new-primitives.js";
-export { batch, Cell, type CellOptions, cell, derive, effect, type Init, type Inner, isCell, isComputed, isLens, lazy, lens, type Network, network, type Read, reader, readNow, type StatefulBwd, type StatefulLensSpec, setCellWriteHook, untracked, type Val, type Writable, type WritableBrand, } from "./signal.js";
+export { each, type Lifecycle } from "./lifecycle.js";
 export { type Equals, type Lerp, type Linear, type Metric, type Pack, type Pivotal, requireEquals, requireLerp, requireLinear, requireMetric, requirePack, requirePivotal, type TraitDict, type Traits, } from "./traits.js";
-export { allNodes, atPath, isLeaf, leavesOf, node as treeNode, nodeCount, type TreeNode, walkTree, } from "./tree.js";
 export { Anchor, Dir } from "./values/anchor.js";
 export { Audio, type AudioClip, audio, stamp as audioStamp } from "./values/audio.js";
 export * as BoolMath from "./values/bool.js";
 export { Bool, bool } from "./values/bool.js";
 export * as BoxMath from "./values/box.js";
-export { Box, box, edgeFrom, union as boxUnion } from "./values/box.js";
+export { Box, box } from "./values/box.js";
 export { Canvas, canvas, type Raster, stamp as canvasStamp } from "./values/canvas.js";
 export * as ColorMath from "./values/color.js";
 export { Color, rgb, rgba } from "./values/color.js";
 export { Flags, flags } from "./values/flags.js";
 export { blit as gpuBlit, brush as gpuBrush, copy as gpuCopy, newTex as gpuNewTex, Spring, scratch2 as gpuScratch2, type Tex, } from "./values/gpu.js";
 export * as MatrixMath from "./values/matrix.js";
-export { compose, determinant, fromRotate, fromScale, fromTranslate, identity, invert, isIdentity, Matrix, matrix, multiply, toMatrixString, transformBox, transformPoint, } from "./values/matrix.js";
+export { Matrix, matrix, transformBox, transformPoint } from "./values/matrix.js";
 export * as NumMath from "./values/num.js";
 export { Num, num } from "./values/num.js";
 export * as PoseMath from "./values/pose.js";
@@ -35,4 +31,3 @@ export * as TriMath from "./values/tri.js";
 export { Tri, tri } from "./values/tri.js";
 export * as VecMath from "./values/vec.js";
 export { type PolarPolicy, polar, tangentPoint, Vec, vec } from "./values/vec.js";
-export { derived, field } from "./writable.js";

package/dist/core/index.js

@@ -1,25 +1,21 @@
-export { argminNum, argminVec, centroidLens, clampToDisc, meanLens, midpointLens, } from "./aggregates.js";
-export { attract, driven, every, loop, not, play, spring, Tween, toward, tween, untilChange, wave, when, } from "./anim.js";
-export { transitiveDeps } from "./introspect.js";
+export { batch, Cell, cachedDerive, cell, derive, effect, field, isCell, isLens, isReadonly, lazy, lens, network, reader, readNow, setCellWriteHook, transitiveDeps, untracked, } from "./cell.js";
+export { bezier2, bezier3 } from "./derived-geometry.js";
 export * from "./lenses/index.js";
-export { each } from "./network-utils.js";
-export { reflectionLens } from "./new-primitives.js";
-export { batch, Cell, cell, derive, effect, isCell, isComputed, isLens, lazy, lens, network, reader, readNow, setCellWriteHook, untracked, } from "./signal.js";
+export { each } from "./lifecycle.js";
 export { requireEquals, requireLerp, requireLinear, requireMetric, requirePack, requirePivotal, } from "./traits.js";
-export { allNodes, atPath, isLeaf, leavesOf, node as treeNode, nodeCount, walkTree, } from "./tree.js";
 export { Anchor, Dir } from "./values/anchor.js";
 export { Audio, audio, stamp as audioStamp } from "./values/audio.js";
 export * as BoolMath from "./values/bool.js";
 export { Bool, bool } from "./values/bool.js";
 export * as BoxMath from "./values/box.js";
-export { Box, box, edgeFrom, union as boxUnion } from "./values/box.js";
+export { Box, box } from "./values/box.js";
 export { Canvas, canvas, stamp as canvasStamp } from "./values/canvas.js";
 export * as ColorMath from "./values/color.js";
 export { Color, rgb, rgba } from "./values/color.js";
 export { Flags, flags } from "./values/flags.js";
 export { blit as gpuBlit, brush as gpuBrush, copy as gpuCopy, newTex as gpuNewTex, Spring, scratch2 as gpuScratch2, } from "./values/gpu.js";
 export * as MatrixMath from "./values/matrix.js";
-export { compose, determinant, fromRotate, fromScale, fromTranslate, identity, invert, isIdentity, Matrix, matrix, multiply, toMatrixString, transformBox, transformPoint, } from "./values/matrix.js";
+export { Matrix, matrix, transformBox, transformPoint } from "./values/matrix.js";
 export * as NumMath from "./values/num.js";
 export { Num, num } from "./values/num.js";
 export * as PoseMath from "./values/pose.js";
@@ -35,4 +31,3 @@ export * as TriMath from "./values/tri.js";
 export { Tri, tri } from "./values/tri.js";
 export * as VecMath from "./values/vec.js";
 export { polar, tangentPoint, Vec, vec } from "./values/vec.js";
-export { derived, field } from "./writable.js";

package/dist/core/{aggregates.d.ts → lenses/aggregates.d.ts}

@@ -1,16 +1,6 @@
-import type { Cell, Writable } from "./signal.js";
-import { Num } from "./values/num.js";
-import { Vec } from "./values/vec.js";
-type V = {
-    x: number;
-    y: number;
-};
-/** Equal-weight mean of N Linear values; writes distribute the delta evenly. */
-export declare function meanLens<T, C extends new (...args: never[]) => Cell<any>>(Cls: C, parents: readonly Cell<T>[]): Writable<InstanceType<C>>;
-/** Midpoint of two writable Vecs. Drag-translates both endpoints. */
-export declare function midpointLens(a: Cell<V>, b: Cell<V>): Writable<Vec>;
-/** Centroid of N writable Vecs. Drag-translates all members. */
-export declare function centroidLens(parents: readonly Cell<V>[]): Writable<Vec>;
+import type { Writable } from "../cell.js";
+import { Num } from "../values/num.js";
+import { Vec } from "../values/vec.js";
 export interface ArgminOpts {
     /** Finite-difference epsilon for the Jacobian. Default 1e-4. */
     eps?: number;
@@ -61,4 +51,3 @@ export declare function argminVec(inputs: readonly Num[], forward: (xs: readonly
     x: number;
     y: number;
 }, weights: readonly number[], opts?: ArgminVecOpts): Writable<Vec>;
-export {};

package/dist/core/{aggregates.js → lenses/aggregates.js}

@@ -1,85 +1,12 @@
-// aggregates.ts — N→1 aggregate lens primitives over `Cls.lens` /
-// `Cls.derive`.
+// aggregates.ts — numerical N→1 / N→M argmin lens primitives over
+// `Cls.lens`. For the closed-form equal-weight `mean` and `spread`
+// aggregates see `domain-aggregates.ts`.
 //
 // All route through the engine's N-input lens path. Stateless-bwd
 // (`(target) => updates`) skips the peek loop on the hot path;
 // stateful-bwd (`(target, vals) => updates`) reads the scratch.
-import { Num } from "./values/num.js";
-import { Vec } from "./values/vec.js";
-/** Equal-weight mean of N Linear values; writes distribute the delta evenly. */
-// biome-ignore lint/suspicious/noExplicitAny: variance escape, mirrors Cls.lens
-export function meanLens(Cls, parents) {
-    const lin = (Cls.traits?.linear ??
-        (() => {
-            throw new Error("meanLens: value class has no 'linear' trait");
-        })());
-    const n = parents.length;
-    const inv = 1 / n;
-    // biome-ignore lint/suspicious/noExplicitAny: variance escape on Cls.lens
-    return Cls.lens(parents, 
-    // biome-ignore lint/suspicious/noExplicitAny: tuple-vs-array variance
-    (vals) => {
-        let acc = vals[0];
-        for (let i = 1; i < n; i++)
-            acc = lin.add(acc, vals[i]);
-        return lin.scale(acc, inv);
-    }, 
-    // biome-ignore lint/suspicious/noExplicitAny: tuple-vs-array variance
-    (target, vals) => {
-        let cur = vals[0];
-        for (let i = 1; i < n; i++)
-            cur = lin.add(cur, vals[i]);
-        cur = lin.scale(cur, inv);
-        const delta = lin.sub(target, cur);
-        const out = new Array(n);
-        for (let i = 0; i < n; i++)
-            out[i] = lin.add(vals[i], delta);
-        return out;
-    });
-}
-/** Midpoint of two writable Vecs. Drag-translates both endpoints. */
-export function midpointLens(a, b) {
-    return Vec.lens([a, b], vals => {
-        const [av, bv] = vals;
-        return { x: (av.x + bv.x) / 2, y: (av.y + bv.y) / 2 };
-    }, (target, vals) => {
-        const [av, bv] = vals;
-        const dx = target.x - (av.x + bv.x) / 2;
-        const dy = target.y - (av.y + bv.y) / 2;
-        return [
-            { x: av.x + dx, y: av.y + dy },
-            { x: bv.x + dx, y: bv.y + dy },
-        ];
-    });
-}
-/** Centroid of N writable Vecs. Drag-translates all members. */
-export function centroidLens(parents) {
-    const n = parents.length;
-    const inv = 1 / n;
-    return Vec.lens(parents, vals => {
-        const arr = vals;
-        let sx = 0, sy = 0;
-        for (let i = 0; i < n; i++) {
-            sx += arr[i].x;
-            sy += arr[i].y;
-        }
-        return { x: sx * inv, y: sy * inv };
-    }, (target, vals) => {
-        const arr = vals;
-        let sx = 0, sy = 0;
-        for (let i = 0; i < n; i++) {
-            sx += arr[i].x;
-            sy += arr[i].y;
-        }
-        const dx = target.x - sx * inv;
-        const dy = target.y - sy * inv;
-        const out = new Array(n);
-        for (let i = 0; i < n; i++) {
-            out[i] = { x: arr[i].x + dx, y: arr[i].y + dy };
-        }
-        return out;
-    });
-}
+import { Num } from "../values/num.js";
+import { Vec } from "../values/vec.js";
 /** Project `p` into the closed disc of radius `r` centred on `c` (points
  *  inside pass through). Use as `argminVec`'s `clampTarget` to fix IK
  *  explosion at maximum reach. */

package/dist/core/lenses/closed-form-policies.d.ts

@@ -4,7 +4,7 @@ type V = {
     y: number;
 };
 /** Writable centroid; on write, translates every point by the delta.
- *  Alias of `centroidLens` under the "policy" naming. */
+ *  The Vec-specific group-action reading of `mean`. */
 export declare function rigidTranslate(points: readonly Writable<Vec>[]): Writable<Vec>;
 /** Writable angle from `pivot` to `points[0]`; write rotates every input
  *  about `pivot` by (target − current) via its `Pivotal` trait.
@@ -12,7 +12,7 @@ export declare function rigidTranslate(points: readonly Writable<Vec>[]): Writab
  *  Trait-generic: Vec rotates position; Pose rotates position AND
  *  orientation. Rotation-about-pivot fixes the pivot and preserves radial
  *  distances, so scale-about-pivot reads unchanged. `pivot` is reactive
- *  (re-read per write); pass `centroidLens(points)` for rotation about
+ *  (re-read per write); pass `rigidTranslate(points)` for rotation about
  *  the cluster's own centroid. */
 export declare function rotateAbout<T extends {
     x: number;
@@ -35,22 +35,15 @@ export declare function scaleAbout<T extends {
  *  point 0's offset, so a per-axis collapse is recoverable (cf.
  *  `bboxLens.size`). */
 export declare function scaleAboutXY(points: readonly Writable<Vec>[], pivot: Read<V>): Writable<Vec>;
-/** Same semantics as `factor-lens.ts`'s `procrustesLens`, decomposed
- *  into three building-block lenses sharing a centroid. */
-export declare function procrustesViaBuildingBlocks(points: readonly Writable<Vec>[]): {
-    centroid: Writable<Vec>;
-    rotation: Writable<Num>;
-    scale: Writable<Num>;
-};
-export declare function bestFitLineLens(points: readonly Writable<Vec>[]): {
+export declare function bestFitLine(points: readonly Writable<Vec>[]): {
     point: Writable<Vec>;
     direction: Writable<Num>;
 };
-export declare function bestFitCircleLens(points: readonly Writable<Vec>[]): {
+export declare function bestFitCircle(points: readonly Writable<Vec>[]): {
     center: Writable<Vec>;
     radius: Writable<Num>;
 };
-export declare function pcaLens(points: readonly Writable<Vec>[]): {
+export declare function pca(points: readonly Writable<Vec>[]): {
     mean: Writable<Vec>;
     rotation: Writable<Num>;
     majorLength: Writable<Num>;
@@ -60,5 +53,5 @@ export declare function pcaLens(points: readonly Writable<Vec>[]): {
  *  preserving their ratios. A `remember` anchored at zero with a signed
  *  sum feature: a collapse to zero reinflates the stored ratios, seeded
  *  uniform so an all-zero start splits evenly. */
-export declare function totalLens(parts: readonly Writable<Num>[]): Writable<Num>;
+export declare function total(parts: readonly Writable<Num>[]): Writable<Num>;
 export {};