bireactive 0.3.1 → 0.3.2

package/dist/core/lenses/aggregates.js

@@ -1,126 +1,235 @@
-// 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 { SKIP } from "../cell.js";
-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. */
-export function clampToDisc(c, r) {
-    return p => {
-        const dx = p.x - c.x;
-        const dy = p.y - c.y;
-        const d = Math.hypot(dx, dy);
-        if (d <= r)
-            return p;
-        const k = r / d;
-        return { x: c.x + dx * k, y: c.y + dy * k };
+// Trait-driven aggregate lenses: `mean`, `mix`, `spread`, etc. infer the value
+// class from the first input, so they work for any class with the right traits
+// (Vec, Color, Pose, Range, Box, …). All closed-form and cross-channel
+// invariant by construction.
+import { Num, reader, SKIP, } from "../index.js";
+import { remember } from "./memory.js";
+/** Equal-weight mean (writable of `inputs[0]`'s class); writes distribute
+ *  the delta evenly. Class inferred from the first input; needs `linear`. */
+// biome-ignore lint/suspicious/noExplicitAny: variance escape
+export function mean(inputs) {
+    if (inputs.length === 0)
+        throw new Error("mean: need ≥ 1 input");
+    // biome-ignore lint/suspicious/noExplicitAny: dynamic class lookup
+    const Cls = inputs[0].constructor;
+    // biome-ignore lint/suspicious/noExplicitAny: dynamic trait lookup
+    const lin = Cls.traits?.linear;
+    if (!lin)
+        throw new Error(`mean: ${Cls.name ?? "?"} has no traits.linear`);
+    const n = inputs.length;
+    const inv = 1 / n;
+    // biome-ignore lint/suspicious/noExplicitAny: variance escape on Cls.lens
+    return Cls.lens(inputs, 
+    // biome-ignore lint/suspicious/noExplicitAny: variance escape
+    (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: variance escape
+    (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;
+    });
+}
+/** Weighted blend of K branches over any `Linear` type: reads the normalized
+ *  weighted sum `Σ wᵢ·aᵢ`, writes the minimum-norm delta back into the
+ *  branches (zero-weight branches untouched). Weights are read-only reactive
+ *  controls — a one-hot is `select`, a `(1−t, t)` edge is `crossfade`. */
+// biome-ignore lint/suspicious/noExplicitAny: variance escape
+export function mix(weights, branches) {
+    const K = branches.length;
+    if (K < 1)
+        throw new Error("mix: need ≥ 1 branch");
+    if (weights.length !== K)
+        throw new Error("mix: weights/branches length mismatch");
+    // biome-ignore lint/suspicious/noExplicitAny: dynamic class lookup
+    const Cls = branches[0].constructor;
+    // biome-ignore lint/suspicious/noExplicitAny: dynamic trait lookup
+    const lin = Cls.traits?.linear;
+    if (!lin)
+        throw new Error(`mix: ${Cls.name ?? "?"} has no traits.linear`);
+    const wf = weights.map(w => reader(w));
+    // Normalized weights + Σw². Degenerate (all-zero) weights fall back to
+    // uniform so the read stays defined.
+    const readW = () => {
+        const raw = wf.map(f => f());
+        let sum = 0;
+        for (const x of raw)
+            sum += x;
+        const w = Math.abs(sum) > 1e-12 ? raw.map(x => x / sum) : raw.map(() => 1 / K);
+        let sumSq = 0;
+        for (const x of w)
+            sumSq += x * x;
+        return { w, sumSq };
+    };
+    // biome-ignore lint/suspicious/noExplicitAny: variance escape on Cls.lens
+    const combine = (vals, w) => {
+        let acc = lin.scale(vals[0], w[0]);
+        for (let i = 1; i < K; i++)
+            acc = lin.add(acc, lin.scale(vals[i], w[i]));
+        return acc;
     };
+    // biome-ignore lint/suspicious/noExplicitAny: variance escape on Cls.lens
+    return Cls.lens(branches, 
+    // biome-ignore lint/suspicious/noExplicitAny: variance escape
+    (vals) => combine(vals, readW().w), 
+    // biome-ignore lint/suspicious/noExplicitAny: variance escape
+    (target, vals) => {
+        const { w, sumSq } = readW();
+        const delta = lin.sub(target, combine(vals, w));
+        if (sumSq < 1e-12)
+            return vals.map(() => SKIP);
+        const inv = 1 / sumSq;
+        return vals.map((v, i) => w[i] === 0 ? SKIP : lin.add(v, lin.scale(delta, w[i] * inv)));
+    });
+}
+/** Two-branch router (mix simplex *vertex*): reads the live branch, writes
+ *  flow entirely to it, the other is left put. Flipping `cond` snaps the
+ *  output to the other branch's stored value. */
+// biome-ignore lint/suspicious/noExplicitAny: variance escape
+export function select(cond, whenFalse, whenTrue) {
+    return mix([Num.derive(() => (cond.value ? 0 : 1)), Num.derive(() => (cond.value ? 1 : 0))], [whenFalse, whenTrue]);
+}
+/** Two-branch crossfade (mix simplex *edge*): `lerp(a, b, t)`. Writing
+ *  keeps `t` fixed and splits the delta by influence. */
+// biome-ignore lint/suspicious/noExplicitAny: variance escape
+export function crossfade(t, a, b) {
+    return mix([Num.derive(() => 1 - t.value), Num.derive(() => t.value)], [a, b]);
 }
-/** Scalar-output argmin lens: write does one Newton step against the FD
- *  Jacobian, distributing the residual by `weights`. For typed/multi-
- *  output cases use `factor()`; this M=1 path is kept for its hand-rolled
- *  inner loop. */
-export function argminNum(inputs, forward, weights, opts = {}) {
-    if (weights.length !== inputs.length) {
-        throw new Error("argminNum: weights/inputs length mismatch");
+/** Mean distance from the centroid (needs `Linear` + `Metric`); write scales
+ *  the cluster's deviations so the new mean matches. The complement carries
+ *  normalized deviations, so a collapse (spread → 0) reinflates the shape. */
+export function spread(inputs) {
+    const K = inputs.length;
+    if (K < 1)
+        throw new Error("spread: need ≥ 1 input");
+    // biome-ignore lint/suspicious/noExplicitAny: dynamic class lookup
+    const Cls = inputs[0].constructor;
+    const lin = Cls.traits?.linear;
+    const met = Cls.traits?.metric;
+    if (!lin || !met) {
+        throw new Error(`spread: ${Cls.name ?? "?"} needs Linear + Metric`);
     }
-    const eps = opts.eps ?? 1e-4;
-    const damping = opts.damping ?? 1e-6;
-    const n = inputs.length;
-    // Pre-allocated to avoid per-write allocations.
-    const J = new Array(n);
-    const out = new Array(n);
-    return Num.lens(inputs, vals => forward(vals), (target, vals) => {
-        const xs = vals;
-        const y0 = forward(xs);
-        const dy = target - y0;
-        for (let i = 0; i < n; i++) {
-            const saved = xs[i];
-            xs[i] = saved + eps;
-            J[i] = (forward(xs) - y0) / eps;
-            xs[i] = saved;
-        }
-        let denom = damping;
+    const inv = 1 / K;
+    const centroid = (vals) => {
+        let acc = vals[0];
+        for (let i = 1; i < K; i++)
+            acc = lin.add(acc, vals[i]);
+        return lin.scale(acc, inv);
+    };
+    const meanSpread = (vals, ctr) => {
+        let total = 0;
+        for (let i = 0; i < K; i++)
+            total += met(vals[i], ctr);
+        return total * inv;
+    };
+    // Mean metric-distance from the centroid is a magnitude `remember`:
+    // writing it scales the cluster's deviations about the centroid, and a
+    // collapse (spread → 0) reinflates the remembered shape.
+    return remember(inputs, {
+        anchor: (vals) => centroid(vals),
+        feature: (vals, ctr) => meanSpread(vals, ctr),
+    });
+}
+/** Mean/spread decomposition: K values → {mean, spread}, i.e. centroid +
+ *  uniform scale about it. `mean` ∘ `spread`; works for any
+ *  Linear + Metric class (palettes, point clouds, poses, …). */
+export function meanSpread(colors) {
+    return {
+        mean: mean(colors),
+        spread: spread(colors),
+    };
+}
+/** (a, b) → {mean: (a+b)/2, diff: a−b}. Square linear iso; each write is the
+ *  inverse change of basis, so mean and diff are cross-channel invariant. */
+export function meanDiff(a, b) {
+    const mean = Num.lens([a, b], vals => (vals[0] + vals[1]) / 2, (target, vals) => {
+        const d = vals[0] - vals[1];
+        return [target + d / 2, target - d / 2];
+    });
+    const diff = Num.lens([a, b], vals => vals[0] - vals[1], (target, vals) => {
+        const m = (vals[0] + vals[1]) / 2;
+        return [m + target / 2, m - target / 2];
+    });
+    return { mean, diff };
+}
+/** Mean of N nums, clamped to `[lo, hi]` on read and write (writes are
+ *  clamped before the delta is distributed). */
+export function clampedMean(parents, lo, hi) {
+    const n = parents.length;
+    const inv = 1 / n;
+    return Num.lens(parents, vals => {
+        let s = 0;
+        for (let i = 0; i < n; i++)
+            s += vals[i];
+        const m = s * inv;
+        return m < lo ? lo : m > hi ? hi : m;
+    }, (target, vals) => {
+        const clamped = target < lo ? lo : target > hi ? hi : target;
+        let s = 0;
+        for (let i = 0; i < n; i++)
+            s += vals[i];
+        const cur = s * inv;
+        const delta = clamped - cur;
+        const out = new Array(n);
         for (let i = 0; i < n; i++)
-            denom += weights[i] * J[i] * J[i];
-        const k = dy / denom;
-        for (let i = 0; i < n; i++) {
-            if (weights[i] === 0) {
-                out[i] = SKIP;
-            }
-            else {
-                out[i] = xs[i] + weights[i] * J[i] * k;
-            }
-        }
+            out[i] = vals[i] + delta;
         return out;
     });
 }
-/** 2D-output argmin lens (scalar Num inputs, `{x, y}` forward). For IK
- *  arms, draggable points, handle projection. Kept for its hand-rolled
- *  2×2 inverse + `clampTarget` hook; see `factor()` for other M. */
-export function argminVec(inputs, forward, weights, opts = {}) {
-    if (weights.length !== inputs.length) {
-        throw new Error("argminVec: weights/inputs length mismatch");
+/** Num values as (i, valueᵢ) samples → {mean, slope}. Writing `mean` shifts
+ *  all values; writing `slope` (least-squares) tilts them about the mean.
+ *  Each preserves the other's reading. */
+export function timeSeries(values) {
+    const N = values.length;
+    if (N < 2)
+        throw new Error("timeSeries: need ≥ 2 values");
+    const mean = Num.lens(values, (vals) => {
+        let s = 0;
+        for (let i = 0; i < N; i++)
+            s += vals[i];
+        return s / N;
+    }, (target, vals) => {
+        let s = 0;
+        for (let i = 0; i < N; i++)
+            s += vals[i];
+        const cur = s / N;
+        const delta = target - cur;
+        return vals.map(v => v + delta);
+    });
+    // Least-squares slope = Σ (i − idxMean)(v − mean) / Σ (i − idxMean)²,
+    // idxMean = (N−1)/2 constant. Write tilts about the mean:
+    // value_i = mean + (i − idxMean)·s.
+    const idxMean = (N - 1) / 2;
+    let denomSlope = 0;
+    for (let i = 0; i < N; i++) {
+        const di = i - idxMean;
+        denomSlope += di * di;
     }
-    const eps = opts.eps ?? 1e-4;
-    const damping = opts.damping ?? 1e-3;
-    const clamp = opts.clampTarget;
-    const n = inputs.length;
-    // Pre-allocated to avoid per-write allocations.
-    const Jx = new Array(n);
-    const Jy = new Array(n);
-    const out = new Array(n);
-    return Vec.lens(inputs, vals => forward(vals), (rawTarget, vals) => {
-        const xs = vals;
-        const target = clamp ? clamp(rawTarget, xs) : rawTarget;
-        const y0 = forward(xs);
-        const dx = target.x - y0.x;
-        const dy = target.y - y0.y;
-        for (let i = 0; i < n; i++) {
-            const saved = xs[i];
-            xs[i] = saved + eps;
-            const ye = forward(xs);
-            xs[i] = saved;
-            Jx[i] = (ye.x - y0.x) / eps;
-            Jy[i] = (ye.y - y0.y) / eps;
-        }
-        // J·W·Jᵀ is the 2×2 [a b; b c]. Add damping to the diagonal, invert.
-        let a = damping;
-        let b = 0;
-        let c = damping;
-        for (let i = 0; i < n; i++) {
-            const w = weights[i];
-            a += w * Jx[i] * Jx[i];
-            b += w * Jx[i] * Jy[i];
-            c += w * Jy[i] * Jy[i];
-        }
-        const det = a * c - b * b;
-        if (Math.abs(det) < 1e-14) {
-            // Singular; leave inputs unchanged.
-            for (let i = 0; i < n; i++)
-                out[i] = SKIP;
-            return out;
-        }
-        const invA = c / det;
-        const invB = -b / det;
-        const invC = a / det;
-        const kx = invA * dx + invB * dy;
-        const ky = invB * dx + invC * dy;
-        for (let i = 0; i < n; i++) {
-            const w = weights[i];
-            if (w === 0) {
-                out[i] = SKIP;
-            }
-            else {
-                out[i] = xs[i] + w * (Jx[i] * kx + Jy[i] * ky);
-            }
-        }
-        return out;
+    const slope = Num.lens(values, (vals) => {
+        let valMean = 0;
+        for (let i = 0; i < N; i++)
+            valMean += vals[i];
+        valMean /= N;
+        let num = 0;
+        for (let i = 0; i < N; i++)
+            num += (i - idxMean) * (vals[i] - valMean);
+        return num / denomSlope;
+    }, (target, vals) => {
+        let valMean = 0;
+        for (let i = 0; i < N; i++)
+            valMean += vals[i];
+        valMean /= N;
+        return vals.map((_, i) => valMean + (i - idxMean) * target);
     });
+    return { mean, slope };
 }

package/dist/core/lenses/geometry.d.ts

@@ -1,4 +1,4 @@
-import { type Cell, type Read, type Writable } from "../cell.js";
+import { type Cell, type Init, type Read, type Writable } from "../cell.js";
 import { Num } from "../values/num.js";
 import { Vec } from "../values/vec.js";
 type V = {
@@ -24,7 +24,25 @@ export declare function pulleySum(a: Num, b: Num): Writable<Num>;
 /** Difference of two nums: `a - b`. Writing the difference shifts
  *  both inputs symmetrically by ±half-delta. */
 export declare function diff(a: Num, b: Num): Writable<Num>;
-/** Mean of N nums, clamped to `[lo, hi]` on read and write (writes are
- *  clamped before the delta is distributed). */
-export declare function clampedMean(parents: readonly Num[], lo: number, hi: number): Writable<Num>;
+/** Policy for `polar`'s inverse — which inputs absorb a write:
+ *
+ *  - `rotate`    — c fixed; write r and a to land on target.
+ *  - `translate` — r and a fixed; shift c by Δ.
+ *  - `radial`    — c and a fixed; project the drag onto the ray.
+ *  - `circular`  — c and r fixed; project the drag onto the circle. */
+export type PolarPolicy = "rotate" | "translate" | "radial" | "circular";
+/** Vec at a polar offset from `center`: `center + (r·cos a, r·sin a)`. Each
+ *  input is a literal (new cell) or existing writable (passed through); for
+ *  read-only sources use `Vec.derive`. `policy` selects which inputs absorb
+ *  writes; lock one with `Num.pin`: `polar(c, Num.pin(100), a)`. */
+export declare function polar(center: Init<Vec>, r: Init<Num>, a: Init<Num>, policy?: PolarPolicy): Writable<Vec>;
+/** Cubic Bezier (p0..p3) → {start, end, startTangent, endTangent}. Moving an
+ *  endpoint carries its control point (tangent preserved); writing a tangent
+ *  moves only its control point. Square linear iso — all pairs invariant. */
+export declare function bezierGestalt(p0: Writable<Vec>, p1: Writable<Vec>, p2: Writable<Vec>, p3: Writable<Vec>): {
+    start: Writable<Vec>;
+    end: Writable<Vec>;
+    startTangent: Writable<Vec>;
+    endTangent: Writable<Vec>;
+};
 export {};

package/dist/core/lenses/geometry.js

@@ -1,10 +1,8 @@
-// geometry.ts — geometric lens building blocks over the N-input
-// `Cls.lens` / `Cls.derive` forms. All are a few lines on top of the engine.
 import { SKIP } from "../cell.js";
-import { Num } from "../values/num.js";
-import { Vec } from "../values/vec.js";
-import { rotateAbout } from "./closed-form-policies.js";
+import { Num, num } from "../values/num.js";
+import { nearestAngle, Vec, vec } from "../values/vec.js";
 import { remember } from "./memory.js";
+import { rotateAbout } from "./point-cloud.js";
 /** Distance between two Vecs; writing scales them symmetrically about
  *  their midpoint (collapse to 0 reinflates the last direction). */
 export function distance(a, b) {
@@ -72,27 +70,61 @@ export function diff(a, b) {
         return [av + delta / 2, bv - delta / 2];
     });
 }
-/** Mean of N nums, clamped to `[lo, hi]` on read and write (writes are
- *  clamped before the delta is distributed). */
-export function clampedMean(parents, lo, hi) {
-    const n = parents.length;
-    const inv = 1 / n;
-    return Num.lens(parents, vals => {
-        let s = 0;
-        for (let i = 0; i < n; i++)
-            s += vals[i];
-        const m = s * inv;
-        return m < lo ? lo : m > hi ? hi : m;
-    }, (target, vals) => {
-        const clamped = target < lo ? lo : target > hi ? hi : target;
-        let s = 0;
-        for (let i = 0; i < n; i++)
-            s += vals[i];
-        const cur = s * inv;
-        const delta = clamped - cur;
-        const out = new Array(n);
-        for (let i = 0; i < n; i++)
-            out[i] = vals[i] + delta;
-        return out;
+/** Vec at a polar offset from `center`: `center + (r·cos a, r·sin a)`. Each
+ *  input is a literal (new cell) or existing writable (passed through); for
+ *  read-only sources use `Vec.derive`. `policy` selects which inputs absorb
+ *  writes; lock one with `Num.pin`: `polar(c, Num.pin(100), a)`. */
+export function polar(center, r, a, policy = "rotate") {
+    const cSig = center instanceof Vec ? center : vec(center.x, center.y);
+    const rSig = num(r);
+    const aSig = num(a);
+    const project = (c, rv, av) => ({
+        x: c.x + rv * Math.cos(av),
+        y: c.y + rv * Math.sin(av),
+    });
+    let bwd;
+    switch (policy) {
+        case "rotate":
+            bwd = (p, [cv, , av]) => {
+                const dx = p.x - cv.x;
+                const dy = p.y - cv.y;
+                return [SKIP, Math.hypot(dx, dy), nearestAngle(Math.atan2(dy, dx), av)];
+            };
+            break;
+        case "translate":
+            bwd = (p, [cv, rv, av]) => {
+                const f = project(cv, rv, av);
+                return [{ x: cv.x + (p.x - f.x), y: cv.y + (p.y - f.y) }, SKIP, SKIP];
+            };
+            break;
+        case "radial":
+            bwd = (p, [cv, , av]) => {
+                const dx = p.x - cv.x;
+                const dy = p.y - cv.y;
+                return [SKIP, dx * Math.cos(av) + dy * Math.sin(av), SKIP];
+            };
+            break;
+        case "circular":
+            bwd = (p, [cv, , av]) => [SKIP, SKIP, nearestAngle(Math.atan2(p.y - cv.y, p.x - cv.x), av)];
+            break;
+    }
+    return Vec.lens([cSig, rSig, aSig], ([c, rv, av]) => project(c, rv, av), bwd);
+}
+/** Cubic Bezier (p0..p3) → {start, end, startTangent, endTangent}. Moving an
+ *  endpoint carries its control point (tangent preserved); writing a tangent
+ *  moves only its control point. Square linear iso — all pairs invariant. */
+export function bezierGestalt(p0, p1, p2, p3) {
+    const start = Vec.lens([p0, p1], (vals) => vals[0], (target, vals) => {
+        const dx = target.x - vals[0].x;
+        const dy = target.y - vals[0].y;
+        return [target, { x: vals[1].x + dx, y: vals[1].y + dy }];
+    });
+    const end = Vec.lens([p2, p3], (vals) => vals[1], (target, vals) => {
+        const dx = target.x - vals[1].x;
+        const dy = target.y - vals[1].y;
+        return [{ x: vals[0].x + dx, y: vals[0].y + dy }, target];
     });
+    const startTangent = Vec.lens([p0, p1], (vals) => ({ x: vals[1].x - vals[0].x, y: vals[1].y - vals[0].y }), (target, vals) => [SKIP, { x: vals[0].x + target.x, y: vals[0].y + target.y }]);
+    const endTangent = Vec.lens([p2, p3], (vals) => ({ x: vals[1].x - vals[0].x, y: vals[1].y - vals[0].y }), (target, vals) => [{ x: vals[1].x - target.x, y: vals[1].y - target.y }, SKIP]);
+    return { start, end, startTangent, endTangent };
 }

package/dist/core/lenses/index.d.ts

@@ -1,8 +1,7 @@
-export { type ArgminOpts, type ArgminVecOpts, argminNum, argminVec, clampToDisc, } from "./aggregates.js";
-export { bestFitCircle, bestFitLine, pca, rigidTranslate, rotateAbout, scaleAbout, scaleAboutXY, total, } from "./closed-form-policies.js";
-export { bbox, meanDiff, procrustes } from "./decompositions.js";
-export { bezierGestalt, crossfade, mean, meanSpread, mix, select, spread, timeSeries, } from "./domain-aggregates.js";
-export { angle, clampedMean, diff, distance, pulleySum, reflection, vecLerp } from "./geometry.js";
+export { clampedMean, crossfade, mean, meanDiff, meanSpread, mix, select, spread, timeSeries, } from "./aggregates.js";
+export { angle, bezierGestalt, diff, distance, type PolarPolicy, polar, pulleySum, reflection, vecLerp, } from "./geometry.js";
 export { type ContinuousOpts, continuous, type RememberOpts, remember, } from "./memory.js";
+export { type ArgminOpts, type ArgminVecOpts, argminNum, argminVec, bundle, clampToDisc, type FactorOpts, type FactorResult, factor, factorTuple, type OutputSpec, type PackedInput, } from "./numerical.js";
+export { bbox, bestFitCircle, bestFitLine, pca, procrustes, rotateAbout, scaleAbout, scaleAboutXY, total, } from "./point-cloud.js";
 export { type ClosestOpts, hullWeights, nearestIndex } from "./snap.js";
-export { bundle, type FactorOpts, type FactorResult, factor, factorTuple, type OutputSpec, type PackedInput, } from "./typed-factor.js";
+export { applyCaseMask, applyCasePattern, caseFold, caseMaskOf, parseWords, rebuildWords, } from "./text.js";

package/dist/core/lenses/index.js

@@ -1,8 +1,7 @@
-export { argminNum, argminVec, clampToDisc, } from "./aggregates.js";
-export { bestFitCircle, bestFitLine, pca, rigidTranslate, rotateAbout, scaleAbout, scaleAboutXY, total, } from "./closed-form-policies.js";
-export { bbox, meanDiff, procrustes } from "./decompositions.js";
-export { bezierGestalt, crossfade, mean, meanSpread, mix, select, spread, timeSeries, } from "./domain-aggregates.js";
-export { angle, clampedMean, diff, distance, pulleySum, reflection, vecLerp } from "./geometry.js";
+export { clampedMean, crossfade, mean, meanDiff, meanSpread, mix, select, spread, timeSeries, } from "./aggregates.js";
+export { angle, bezierGestalt, diff, distance, polar, pulleySum, reflection, vecLerp, } from "./geometry.js";
 export { continuous, remember, } from "./memory.js";
+export { argminNum, argminVec, bundle, clampToDisc, factor, factorTuple, } from "./numerical.js";
+export { bbox, bestFitCircle, bestFitLine, pca, procrustes, rotateAbout, scaleAbout, scaleAboutXY, total, } from "./point-cloud.js";
 export { hullWeights, nearestIndex } from "./snap.js";
-export { bundle, factor, factorTuple, } from "./typed-factor.js";
+export { applyCaseMask, applyCasePattern, caseFold, caseMaskOf, parseWords, rebuildWords, } from "./text.js";

package/dist/core/lenses/memory.js

@@ -1,20 +1,7 @@
-// memory.ts — path-dependent (stateful-complement) lens combinators.
-//
-// Two backward directions are not functions of the current source alone;
-// they depend on where the value has BEEN. Both were hand-rolled per site
-// across the closed-form-policy and aggregate lenses, each with its own
-// degeneracy threshold. They factor into two combinators:
-//
-//   remember   — a magnitude/total view of a cluster: sources live at
-//                `anchorᵢ + shapeᵢ · scale`, `scale` is the writable
-//                scalar. The complement holds the normalized shape so a
-//                collapse to the anchor (scale → 0) reinflates it. Covers
-//                scaleAbout, bestFitCircle.radius, spreadOf, totalLens.
-//   continuous — a cyclic (mod-`period`) view lifted to its universal
-//                cover: the complement tracks the last emitted value and
-//                unwraps the raw reading to the nearest sheet, so the
-//                view never tears at a branch cut. Covers the eigenvector
-//                angle of bestFitLine; the primitive behind winding.
+// Stateful-complement lens combinators: the backward pass depends on where
+// the value has been, not just the current source. `remember` is a
+// magnitude/total view with shape-memory; `continuous` is a winding-aware
+// view of a cyclic reading.
 import { Num, SKIP } from "../index.js";
 /** Scalar shape-memory lens. Reads `feature(sources)`; writing it scales
  *  the cluster about `anchor` so the new feature matches, reinflating the