bireactive 0.2.4 → 0.3.0

package/dist/schema/lens.d.ts

@@ -0,0 +1,121 @@
+import { type Cell, type Writable } from "../core/cell.js";
+/** A plain JSON-ish record. */
+export type Obj = Record<string, unknown>;
+/** A value-level bidirectional transform carrying complement `C`. */
+export interface VLens<S, V, C> {
+    init: (s: S) => C;
+    /** Refresh the complement from a (possibly externally-changed) source. */
+    step?: (s: S, c: C) => C;
+    fwd: (s: S, c: C) => V;
+    bwd: (v: V, s: S, c: C) => {
+        s: S;
+        c: C;
+    };
+}
+/** An object→object lens (the common case). */
+export type OLens = VLens<Obj, Obj, unknown>;
+/** Rename a top-level field. Complement-honest about a colliding target:
+ *  if the source already has `to`, that shadowed value is parked and
+ *  restored on the way back (so GetPut holds even on malformed input). */
+export declare function renameV(from: string, to: string): VLens<Obj, Obj, {
+    shadow: unknown;
+}>;
+/** A field a newer schema adds; the value lives in the complement. */
+export declare function addV(key: string, initial: unknown): VLens<Obj, Obj, {
+    val: unknown;
+}>;
+/** A field a newer schema drops; the value (and position) live in the complement. */
+export declare function removeV(key: string): VLens<Obj, Obj, {
+    val: unknown;
+    idx: number;
+}>;
+/** Move several top-level fields into a sub-object. Bijective. */
+export declare function nestV(keys: readonly string[], under: string): VLens<Obj, Obj, null>;
+/** How to split one string field into two and rejoin them. */
+export interface SplitSpec {
+    split: (whole: string) => [string, string];
+    join: (a: string, b: string) => string;
+}
+/** Split one string field into two. Complement-honest: it stores the chosen
+ *  halves AND the exact original string, so a clean read-write round-trip
+ *  reproduces the source verbatim (trailing spaces, odd separators) instead
+ *  of being re-guessed by `join(split(·))`. The lens Cambria couldn't make
+ *  bidirectional ("firstName/lastName → fullName runs reliably one way"). */
+export declare function splitV(key: string, into: readonly [string, string], spec: SplitSpec): VLens<Obj, Obj, {
+    a: string;
+    b: string;
+    whole: string;
+}>;
+/** A stateful 1→1 value transform on a single field's value. */
+export interface FieldMap<C> {
+    init: (srcVal: unknown) => C;
+    step?: (srcVal: unknown, c: C) => C;
+    fwd: (srcVal: unknown, c: C) => unknown;
+    bwd: (viewVal: unknown, srcVal: unknown, c: C) => {
+        src: unknown;
+        complement: C;
+    };
+}
+/** Apply a value-lens to a single field, optionally renaming the key. The
+ *  workhorse behind `mapField`, `wrapField`, and `into`. */
+export declare function onField<S, V, C>(key: string, viewKey: string, vl: VLens<S, V, C>): VLens<Obj, Obj, C>;
+/** Scalar → array. Forward wraps the scalar as the array head; the *tail*
+ *  (everything the older scalar schema can't see) lives in the complement.
+ *  Writing the scalar replaces only the head and CONSERVES the tail — the
+ *  consistency Cambria's `head`/`wrap` pair couldn't keep (its Appendix III
+ *  "defective implementation" clobbered or dropped the unseen elements). */
+export declare function wrapV(): VLens<unknown, unknown[], {
+    tail: unknown[];
+}>;
+/** Array → scalar head (the dual of `wrapV`). The tail stays in the source
+ *  array, so no complement is needed: the head view writes back as
+ *  `[head, ...tail]`, conserving the rest. Reorder or grow the array and the
+ *  scalar tracks the new head; edit the scalar and only the head moves. */
+export declare function headV(): VLens<unknown[], unknown, null>;
+/** Left-to-right composition of value-lenses. The complement type is the
+ *  (heterogeneous) product of the parts', so it's existential here. */
+export declare function seq(...lenses: VLens<Obj, Obj, any>[]): VLens<Obj, Obj, unknown>;
+/** Descend into a field and apply a value-lens to whatever lives there
+ *  (a nested object, or an array — see `each`). Cambria's `in`. */
+export declare function into<S, V, C>(key: string, vl: VLens<S, V, C>): VLens<Obj, Obj, C>;
+/** Apply an element lens to every item of an array, keyed by `by` for stable
+ *  identity. Inserts (new key), deletes (missing key), and reorders (view
+ *  order) all round-trip, and each element keeps its OWN complement across
+ *  the move — the array case Cambria flagged as unbuilt (`mapInto` plus
+ *  "merging or splitting arrays"). */
+export declare function eachBy(by: (e: Obj) => unknown, elem: VLens<Obj, Obj, any>): VLens<Obj[], Obj[], Map<unknown, unknown>>;
+/** Positional `each` (element i ↔ element i). Use `eachBy` when elements can
+ *  reorder; this is fine for stable structures (e.g. recursive trees). */
+export declare function each(elem: VLens<Obj, Obj, any>): VLens<Obj[], Obj[], unknown[]>;
+/** Build a self-referential lens. `recurse(self => …)` lets a lens use itself
+ *  for nested occurrences — e.g. rename a field at every level of a subtask
+ *  tree of arbitrary depth. Cambria's open "recursive schemas" case. */
+export declare function recurse(build: (self: OLens) => OLens): OLens;
+/** Lift a value-lens onto a reactive cell. */
+export declare function toStep<C>(vl: VLens<Obj, Obj, C>): Step;
+/** A migration step: a writable lens from one POJO schema to the next. */
+export type Step = (src: Writable<Cell<Obj>>) => Writable<Cell<Obj>>;
+/** Left-to-right composition of reactive steps (chains cells). */
+export declare function pipe(...steps: Step[]): Step;
+/** Rename a top-level field. */
+export declare function renameField(from: string, to: string): Step;
+/** Add a field the source can't represent (value parked in the complement). */
+export declare function addField(key: string, initial: unknown): Step;
+/** Drop a field (value + position parked in the complement). */
+export declare function removeField(key: string): Step;
+/** Move several top-level fields into a sub-object. */
+export declare function nestFields(keys: readonly string[], under: string): Step;
+/** Split one string field into two (complement-honest; see {@link splitV}). */
+export declare function splitField(key: string, into: readonly [string, string], spec: SplitSpec): Step;
+/** Scalar → array on a field, optionally renaming it (see {@link wrapV}). */
+export declare function wrapField(key: string, rename?: string): Step;
+/** Array → scalar head on a field, optionally renaming it (see {@link headV}). */
+export declare function headField(key: string, rename?: string): Step;
+/** A stateful 1→1 value transform on a single field, optionally renaming it. */
+export declare function mapField<C>(key: string, m: FieldMap<C> & {
+    rename?: string;
+}): Step;
+/** Apply a whole sub-migration inside a nested object field. Cambria's `in`. */
+export declare function inField(key: string, vl: VLens<Obj, Obj, unknown>): Step;
+/** Apply an element migration to every item of an array field, keyed by `by`. */
+export declare function mapElems(key: string, by: (e: Obj) => unknown, elem: VLens<Obj, Obj, any>): Step;

package/dist/schema/lens.js

@@ -0,0 +1,429 @@
+// schema/lens.ts — composable, complement-carrying lenses between plain POJOs.
+//
+// Two layers:
+//
+//   • VLens<S,V,C> — a *value-level* bidirectional transform carrying a
+//     complement `C` (what the forward direction drops). VLenses compose
+//     (`seq`), descend into a field (`into`), map over arrays element-wise
+//     (`each`/`eachBy`), and recurse (`recurse`). The complement of a
+//     composite is the product of its parts' complements, so a lossy
+//     pipeline still round-trips — the property Cambria lacked.
+//
+//   • Step — a VLens lifted onto a reactive cell (`toStep`). `pipe` chains
+//     Steps into the A→B→{C,D} reactive graph used by the demo.
+//
+// Orientation: the source `S` is the older / upstream schema; `fwd` builds
+// the newer view, `bwd` writes an edit back. Information a newer schema adds,
+// or distinctions an older one can't hold, lives in `C` — local view state,
+// never in the shared source.
+import { lens } from "../core/cell.js";
+/** Sentinel for "this key was absent" (distinct from an explicit `undefined`). */
+const ABSENT = Symbol("absent");
+// ── object helpers (order-preserving, pure) ─────────────────────────
+function omit(v, key) {
+    const out = {};
+    for (const k of Object.keys(v))
+        if (k !== key)
+            out[k] = v[k];
+    return out;
+}
+function replaceKey(v, oldKey, newKey, newVal) {
+    const out = {};
+    let placed = false;
+    for (const k of Object.keys(v)) {
+        if (k === oldKey) {
+            out[newKey] = newVal;
+            placed = true;
+        }
+        else if (k === newKey && oldKey !== newKey) {
+            // drop a colliding target slot; the rename owns this key now
+        }
+        else {
+            out[k] = v[k];
+        }
+    }
+    if (!placed)
+        out[newKey] = newVal;
+    return out;
+}
+function keyIndex(v, key) {
+    return Object.keys(v).indexOf(key);
+}
+/** Reinsert `key` (absent from `v`) at position `idx`. */
+function insertAt(v, key, val, idx) {
+    const keys = Object.keys(v).filter(k => k !== key);
+    const at = idx < 0 ? keys.length : Math.min(idx, keys.length);
+    keys.splice(at, 0, key);
+    const out = {};
+    for (const k of keys)
+        out[k] = k === key ? val : v[k];
+    return out;
+}
+function insertPair(v, key, ka, va, kb, vb) {
+    const out = {};
+    for (const k of Object.keys(v)) {
+        if (k === key) {
+            out[ka] = va;
+            out[kb] = vb;
+        }
+        else {
+            out[k] = v[k];
+        }
+    }
+    return out;
+}
+function collapsePair(v, ka, kb, key, whole) {
+    const out = {};
+    let placed = false;
+    for (const k of Object.keys(v)) {
+        if (k === ka || k === kb) {
+            if (!placed) {
+                out[key] = whole;
+                placed = true;
+            }
+        }
+        else {
+            out[k] = v[k];
+        }
+    }
+    if (!placed)
+        out[key] = whole;
+    return out;
+}
+function nestObj(v, keys, under) {
+    const set = new Set(keys);
+    const sub = {};
+    for (const k of keys)
+        if (k in v)
+            sub[k] = v[k];
+    const out = {};
+    let placed = false;
+    for (const k of Object.keys(v)) {
+        if (set.has(k)) {
+            if (!placed) {
+                out[under] = sub;
+                placed = true;
+            }
+        }
+        else {
+            out[k] = v[k];
+        }
+    }
+    if (!placed)
+        out[under] = sub;
+    return out;
+}
+function unnestObj(v, keys, under) {
+    const sub = v[under] ?? {};
+    const out = {};
+    for (const k of Object.keys(v)) {
+        if (k === under) {
+            for (const kk of keys)
+                out[kk] = sub[kk];
+        }
+        else {
+            out[k] = v[k];
+        }
+    }
+    return out;
+}
+// ── value-level primitives ──────────────────────────────────────────
+/** Rename a top-level field. Complement-honest about a colliding target:
+ *  if the source already has `to`, that shadowed value is parked and
+ *  restored on the way back (so GetPut holds even on malformed input). */
+export function renameV(from, to) {
+    return {
+        init: v => ({ shadow: to in v ? v[to] : ABSENT }),
+        step: v => ({ shadow: to in v ? v[to] : ABSENT }),
+        fwd: v => replaceKey(v, from, to, v[from]),
+        bwd: (t, _v, c) => {
+            let s = replaceKey(t, to, from, t[to]);
+            if (c.shadow !== ABSENT)
+                s = { ...s, [to]: c.shadow };
+            return { s, c };
+        },
+    };
+}
+/** A field a newer schema adds; the value lives in the complement. */
+export function addV(key, initial) {
+    return {
+        init: () => ({ val: initial }),
+        fwd: (v, c) => ({ ...v, [key]: c.val }),
+        bwd: t => ({ s: omit(t, key), c: { val: t[key] } }),
+    };
+}
+/** A field a newer schema drops; the value (and position) live in the complement. */
+export function removeV(key) {
+    const capture = (v) => ({ val: v[key], idx: keyIndex(v, key) });
+    return {
+        init: capture,
+        step: (v, c) => (key in v ? capture(v) : c),
+        fwd: v => omit(v, key),
+        bwd: (t, _v, c) => ({ s: insertAt(t, key, c.val, c.idx), c }),
+    };
+}
+/** Move several top-level fields into a sub-object. Bijective. */
+export function nestV(keys, under) {
+    return {
+        init: () => null,
+        fwd: v => nestObj(v, keys, under),
+        bwd: t => ({ s: unnestObj(t, keys, under), c: null }),
+    };
+}
+/** Split one string field into two. Complement-honest: it stores the chosen
+ *  halves AND the exact original string, so a clean read-write round-trip
+ *  reproduces the source verbatim (trailing spaces, odd separators) instead
+ *  of being re-guessed by `join(split(·))`. The lens Cambria couldn't make
+ *  bidirectional ("firstName/lastName → fullName runs reliably one way"). */
+export function splitV(key, into, spec) {
+    const [ka, kb] = into;
+    const part = (whole) => {
+        const [a, b] = spec.split(whole);
+        return { a, b, whole };
+    };
+    return {
+        init: v => part(String(v[key] ?? "")),
+        step: (v, c) => {
+            const whole = String(v[key] ?? "");
+            return whole === c.whole ? c : part(whole);
+        },
+        fwd: (v, c) => insertPair(v, key, ka, c.a, kb, c.b),
+        bwd: (t, _v, c) => {
+            const a = String(t[ka] ?? "");
+            const b = String(t[kb] ?? "");
+            // Parts unchanged ⇒ restore the original whole exactly (GetPut).
+            const whole = a === c.a && b === c.b ? c.whole : spec.join(a, b);
+            return { s: collapsePair(t, ka, kb, key, whole), c: { a, b, whole } };
+        },
+    };
+}
+/** Apply a value-lens to a single field, optionally renaming the key. The
+ *  workhorse behind `mapField`, `wrapField`, and `into`. */
+export function onField(key, viewKey, vl) {
+    return {
+        init: v => vl.init(v[key]),
+        step: (v, c) => (vl.step ? vl.step(v[key], c) : c),
+        fwd: (v, c) => replaceKey(v, key, viewKey, vl.fwd(v[key], c)),
+        bwd: (t, v, c) => {
+            const r = vl.bwd(t[viewKey], v[key], c);
+            return { s: replaceKey(t, viewKey, key, r.s), c: r.c };
+        },
+    };
+}
+function fieldMapToVL(m) {
+    return {
+        init: m.init,
+        step: m.step,
+        fwd: m.fwd,
+        bwd: (v, s, c) => {
+            const r = m.bwd(v, s, c);
+            return { s: r.src, c: r.complement };
+        },
+    };
+}
+/** Scalar → array. Forward wraps the scalar as the array head; the *tail*
+ *  (everything the older scalar schema can't see) lives in the complement.
+ *  Writing the scalar replaces only the head and CONSERVES the tail — the
+ *  consistency Cambria's `head`/`wrap` pair couldn't keep (its Appendix III
+ *  "defective implementation" clobbered or dropped the unseen elements). */
+export function wrapV() {
+    return {
+        init: () => ({ tail: [] }),
+        fwd: (s, c) => [s, ...c.tail],
+        bwd: arr => {
+            const a = Array.isArray(arr) ? arr : [arr];
+            return { s: a.length ? a[0] : null, c: { tail: a.slice(1) } };
+        },
+    };
+}
+/** Array → scalar head (the dual of `wrapV`). The tail stays in the source
+ *  array, so no complement is needed: the head view writes back as
+ *  `[head, ...tail]`, conserving the rest. Reorder or grow the array and the
+ *  scalar tracks the new head; edit the scalar and only the head moves. */
+export function headV() {
+    return {
+        init: () => null,
+        fwd: arr => (Array.isArray(arr) && arr.length ? arr[0] : null),
+        bwd: (head, arr) => ({ s: [head, ...(Array.isArray(arr) ? arr.slice(1) : [])], c: null }),
+    };
+}
+// ── combinators ──────────────────────────────────────────────────────
+/** Compose two value-lenses (the product complement is `[c1, c2]`). */
+function then2(l1, l2) {
+    return {
+        init: a => {
+            const c1 = l1.init(a);
+            return [c1, l2.init(l1.fwd(a, c1))];
+        },
+        step: (a, [c1, c2]) => {
+            const c1b = l1.step ? l1.step(a, c1) : c1;
+            const b = l1.fwd(a, c1b);
+            const c2b = l2.step ? l2.step(b, c2) : c2;
+            return [c1b, c2b];
+        },
+        fwd: (a, [c1, c2]) => l2.fwd(l1.fwd(a, c1), c2),
+        bwd: (d, a, [c1, c2]) => {
+            const b = l1.fwd(a, c1);
+            const r2 = l2.bwd(d, b, c2);
+            const r1 = l1.bwd(r2.s, a, c1);
+            return { s: r1.s, c: [r1.c, r2.c] };
+        },
+    };
+}
+/** Left-to-right composition of value-lenses. The complement type is the
+ *  (heterogeneous) product of the parts', so it's existential here. */
+// biome-ignore lint/suspicious/noExplicitAny: complements compose existentially
+export function seq(...lenses) {
+    if (lenses.length === 0) {
+        return { init: () => null, fwd: v => v, bwd: t => ({ s: t, c: null }) };
+    }
+    return lenses.reduce((acc, l) => then2(acc, l));
+}
+/** Descend into a field and apply a value-lens to whatever lives there
+ *  (a nested object, or an array — see `each`). Cambria's `in`. */
+export function into(key, vl) {
+    return onField(key, key, vl);
+}
+/** Apply an element lens to every item of an array, keyed by `by` for stable
+ *  identity. Inserts (new key), deletes (missing key), and reorders (view
+ *  order) all round-trip, and each element keeps its OWN complement across
+ *  the move — the array case Cambria flagged as unbuilt (`mapInto` plus
+ *  "merging or splitting arrays"). */
+export function eachBy(by, 
+// biome-ignore lint/suspicious/noExplicitAny: per-element complement is existential
+elem) {
+    return {
+        init: arr => {
+            const m = new Map();
+            for (const el of arr)
+                m.set(by(el), elem.init(el));
+            return m;
+        },
+        step: (arr, c) => {
+            const m = new Map();
+            for (const el of arr) {
+                const k = by(el);
+                const ci = c.has(k) ? c.get(k) : elem.init(el);
+                m.set(k, elem.step ? elem.step(el, ci) : ci);
+            }
+            return m;
+        },
+        fwd: (arr, c) => arr.map(el => elem.fwd(el, c.has(by(el)) ? c.get(by(el)) : elem.init(el))),
+        bwd: (view, arr, c) => {
+            const srcByKey = new Map();
+            for (const el of arr)
+                srcByKey.set(by(el), el);
+            const nc = new Map();
+            const s = view.map(vel => {
+                const k = by(vel);
+                const s0 = srcByKey.get(k) ?? {};
+                const ci = c.has(k) ? c.get(k) : elem.init(s0);
+                const r = elem.bwd(vel, s0, ci);
+                nc.set(k, r.c);
+                return r.s;
+            });
+            return { s, c: nc };
+        },
+    };
+}
+/** Positional `each` (element i ↔ element i). Use `eachBy` when elements can
+ *  reorder; this is fine for stable structures (e.g. recursive trees). */
+// biome-ignore lint/suspicious/noExplicitAny: per-element complement is existential
+export function each(elem) {
+    return {
+        init: arr => arr.map(el => elem.init(el)),
+        step: (arr, c) => arr.map((el, i) => {
+            const ci = i < c.length ? c[i] : elem.init(el);
+            return elem.step ? elem.step(el, ci) : ci;
+        }),
+        fwd: (arr, c) => arr.map((el, i) => elem.fwd(el, i < c.length ? c[i] : elem.init(el))),
+        bwd: (view, arr, c) => {
+            const nc = [];
+            const s = view.map((vel, i) => {
+                const s0 = arr[i] ?? {};
+                const ci = i < c.length ? c[i] : elem.init(s0);
+                const r = elem.bwd(vel, s0, ci);
+                nc.push(r.c);
+                return r.s;
+            });
+            return { s, c: nc };
+        },
+    };
+}
+/** Build a self-referential lens. `recurse(self => …)` lets a lens use itself
+ *  for nested occurrences — e.g. rename a field at every level of a subtask
+ *  tree of arbitrary depth. Cambria's open "recursive schemas" case. */
+export function recurse(build) {
+    // Lazy thunk: the body references `self`, whose methods defer to the built
+    // lens. Construction terminates; recursion only unfolds against finite data.
+    let built = null;
+    const self = {
+        init: s => (built ??= build(self)).init(s),
+        step: (s, c) => {
+            const b = (built ??= build(self));
+            return b.step ? b.step(s, c) : c;
+        },
+        fwd: (s, c) => (built ??= build(self)).fwd(s, c),
+        bwd: (v, s, c) => (built ??= build(self)).bwd(v, s, c),
+    };
+    return self;
+}
+// ── reactive lifting (cells) ─────────────────────────────────────────
+/** Lift a value-lens onto a reactive cell. */
+export function toStep(vl) {
+    return src => lens(src, {
+        init: ([v]) => vl.init(v),
+        step: ([v], c) => (vl.step ? vl.step(v, c) : c),
+        fwd: ([v], c) => vl.fwd(v, c),
+        bwd: (t, [v], c) => {
+            const r = vl.bwd(t, v, c);
+            return { updates: [r.s], complement: r.c };
+        },
+    });
+}
+/** Left-to-right composition of reactive steps (chains cells). */
+export function pipe(...steps) {
+    return src => steps.reduce((acc, step) => step(acc), src);
+}
+// ── public Step-returning kit (sugar over the value-level core) ──────
+/** Rename a top-level field. */
+export function renameField(from, to) {
+    return toStep(renameV(from, to));
+}
+/** Add a field the source can't represent (value parked in the complement). */
+export function addField(key, initial) {
+    return toStep(addV(key, initial));
+}
+/** Drop a field (value + position parked in the complement). */
+export function removeField(key) {
+    return toStep(removeV(key));
+}
+/** Move several top-level fields into a sub-object. */
+export function nestFields(keys, under) {
+    return toStep(nestV(keys, under));
+}
+/** Split one string field into two (complement-honest; see {@link splitV}). */
+export function splitField(key, into, spec) {
+    return toStep(splitV(key, into, spec));
+}
+/** Scalar → array on a field, optionally renaming it (see {@link wrapV}). */
+export function wrapField(key, rename) {
+    return toStep(onField(key, rename ?? key, wrapV()));
+}
+/** Array → scalar head on a field, optionally renaming it (see {@link headV}). */
+export function headField(key, rename) {
+    return toStep(onField(key, rename ?? key, headV()));
+}
+/** A stateful 1→1 value transform on a single field, optionally renaming it. */
+export function mapField(key, m) {
+    return toStep(onField(key, m.rename ?? key, fieldMapToVL(m)));
+}
+/** Apply a whole sub-migration inside a nested object field. Cambria's `in`. */
+export function inField(key, vl) {
+    return toStep(into(key, vl));
+}
+/** Apply an element migration to every item of an array field, keyed by `by`. */
+// biome-ignore lint/suspicious/noExplicitAny: per-element complement is existential
+export function mapElems(key, by, elem) {
+    return toStep(into(key, eachBy(by, elem)));
+}

package/dist/shapes/annular-sector.js

@@ -7,10 +7,10 @@ export class AnnularSector extends Shape {
     a0;
     a1;
     constructor(center, rOuter, rInner, a0, a1, opts = {}) {
-        const ro = Num.from(rOuter);
-        const ri = Num.from(rInner);
-        const a0s = Num.from(a0);
-        const a1s = Num.from(a1);
+        const ro = Num.coerce(rOuter);
+        const ri = Num.coerce(rInner);
+        const a0s = Num.coerce(a0);
+        const a1s = Num.coerce(a1);
         super("path", () => ({
             x: center.x.value - ro.value,
             y: center.y.value - ro.value,

package/dist/shapes/button.js

@@ -11,7 +11,7 @@ import { tokens } from "./tokens.js";
 export function button(pos, content, onClick, opts = {}) {
     const w = opts.width ?? 80;
     const h = opts.height ?? 26;
-    const size = Num.from(opts.size ?? 11);
+    const size = Num.coerce(opts.size ?? 11);
     const hovered = opts.hovered ?? cell(false);
     // Hover tint behind the border so outline weight stays constant.
     const g = group({ translate: pos }, rect(0, 0, w, h, {

package/dist/shapes/circle.js

@@ -4,7 +4,7 @@ import { Shape } from "./shape.js";
 export class Circle extends Shape {
     radius;
     constructor(center, radius, opts = {}) {
-        const r = Num.from(radius);
+        const r = Num.coerce(radius);
         super(opts.dashed ? "path" : "circle", () => ({
             x: center.x.value - r.value,
             y: center.y.value - r.value,

package/dist/shapes/handle.js

@@ -1,5 +1,5 @@
 // handle.* — writable derived shapes (draggable circles wired to a Vec).
-import { cell, mean, polar as polarLens, Vec, } from "../core/index.js";
+import { cell, mean, polar as polarLens, SKIP, Vec, } from "../core/index.js";
 import { Circle } from "./circle.js";
 import { drag } from "./interaction.js";
 const COLOR = "var(--bireactive-handle, #2563eb)";
@@ -51,7 +51,7 @@ const scaleHandle = (shape, radius = 40, opts) => {
     // Reads center and scale; writes only scale.
     const pos = Vec.lens([shape.center, shape.scale], vals => ({ x: vals[0].x + radius * vals[1].x, y: vals[0].y }), (target, vals) => {
         const k = Math.max(0.05, Math.abs(target.x - vals[0].x) / radius);
-        return [undefined, { x: k, y: k }];
+        return [SKIP, { x: k, y: k }];
     });
     return handleFn(pos, { cursor: "ew-resize", ...opts });
 };

package/dist/shapes/label.js

@@ -14,7 +14,7 @@ export class Label extends Shape {
             : typeof content === "function"
                 ? derive(content)
                 : cell(content);
-        const sizeSig = Num.from(opts.size ?? tokens.fontSize);
+        const sizeSig = Num.coerce(opts.size ?? tokens.fontSize);
         const a = opts.align ?? { x: 0.5, y: 0.5 };
         super("text", () => {
             const text = flattenText(contentSig.value);

package/dist/shapes/layout.js

@@ -1,5 +1,5 @@
 // Spatial composition primitives.
-import { Box, BoxMath, reader, transformBox } from "../core/index.js";
+import { Box, boxExpand, reader, transformBox } from "../core/index.js";
 /** Lay out `shapes` in a row/column. First stays put; the rest bind
  *  their `translate` reactively to sit `gap` past the previous.
  *  Reflows on size or anchor change. */
@@ -40,7 +40,7 @@ export function arrange(shapes, axis, opts = {}) {
 /** Inflate a Box on each side by `by`. */
 export function expand(b, by) {
     const byFn = reader(by);
-    return Box.derive(() => BoxMath.expand(b.value, byFn()));
+    return Box.derive(() => boxExpand(b.value, byFn()));
 }
 /** Split a Box along an axis into N reactive sub-Boxes.
  *

package/dist/shapes/rect.js

@@ -9,10 +9,10 @@ export class Rect extends Shape {
     h;
     corner;
     constructor(x, y, w, h, opts = {}) {
-        const xs = Num.from(x);
-        const ys = Num.from(y);
-        const ws = Num.from(w);
-        const hs = Num.from(h);
+        const xs = Num.coerce(x);
+        const ys = Num.coerce(y);
+        const ws = Num.coerce(w);
+        const hs = Num.coerce(h);
         super(opts.dashed ? "path" : "rect", () => ({ x: xs.value, y: ys.value, w: ws.value, h: hs.value }), opts, {
             origin: derive(() => ({
                 x: xs.value + ws.value / 2,
@@ -23,7 +23,7 @@ export class Rect extends Shape {
         this.y = ys;
         this.w = ws;
         this.h = hs;
-        this.corner = Num.from(opts.corner ?? tokens.corner);
+        this.corner = Num.coerce(opts.corner ?? tokens.corner);
         this.stroke(opts, true, {
             x: xs,
             y: ys,
@@ -123,8 +123,8 @@ export function rect(a, b, c, d, e) {
     if (a instanceof Vec) {
         const w = b;
         const h = c;
-        const ws = Num.from(w);
-        const hs = Num.from(h);
+        const ws = Num.coerce(w);
+        const hs = Num.coerce(h);
         return new Rect(derive(() => a.x.value - ws.value / 2), derive(() => a.y.value - hs.value / 2), ws, hs, d);
     }
     return new Rect(a, b, c, d, e);