bireactive 0.3.0 → 0.3.2

package/dist/core/lenses/decompositions.js

@@ -1,224 +0,0 @@
-// decompositions.ts — closed-form N→M lens decompositions (Vec/Num).
-//
-// N inputs → M coupled writable outputs, where writing one output
-// preserves the readings of the other M−1 (cross-channel invariance).
-// Each bwd is a hand-rolled group action (translate / rotate / scale
-// about the centroid), so cross-channel invariance is EXACT and one
-// write lands in O(K). For the generic numerical N→M escape hatch (when
-// no closed form fits) see `factor` in `typed-factor.ts`.
-import { Num, SKIP, Vec } from "../index.js";
-// meanDiff — M=2 isomorphism baseline.
-//
-// (a, b) → ((a+b)/2, a−b). Square full-rank linear lens; bwd is the
-// inverse change of basis — exact, 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 };
-}
-// procrustes — closed-form similarity (the showcase).
-//
-// K writable Vecs → {centroid, rotation (angle of point[0] about
-// centroid), scale (its distance from centroid)}. Each bwd is a
-// closed-form transform about the centroid:
-//   write centroid → translate every point by (c − old c)
-//   write rotation → rotate every point about centroid by (θ − old θ)
-//   write scale    → scale every point about centroid by (s / old s)
-// These commute on the cluster's similarity orbit, so the three outputs
-// have EXACT cross-channel invariance. Degenerate: K < 2 leaves
-// rotation/scale undefined; a collapsed cluster (scale → 0) makes
-// rotation singular and scale writes no-ops; target scale = 0 collapses
-// to the centroid.
-export function procrustes(points) {
-    const K = points.length;
-    if (K < 2)
-        throw new Error("procrustes: need ≥ 2 points");
-    const centroid = Vec.lens(points, (vals) => {
-        let sx = 0;
-        let sy = 0;
-        for (let i = 0; i < K; i++) {
-            sx += vals[i].x;
-            sy += vals[i].y;
-        }
-        return { x: sx / K, y: sy / K };
-    }, (target, vals) => {
-        let sx = 0;
-        let sy = 0;
-        for (let i = 0; i < K; i++) {
-            sx += vals[i].x;
-            sy += vals[i].y;
-        }
-        const dx = target.x - sx / K;
-        const dy = target.y - sy / K;
-        const out = new Array(K);
-        for (let i = 0; i < K; i++)
-            out[i] = { x: vals[i].x + dx, y: vals[i].y + dy };
-        return out;
-    });
-    const rotation = Num.lens(points, (vals) => {
-        let sx = 0;
-        let sy = 0;
-        for (let i = 0; i < K; i++) {
-            sx += vals[i].x;
-            sy += vals[i].y;
-        }
-        const cx = sx / K;
-        const cy = sy / K;
-        return Math.atan2(vals[0].y - cy, vals[0].x - cx);
-    }, (target, vals) => {
-        let sx = 0;
-        let sy = 0;
-        for (let i = 0; i < K; i++) {
-            sx += vals[i].x;
-            sy += vals[i].y;
-        }
-        const cx = sx / K;
-        const cy = sy / K;
-        const rx0 = vals[0].x - cx;
-        const ry0 = vals[0].y - cy;
-        if (rx0 * rx0 + ry0 * ry0 < 1e-24) {
-            // Collapsed cluster; no angle to rotate from.
-            return vals.map(() => SKIP);
-        }
-        const oldθ = Math.atan2(ry0, rx0);
-        const dθ = target - oldθ;
-        const cos = Math.cos(dθ);
-        const sin = Math.sin(dθ);
-        const out = new Array(K);
-        for (let i = 0; i < K; i++) {
-            const rx = vals[i].x - cx;
-            const ry = vals[i].y - cy;
-            out[i] = { x: cx + cos * rx - sin * ry, y: cy + sin * rx + cos * ry };
-        }
-        return out;
-    });
-    const centroidOf = (vals) => {
-        let sx = 0;
-        let sy = 0;
-        for (let i = 0; i < K; i++) {
-            sx += vals[i].x;
-            sy += vals[i].y;
-        }
-        return { x: sx / K, y: sy / K };
-    };
-    const refreshDevs = (devs, vals) => {
-        const c = centroidOf(vals);
-        return devs.map((d, i) => {
-            const dx = vals[i].x - c.x;
-            const dy = vals[i].y - c.y;
-            return dx * dx + dy * dy > 1e-18 ? { x: dx, y: dy } : d;
-        });
-    };
-    const scale = Num.lens(points, {
-        init: (vals) => {
-            const c = centroidOf(vals);
-            return { devs: vals.map(v => ({ x: v.x - c.x, y: v.y - c.y })) };
-        },
-        step: (vals, c) => ({ devs: refreshDevs(c.devs, vals) }),
-        fwd: (vals) => {
-            const c = centroidOf(vals);
-            return Math.hypot(vals[0].x - c.x, vals[0].y - c.y);
-        },
-        bwd: (target, vals, c) => {
-            const cen = centroidOf(vals);
-            const d0 = c.devs[0];
-            const r0 = Math.hypot(d0.x, d0.y);
-            if (r0 < 1e-12)
-                return { updates: vals.map(() => SKIP), complement: c };
-            const k = target / r0;
-            const out = c.devs.map(d => ({ x: cen.x + k * d.x, y: cen.y + k * d.y }));
-            return { updates: out, complement: c };
-        },
-    });
-    return { centroid, rotation, scale };
-}
-// bbox — closed-form axis-aligned bounding box.
-//
-// K Vecs → {center, size}. Forward is min/max (piecewise-constant
-// Jacobian — fatal for FD), but the closed-form bwd is exact:
-//   write center → translate all points by (c − old c)
-//   write size   → scale all about center by component-wise ratio
-// Center↔size invariance is exact. Degenerate axes (size = 0) write
-// as no-ops; negative size reflects (kept permissive).
-export function bbox(points) {
-    const K = points.length;
-    if (K < 1)
-        throw new Error("bbox: need ≥ 1 point");
-    const computeBox = (vals) => {
-        let minX = Number.POSITIVE_INFINITY;
-        let minY = Number.POSITIVE_INFINITY;
-        let maxX = Number.NEGATIVE_INFINITY;
-        let maxY = Number.NEGATIVE_INFINITY;
-        for (let i = 0; i < K; i++) {
-            const x = vals[i].x;
-            const y = vals[i].y;
-            if (x < minX)
-                minX = x;
-            if (x > maxX)
-                maxX = x;
-            if (y < minY)
-                minY = y;
-            if (y > maxY)
-                maxY = y;
-        }
-        return {
-            cx: (minX + maxX) / 2,
-            cy: (minY + maxY) / 2,
-            sx: maxX - minX,
-            sy: maxY - minY,
-        };
-    };
-    const center = Vec.lens(points, (vals) => {
-        const b = computeBox(vals);
-        return { x: b.cx, y: b.cy };
-    }, (target, vals) => {
-        const b = computeBox(vals);
-        const dx = target.x - b.cx;
-        const dy = target.y - b.cy;
-        const out = new Array(K);
-        for (let i = 0; i < K; i++)
-            out[i] = { x: vals[i].x + dx, y: vals[i].y + dy };
-        return out;
-    });
-    const refreshFracs = (fracs, vals) => {
-        const b = computeBox(vals);
-        const hx = b.sx > 1e-12 ? b.sx / 2 : 0;
-        const hy = b.sy > 1e-12 ? b.sy / 2 : 0;
-        return fracs.map((f, i) => ({
-            x: hx > 0 ? (vals[i].x - b.cx) / hx : f.x,
-            y: hy > 0 ? (vals[i].y - b.cy) / hy : f.y,
-        }));
-    };
-    const size = Vec.lens(points, {
-        init: (vals) => {
-            const b = computeBox(vals);
-            const halfX0 = b.sx > 1e-12 ? b.sx / 2 : 1;
-            const halfY0 = b.sy > 1e-12 ? b.sy / 2 : 1;
-            return {
-                fracs: vals.map(v => ({
-                    x: b.sx > 1e-12 ? (v.x - b.cx) / halfX0 : 0,
-                    y: b.sy > 1e-12 ? (v.y - b.cy) / halfY0 : 0,
-                })),
-            };
-        },
-        step: (vals, c) => ({ fracs: refreshFracs(c.fracs, vals) }),
-        fwd: (vals) => {
-            const b = computeBox(vals);
-            return { x: b.sx, y: b.sy };
-        },
-        bwd: (target, vals, c) => {
-            const b = computeBox(vals);
-            const halfTx = target.x / 2;
-            const halfTy = target.y / 2;
-            const out = c.fracs.map(f => ({ x: b.cx + f.x * halfTx, y: b.cy + f.y * halfTy }));
-            return { updates: out, complement: c };
-        },
-    });
-    return { center, size };
-}

package/dist/core/lenses/domain-aggregates.d.ts

@@ -1,42 +0,0 @@
-import { type Cell, Num, type Read, type Traits, type Val, Vec, type Writable } from "../index.js";
-/** Equal-weight mean (writable of `inputs[0]`'s class); writes distribute
- *  the delta evenly. Class inferred from the first input; needs `linear`. */
-export declare function mean<S extends Traits<any, "linear">>(inputs: readonly Writable<S>[]): Writable<S>;
-/** Weighted blend of K branches over any `Linear` type. See module note. */
-export declare function mix<S extends Traits<any, "linear">>(weights: readonly Val<number>[], branches: readonly Writable<S>[]): Writable<S>;
-/** 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. */
-export declare function select<S extends Traits<any, "linear">>(cond: Read<boolean>, whenFalse: Writable<S>, whenTrue: Writable<S>): Writable<S>;
-/** Two-branch crossfade (mix simplex *edge*): `lerp(a, b, t)`. Writing
- *  keeps `t` fixed and splits the delta by influence. */
-export declare function crossfade<S extends Traits<any, "linear">>(t: Read<number>, a: Writable<S>, b: Writable<S>): Writable<S>;
-/** Mean radial distance from the centroid; write scales the cluster's
- *  deviations so the new mean matches the target. Trait-driven via
- *  `Linear` + `Metric`, so it works for any class declaring both (Vec,
- *  Color, Pose, Box, Range, custom).
- *
- *  Complement carries per-input deviations normalized by the current mean
- *  radius, so `spread = T` places each input at `centroid + normDev_i * T`
- *  and a collapse (spread → 0) reinflates the original SHAPE. Centroid is
- *  recomputed every read/write, so an intervening mean translate is not
- *  stale. */
-export declare function spread<T extends NonNullable<unknown>, S extends Cell<T> & Traits<T, "linear" | "metric">>(inputs: readonly Writable<S>[]): Writable<Num>;
-/** 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 declare function meanSpread<T extends NonNullable<unknown>, S extends Cell<T> & Traits<T, "linear" | "metric">>(colors: readonly Writable<S>[]): {
-    mean: Writable<S>;
-    spread: Writable<Num>;
-};
-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>;
-};
-/** Time-series scalar aggregate over Num values as (i, value_i) samples. */
-export declare function timeSeries(values: readonly Writable<Num>[]): {
-    mean: Writable<Num>;
-    slope: Writable<Num>;
-};

package/dist/core/lenses/domain-aggregates.js

@@ -1,245 +0,0 @@
-// domain-aggregates.ts — closed-form lenses beyond point clouds.
-//
-// The group-action patterns from `closed-form-policies.ts`, applied to:
-//   (1) Generic Linear/Metric-trait aggregates — `mean`, `spread`,
-//       `palette` work for colors, poses, ranges, boxes for free.
-//   (2) Bezier gestalt handles ({start, end, startTangent, endTangent}).
-//   (3) Time-series ({mean, slope}) over (i, value) samples.
-// All exact, idempotent, cross-channel invariant by construction.
-import { Num, reader, SKIP, Vec, } from "../index.js";
-import { remember } from "./memory.js";
-// Generic Linear-trait aggregates.
-//
-// Ergonomic entry points that infer the value class from the first input
-// (`mean(colors)` works for any `linear` class). Same engine, no new
-// infrastructure.
-/** 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 (the mix simplex).
-//
-// `mix` is `mean` with the uniform-weight assumption lifted: the read
-// is the normalized weighted sum `Σ wᵢ·aᵢ`, the write is the minimum-norm
-// delta `daᵢ = wᵢ·δ / Σwⱼ²` (the pseudoinverse of `wᵀ·da = δ`), so a
-// zero-weight branch is left untouched. Weights are read-only controls —
-// the bwd never writes them, keeping the blend fixed while the delta flows
-// into the branches.
-//
-// The control lives on the K-simplex: a one-hot vertex is `select`
-// (the live branch absorbs everything), a `(1−t, t)` edge is `crossfade`,
-// uniform weights recover `mean`. Reactive weights are dynamically
-// tracked (read via `.value` inside fwd), so flipping a Bool or sliding a
-// Num re-reads with no extra wiring.
-/** Weighted blend of K branches over any `Linear` type. See module note. */
-// 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]);
-}
-/** Mean radial distance from the centroid; write scales the cluster's
- *  deviations so the new mean matches the target. Trait-driven via
- *  `Linear` + `Metric`, so it works for any class declaring both (Vec,
- *  Color, Pose, Box, Range, custom).
- *
- *  Complement carries per-input deviations normalized by the current mean
- *  radius, so `spread = T` places each input at `centroid + normDev_i * T`
- *  and a collapse (spread → 0) reinflates the original SHAPE. Centroid is
- *  recomputed every read/write, so an intervening mean translate is not
- *  stale. */
-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 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),
-    };
-}
-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 };
-}
-// Time-series aggregates.
-//
-// Scalar values indexed by position → {mean, slope}:
-//   mean  := average; writes shift all values by the delta.
-//   slope := least-squares slope of (i, value_i); writes tilt about mean.
-// mean and slope are invariant under each other (a y-shift preserves
-// slope; tilting about the mean preserves the mean).
-/** Time-series scalar aggregate over Num values as (i, value_i) samples. */
-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 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/typed-factor.d.ts

@@ -1,40 +0,0 @@
-import type { Cell, Inner, Read, Traits, Writable } from "../index.js";
-/** Input cell: writable cell whose value class declares the `pack`
- *  trait. Vec, Num, Pose, Box, Color, Range all satisfy this. */
-export type PackedInput<T = any> = Writable<Read<T> & Traits<T, "pack">>;
-/** Output specification: a target class + a fwd from typed inputs to
- *  the value the class wraps. Optional analytical Jacobian skips FD. */
-export interface OutputSpec<C extends new (...args: never[]) => Cell<any>> {
-    Cls: C;
-    fwd: (inputs: ReadonlyArray<any>) => Inner<InstanceType<C>>;
-    /** Optional analytical Jacobian. Returns dim(Cls) rows, each of
-     *  length `sum(input pack dims)`. If supplied for ALL outputs, FD
-     *  is skipped entirely → faster AND exact (no eps drift). */
-    jacobian?: (inputs: ReadonlyArray<any>) => readonly (readonly number[])[];
-}
-/** Result type: writable cell per output key, typed by the spec's Cls. */
-export type FactorResult<O extends Record<string, OutputSpec<any>>> = {
-    [K in keyof O]: Writable<InstanceType<O[K]["Cls"]>>;
-};
-export interface FactorOpts {
-    /** Per-input mobility weights. 0 = pinned. Defaults to 1 for all. */
-    inputWeights?: readonly number[];
-    /** Levenberg-Marquardt damping. Default 1e-6. */
-    damping?: number;
-    /** Finite-difference epsilon. Default 1e-5. */
-    eps?: number;
-    /** Auto-iterate the bwd until the written channel's reading is
-     *  within `tol` of target (or `maxIters` exhausted). Cheap when
-     *  forwards are linear (1 iter); needed for non-linear forwards
-     *  to land exactly without user-side loops. Default `false`. */
-    converge?: boolean;
-    /** Max iters when `converge: true`. Default 10. */
-    maxIters?: number;
-    /** Convergence tolerance (per-channel L2). Default 1e-4. */
-    tol?: number;
-}
-export declare function factor<O extends Record<string, OutputSpec<any>>>(inputs: readonly PackedInput[], outputs: O, opts?: FactorOpts): FactorResult<O>;
-export declare function factorTuple<T extends readonly OutputSpec<any>[]>(inputs: readonly PackedInput[], outputs: readonly [...T], opts?: FactorOpts): {
-    [K in keyof T]: Writable<InstanceType<T[K]["Cls"]>>;
-};
-export declare function bundle<T, O extends Record<string, OutputSpec<any>>>(source: Writable<Read<T> & Traits<T, "pack">>, views: O, opts?: FactorOpts): FactorResult<O>;