bireactive 0.2.3 → 0.3.0

package/dist/core/values/field.js

@@ -0,0 +1,230 @@
+// field.ts — dense, GPU-resident reactive field: a grid of `T` as ONE cell.
+//
+// A Field is a single reactive node, not one-per-texel: the value is a header
+// {tex, w, h, epoch} (the Canvas handle trick, see gpu.ts), the graph compares
+// `epoch`, and no pixel crosses the bus. So a 1000×1000 field costs the engine
+// exactly what a 4×4 does — graph size is the lens-chain length, independent of
+// resolution. Per-frame work is allocation-free: `evolve`/`splat` ping-pong
+// through reused scratch textures and mint only the small header.
+//
+// Generic over the texel encoding via `Kind<T>` (channel `dim` + the `Pack`
+// codec + the boundary cell class). The dense interior stays a flat RGBA32F
+// texture forever; `T` (Num/Vec/Color) is instantiated ONLY at the boundary —
+// `mean`, `regionMean` — never per-texel. `dim` (1/2/4) selects the channel
+// mask: scalar (heatmap / SDF / density), vector (flow / gradient), colour
+// (i.e. a Canvas).
+//
+// The point of interest is the GPU↔reactivity bridge. `evolve` runs a sim on
+// its own clock (a raf/Anim loop), committing one new value per frame; the
+// reductions (`mean`, `regionMean`) are ordinary read-only derived cells, so
+// they recompute when the field's epoch changes and only *propagate* when their
+// scalar actually moves. Reactive logic downstream (`density > 0.5` → effect)
+// is thereby loosely coupled to time: it observes a continuously-running GPU
+// simulation without knowing a frame exists.
+import { Cell, reader } from "../cell.js";
+import { Canvas, stamp as canvasStamp } from "./canvas.js";
+import { Color } from "./color.js";
+import { newTex, pass, reduceMean, scratch, scratch2 } from "./gpu.js";
+import { Num } from "./num.js";
+import { Vec } from "./vec.js";
+let EPOCH = 0;
+/** Stamp a texture with a fresh epoch — the only way to mint a value. */
+const stamp = (tex, w, h) => ({
+    tex,
+    w,
+    h,
+    epoch: ++EPOCH,
+});
+const equals = (a, b) => a.epoch === b.epoch;
+/** Scalar field (1 channel) — heatmaps, SDFs, density, height. */
+export const Scalar = { dim: 1, pack: Num.traits.pack, cls: Num };
+/** Vector field (2 channels) — flow, gradient, displacement, RD chemicals. */
+export const Vector = { dim: 2, pack: Vec.traits.pack, cls: Vec };
+/** Colour field (4 channels) — i.e. a Canvas. */
+export const Colour = {
+    dim: 4,
+    pack: Color.traits.pack,
+    cls: Color,
+};
+const HEAD = `#version 300 es
+precision highp float;
+in vec2 v_uv;
+out vec4 o;`;
+const MASK = `${HEAD}
+uniform sampler2D u_src; uniform vec2 u_res; uniform vec2 u_o; uniform vec2 u_wh;
+void main() {
+  vec2 px = v_uv * u_res;
+  vec4 s = texture(u_src, v_uv);
+  bool inside = px.x >= u_o.x && px.y >= u_o.y && px.x < u_o.x + u_wh.x && px.y < u_o.y + u_wh.y;
+  o = inside ? vec4(s.rgb, 1.0) : vec4(0.0);
+}`;
+const SPLAT = `${HEAD}
+uniform sampler2D u_src; uniform vec2 u_res; uniform vec2 u_c; uniform float u_r;
+uniform vec3 u_v; uniform float u_mix;
+void main() {
+  vec4 s = texture(u_src, v_uv);
+  float d = distance(v_uv * u_res, u_c);
+  float f = clamp(exp(-(d * d) / (u_r * u_r)) * u_mix, 0.0, 1.0);
+  o = vec4(mix(s.rgb, u_v, f), s.a);
+}`;
+/** GLSL float literal (always carries a decimal point). */
+const glf = (n) => (Number.isInteger(n) ? `${n}.0` : String(n));
+const glv3 = (c) => `${glf(c[0])}, ${glf(c[1])}, ${glf(c[2])}`;
+/** Build a piecewise-linear ramp shader over `channel` (baked per stop set,
+ *  cached by source string in gpu.ts's program cache). */
+function rampFrag(channel, stops) {
+    const ch = "rgba"[channel] ?? "r";
+    let body = `  vec3 c = vec3(${glv3(stops[0][1])});\n`;
+    for (let i = 1; i < stops.length; i++) {
+        const p0 = stops[i - 1][0];
+        const [p1, col] = stops[i];
+        body += `  c = mix(c, vec3(${glv3(col)}), smoothstep(${glf(p0)}, ${glf(p1)}, x));\n`;
+    }
+    return `${HEAD}
+uniform sampler2D u_src;
+void main() {
+  float x = texture(u_src, v_uv).${ch};
+${body}  o = vec4(c, 1.0);
+}`;
+}
+/** Read-only typed view via the kind's boundary class (`Num`/`Vec`/`Color`).
+ *  Cast through the concrete `derive` signature — the static's polymorphic
+ *  `this` rejects the abstract `Ctor<T>`, but at runtime `k.cls` is concrete. */
+function deriveT(k, parent, fn) {
+    const d = k.cls;
+    return d.derive(parent, fn);
+}
+const TMP = new Float64Array(4);
+/** Pack a reduction's `[r,g,b,a]` mean into a boundary value of kind `k`. */
+function packT(k, m) {
+    TMP[0] = m[0];
+    TMP[1] = m[1];
+    TMP[2] = m[2];
+    TMP[3] = m[3];
+    return k.pack.write(TMP, 0);
+}
+function bindUniform(s, name, val) {
+    if (typeof val === "number")
+        s.f(name, val);
+    else if (val.length === 2)
+        s.v2(name, val[0], val[1]);
+    else if (val.length === 3)
+        s.v3(name, val[0], val[1], val[2]);
+    else
+        throw new Error(`field.evolve: uniform ${name} must be number | vec2 | vec3`);
+}
+const EMPTY = { tex: null, w: 0, h: 0, epoch: 0 };
+export class Field extends Cell {
+    kind;
+    static traits = { equals };
+    /** Feedback-safe ping-pong pair for `evolve`/`splat`, lazily allocated. */
+    io = null;
+    constructor(kind, v = EMPTY) {
+        super(v, { equals });
+        this.kind = kind;
+    }
+    pingTex() {
+        return (this.io ??= scratch2());
+    }
+    /** Step the field by `steps` GPU passes of `frag` (which samples the current
+     *  field as `u_src`; `u_texel` = 1/size is provided). One value is committed
+     *  after the substeps, so the reactive graph sees a single new epoch/frame. */
+    evolve(frag, uniforms, steps = 1) {
+        const ping = this.pingTex();
+        const v = this.peek();
+        const w = v.w;
+        const h = v.h;
+        let src = v.tex;
+        let last = null;
+        const entries = uniforms ? Object.entries(uniforms) : null;
+        for (let i = 0; i < steps; i++) {
+            const dst = ping(w, h, src);
+            pass(frag, dst, s => {
+                s.tex("u_src", 0, src);
+                s.v2("u_texel", 1 / w, 1 / h);
+                if (entries)
+                    for (const [name, val] of entries)
+                        bindUniform(s, name, val);
+            });
+            src = dst.tex;
+            last = dst;
+        }
+        if (last)
+            this.value = stamp(last.tex, w, h);
+    }
+    /** Stamp a Gaussian disc of `value` at data pixel `(x, y)`, radius `r`. The
+     *  raster interaction primitive — seed a sim, inject, paint density. */
+    splat(x, y, r, value, strength = 1) {
+        const ping = this.pingTex();
+        const v = this.peek();
+        this.kind.pack.read(value, TMP, 0);
+        const dst = ping(v.w, v.h, v.tex);
+        pass(SPLAT, dst, s => {
+            s.tex("u_src", 0, v.tex);
+            s.v2("u_res", v.w, v.h);
+            s.v2("u_c", x, y);
+            s.f("u_r", r);
+            s.v3("u_v", TMP[0], TMP[1], TMP[2]);
+            s.f("u_mix", strength);
+        });
+        this.value = stamp(dst.tex, v.w, v.h);
+    }
+    /** Whole-field mean as a read-only `T` cell. Reactive: recomputes on every
+     *  new epoch, propagates only when the value moves. One 1×1 GPU readback. */
+    mean() {
+        const k = this.kind;
+        return deriveT(k, this, v => packT(k, reduceMean({ tex: v.tex, w: v.w, h: v.h })));
+    }
+    /** Mean over a sub-rectangle (data pixels, reactive `box`) as a read-only
+     *  `T` cell — the field's "density of this region" observation. */
+    regionMean(box) {
+        const k = this.kind;
+        const bf = reader(box);
+        const sc = scratch();
+        return deriveT(k, this, v => {
+            const b = bf();
+            const dst = sc(v.w, v.h);
+            pass(MASK, dst, s => {
+                s.tex("u_src", 0, v.tex);
+                s.v2("u_res", v.w, v.h);
+                s.v2("u_o", b.x, b.y);
+                s.v2("u_wh", b.w, b.h);
+            });
+            const m = reduceMean({ tex: dst.tex, w: v.w, h: v.h });
+            const cov = m[3];
+            if (cov < 1e-6)
+                return packT(k, [0, 0, 0, 0]);
+            return packT(k, [m[0] / cov, m[1] / cov, m[2] / cov, 1]);
+        });
+    }
+    /** Render `channel` through a colormap to a read-only `Canvas`. Reactive:
+     *  re-renders on every new epoch, so rendering is itself a reactive edge. */
+    colormap(channel, stops) {
+        const frag = rampFrag(channel, stops);
+        const sc = scratch();
+        return Canvas.derive(this, (v) => {
+            const out = sc(v.w, v.h);
+            pass(frag, out, s => s.tex("u_src", 0, v.tex));
+            return canvasStamp(out.tex, v.w, v.h);
+        });
+    }
+}
+/** Writable `Field<T>` of size `w×h`. `painter` fills each texel (returns a
+ *  `T`); omit for an all-zero field. Linear-filtered for continuous sampling. */
+export function field(kind, w, h, painter) {
+    const buf = new Float32Array(w * h * 4);
+    if (painter !== undefined) {
+        const t = new Float64Array(4);
+        let o = 0;
+        for (let y = 0; y < h; y++) {
+            for (let x = 0; x < w; x++, o += 4) {
+                kind.pack.read(painter(x, y), t, 0);
+                for (let c = 0; c < kind.dim; c++)
+                    buf[o + c] = t[c];
+                if (kind.dim < 4)
+                    buf[o + 3] = 1;
+            }
+        }
+    }
+    return new Field(kind, stamp(newTex(w, h, buf, true), w, h));
+}

package/dist/core/values/gpu.d.ts

@@ -6,8 +6,10 @@ export interface Tex {
     w: number;
     h: number;
 }
-/** Allocate an RGBA32F texture (`data` in 0–1 floats, or null). */
-export declare function newTex(w: number, h: number, data?: Float32Array | null): WebGLTexture;
+/** Allocate an RGBA32F texture (`data` in 0–1 floats, or null). `linear`
+ *  requests bilinear filtering (continuous Field sampling), silently
+ *  downgraded to NEAREST where `OES_texture_float_linear` is unavailable. */
+export declare function newTex(w: number, h: number, data?: Float32Array | null, linear?: boolean): WebGLTexture;
 export declare function disposeTex(t: WebGLTexture): void;
 /** A reusable owned texture, reallocated on size change — the GPU analog of
  *  the CPU scratch buffer. */

package/dist/core/values/gpu.js

@@ -21,9 +21,13 @@ export function gl() {
         throw new Error("WebGL2 unavailable");
     if (!ctx.getExtension("EXT_color_buffer_float"))
         throw new Error("EXT_color_buffer_float unavailable");
+    // Optional: linear filtering of RGBA32F (continuous Field sampling/render).
+    // Absent on some mobile GPUs — `newTex(..., linear)` falls back to NEAREST.
+    _floatLinear = ctx.getExtension("OES_texture_float_linear") !== null;
     _gl = ctx;
     return ctx;
 }
+let _floatLinear = false;
 const QUAD = new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]);
 const VERT = `#version 300 es
 in vec2 a_pos;
@@ -81,14 +85,17 @@ function fbo() {
         _fbo = gl().createFramebuffer();
     return _fbo;
 }
-/** Allocate an RGBA32F texture (`data` in 0–1 floats, or null). */
-export function newTex(w, h, data = null) {
+/** Allocate an RGBA32F texture (`data` in 0–1 floats, or null). `linear`
+ *  requests bilinear filtering (continuous Field sampling), silently
+ *  downgraded to NEAREST where `OES_texture_float_linear` is unavailable. */
+export function newTex(w, h, data = null, linear = false) {
     const g = gl();
     const t = g.createTexture();
     g.bindTexture(g.TEXTURE_2D, t);
     g.texImage2D(g.TEXTURE_2D, 0, g.RGBA32F, w, h, 0, g.RGBA, g.FLOAT, data);
-    g.texParameteri(g.TEXTURE_2D, g.TEXTURE_MIN_FILTER, g.NEAREST);
-    g.texParameteri(g.TEXTURE_2D, g.TEXTURE_MAG_FILTER, g.NEAREST);
+    const filter = linear && _floatLinear ? g.LINEAR : g.NEAREST;
+    g.texParameteri(g.TEXTURE_2D, g.TEXTURE_MIN_FILTER, filter);
+    g.texParameteri(g.TEXTURE_2D, g.TEXTURE_MAG_FILTER, filter);
     g.texParameteri(g.TEXTURE_2D, g.TEXTURE_WRAP_S, g.CLAMP_TO_EDGE);
     g.texParameteri(g.TEXTURE_2D, g.TEXTURE_WRAP_T, g.CLAMP_TO_EDGE);
     return t;

package/dist/core/values/matrix.js

@@ -5,7 +5,7 @@
 // compile time. Two invertibles, both `: this` via `Cell#lens`:
 //   - `multiply(b)` — inverse multiplies by `invert(b)`
 //   - `invert()`    — its own inverse
-import { Cell, cachedDerive, field, reader, } from "../cell.js";
+import { Cell, cachedDerive, fieldLens, reader, } from "../cell.js";
 import { Num, num } from "./num.js";
 export const identity = () => ({ a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 });
 export const fromTranslate = (x, y) => ({ a: 1, b: 0, c: 0, d: 1, e: x, f: y });
@@ -93,22 +93,22 @@ export class Matrix extends Cell {
         return this.lens(invert, invert);
     }
     get a() {
-        return field(this, "a", Num);
+        return fieldLens(this, "a", Num);
     }
     get b() {
-        return field(this, "b", Num);
+        return fieldLens(this, "b", Num);
     }
     get c() {
-        return field(this, "c", Num);
+        return fieldLens(this, "c", Num);
     }
     get d() {
-        return field(this, "d", Num);
+        return fieldLens(this, "d", Num);
     }
     get e() {
-        return field(this, "e", Num);
+        return fieldLens(this, "e", Num);
     }
     get f() {
-        return field(this, "f", Num);
+        return fieldLens(this, "f", Num);
     }
     get determinant() {
         return cachedDerive(this, "determinant", Num, determinant);

package/dist/core/values/num.d.ts

@@ -61,7 +61,7 @@ export declare class Num extends Cell<V> {
 }
 /** Writable `Num`. Literal seeds a fresh cell; existing `Writable<Num>`
  *  passes through by identity. RO sources are rejected at the type level —
- *  use `Num.derive(...)` for reactive RO tracking, or `Num.from(...)` for
+ *  use `Num.derive(...)` for reactive RO tracking, or `Num.coerce(...)` for
  *  the permissive lift over any `Val<number>`. */
 export declare function num(v?: Init<Num>): Writable<Num>;
 export {};

package/dist/core/values/num.js

@@ -177,7 +177,7 @@ export class Num extends Cell {
 }
 /** Writable `Num`. Literal seeds a fresh cell; existing `Writable<Num>`
  *  passes through by identity. RO sources are rejected at the type level —
- *  use `Num.derive(...)` for reactive RO tracking, or `Num.from(...)` for
+ *  use `Num.derive(...)` for reactive RO tracking, or `Num.coerce(...)` for
  *  the permissive lift over any `Val<number>`. */
 export function num(v = 0) {
     if (v instanceof Num)

package/dist/core/values/pose.js

@@ -4,7 +4,7 @@
 // a 3-DOF block and writes back through it, so renderers, drag handlers,
 // IK, and physics all observe the same value. Vec / Num lenses compose
 // for consumers that care only about translation or rotation.
-import { Cell, field } from "../cell.js";
+import { Cell, fieldLens } from "../cell.js";
 import { Num } from "./num.js";
 export const add = (a, b) => ({
     x: a.x + b.x,
@@ -71,13 +71,13 @@ export class Pose extends Cell {
         super(v, { equals });
     }
     get x() {
-        return field(this, "x", Num);
+        return fieldLens(this, "x", Num);
     }
     get y() {
-        return field(this, "y", Num);
+        return fieldLens(this, "y", Num);
     }
     get theta() {
-        return field(this, "theta", Num);
+        return fieldLens(this, "theta", Num);
     }
 }
 /** Writable `Pose`. Literal seeds a fresh cell; existing `Pose` passes

package/dist/core/values/range.js

@@ -6,7 +6,7 @@
 // respectively); `.slider(t)` is the bidirectional `t ↔ lo + t·(hi - lo)`
 // iso. Traits: `linear`, `lerp`, `equals`, `pack` (scalar-only).
 import { tween } from "../../animation/index.js";
-import { Cell, cachedDerive, field, isReadonly, reader, readNow, } from "../cell.js";
+import { Cell, cachedDerive, fieldLens, isReadonly, reader, readNow, SKIP, } from "../cell.js";
 import { Bool } from "./bool.js";
 import { Num, num } from "./num.js";
 export const add = (a, b) => ({ lo: a.lo + b.lo, hi: a.hi + b.hi });
@@ -62,11 +62,11 @@ export class Range extends Cell {
     }
     /** Start endpoint. Writes preserve `hi` (start-knob semantics). */
     get lo() {
-        return field(this, "lo", Num);
+        return fieldLens(this, "lo", Num);
     }
     /** End endpoint. Writes preserve `lo` (end-knob semantics). */
     get hi() {
-        return field(this, "hi", Num);
+        return fieldLens(this, "hi", Num);
     }
     get width() {
         return cachedDerive(this, "width", Num, width);
@@ -112,7 +112,7 @@ export class Range extends Cell {
         // defeats the mapped-tuple inference on `[this, t]`).
         return Num.lens([this, t], ([r, tv]) => sample(r, tv), (v, [r]) => {
             const w = r.hi - r.lo;
-            return [undefined, w === 0 ? 0 : (v - r.lo) / w];
+            return [SKIP, w === 0 ? 0 : (v - r.lo) / w];
         });
     }
     /** Membership predicate. Conditional return type: a writable `Num`
@@ -127,8 +127,8 @@ export class Range extends Cell {
                 return Bool.lens([this, v], (vals) => contains(vals[0], vals[1]), (target, vals) => {
                     const [r, n] = vals;
                     if (contains(r, n) === target)
-                        return [undefined, undefined];
-                    return [undefined, target ? clamp(r, n) : eject(r, n)];
+                        return [SKIP, SKIP];
+                    return [SKIP, target ? clamp(r, n) : eject(r, n)];
                 });
             }
         }

package/dist/core/values/template.d.ts

@@ -1,4 +1,4 @@
-import type { Read, Writable } from "../cell.js";
+import { type Read, type Writable } from "../cell.js";
 import { type Num } from "./num.js";
 import { Str } from "./str.js";
 /** Textual codec for a slot value. `parse` returns `undefined` to reject. */

package/dist/core/values/template.js

@@ -20,6 +20,7 @@
 // stop prunes the no-op, and that slot stays put. A missing delimiter
 // rejects the whole edit. Adjacent slots with no literal between them are
 // ambiguous to split — avoid empty inter-slot literals.
+import { SKIP } from "../cell.js";
 import { num } from "./num.js";
 import { Str, str } from "./str.js";
 /** Identity codec for string slots. */
@@ -66,7 +67,7 @@ const render = (literals, slots, vals) => {
 };
 const parse = (literals, slots, edited) => {
     const k = slots.length;
-    const reject = () => new Array(k).fill(undefined);
+    const reject = () => new Array(k).fill(SKIP);
     const updates = reject();
     const lit0 = literals[0] ?? "";
     if (!edited.startsWith(lit0))

package/dist/core/values/transform.js

@@ -2,11 +2,11 @@
 //
 // Invertibles (`add`, `sub`) return `: this` and ride on
 // `Cell#lens(fwd, bwd)`; chained calls compose into a lens chain.
-// Field-lens getters use `field()`, so writability propagates through
+// Field-lens getters use `fieldLens()`, so writability propagates through
 // nested chains
 // (`Transform.translate.x.value = 5` works on writable receivers).
 import { tween } from "../../animation/index.js";
-import { Cell, field, reader, readNow } from "../cell.js";
+import { Cell, fieldLens, reader, readNow } from "../cell.js";
 import { Num } from "./num.js";
 import { Vec, add as vAdd, equals as vEquals, lerp as vLerp, metric as vMetric, scale as vScale, sub as vSub, } from "./vec.js";
 export const DEFAULT = {
@@ -75,19 +75,19 @@ export class Transform extends Cell {
         return Transform.derive(() => lerp(this.value, readNow(b), readNow(t)));
     }
     get translate() {
-        return field(this, "translate", Vec);
+        return fieldLens(this, "translate", Vec);
     }
     get scale() {
-        return field(this, "scale", Vec);
+        return fieldLens(this, "scale", Vec);
     }
     get origin() {
-        return field(this, "origin", Vec);
+        return fieldLens(this, "origin", Vec);
     }
     get rotate() {
-        return field(this, "rotate", Num);
+        return fieldLens(this, "rotate", Num);
     }
     get opacity() {
-        return field(this, "opacity", Num);
+        return fieldLens(this, "opacity", Num);
     }
     /** Tween-builder, implied by the lerp trait. */
     to(target, dur, ease) {

package/dist/core/values/tri.js

@@ -3,7 +3,7 @@
 // `Tri.value ∈ { true, false, "mixed" }` — Bool plus an unknown state
 // fixed under negation. Strong-Kleene AND/OR follow the partial-info
 // reading (`mixed AND false` → `false`, `mixed AND true` → `mixed`).
-import { Cell } from "../cell.js";
+import { Cell, SKIP } from "../cell.js";
 const equals = (a, b) => a === b;
 /** Kleene negation: `true` / `false` swap, `"mixed"` is fixed. */
 export const not = (a) => (a === "mixed" ? "mixed" : !a);
@@ -55,7 +55,7 @@ export class Tri extends Cell {
             return anyT;
         }, (target, _vs) => {
             if (target === "mixed")
-                return parents.map(() => undefined);
+                return parents.map(() => SKIP);
             return parents.map(() => target);
         });
     }
@@ -81,7 +81,7 @@ export class Tri extends Cell {
             return "mixed";
         }, (target, _vs) => {
             if (target === "mixed")
-                return parents.map(() => undefined);
+                return parents.map(() => SKIP);
             return parents.map(() => target);
         });
     }

package/dist/core/values/vec.js

@@ -2,9 +2,9 @@
 //
 // Invertibles return `: this` and ride on `Cell#lens(fwd, bwd)`;
 // chained calls compose into a lens chain. Field-lens getters use
-// `field()` (propagates writability); `cachedDerive()` wraps RO views.
+// `fieldLens()` (propagates writability); `cachedDerive()` wraps RO views.
 import { tween } from "../../animation/index.js";
-import { Cell, cachedDerive, field, reader, readNow, } from "../cell.js";
+import { Cell, cachedDerive, fieldLens, reader, readNow, SKIP, } from "../cell.js";
 import { Num, num } from "./num.js";
 export const add = (a, b) => ({ x: a.x + b.x, y: a.y + b.y });
 export const sub = (a, b) => ({ x: a.x - b.x, y: a.y - b.y });
@@ -149,10 +149,10 @@ export class Vec extends Cell {
         return Num.derive(this, v => metric(v, readNow(other)));
     }
     get x() {
-        return field(this, "x", Num);
+        return fieldLens(this, "x", Num);
     }
     get y() {
-        return field(this, "y", Num);
+        return fieldLens(this, "y", Num);
     }
     get magnitude() {
         return cachedDerive(this, "magnitude", Num, v => Math.hypot(v.x, v.y));
@@ -200,28 +200,24 @@ export function polar(center, r, a, policy = "rotate") {
             bwd = (p, [cv, , av]) => {
                 const dx = p.x - cv.x;
                 const dy = p.y - cv.y;
-                return [undefined, Math.hypot(dx, dy), nearestAngle(Math.atan2(dy, dx), av)];
+                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) }, undefined, undefined];
+                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 [undefined, dx * Math.cos(av) + dy * Math.sin(av), undefined];
+                return [SKIP, dx * Math.cos(av) + dy * Math.sin(av), SKIP];
             };
             break;
         case "circular":
-            bwd = (p, [cv, , av]) => [
-                undefined,
-                undefined,
-                nearestAngle(Math.atan2(p.y - cv.y, p.x - cv.x), av),
-            ];
+            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);

package/dist/ext/timeline.js

@@ -32,8 +32,8 @@ class TimelineImpl {
     }
 }
 function makeClip(spec, clock) {
-    const at = Num.from(spec.at);
-    const dur = Num.from(spec.dur);
+    const at = Num.coerce(spec.at);
+    const dur = Num.coerce(spec.dur);
     const end = Num.derive(() => at.value + dur.value);
     // Bidirectional span when both inputs are writable; RO derive when
     // either is read-only. Mirrors `ResolvedSpan`.