bireactive 0.2.4 → 0.3.1

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);

package/dist/shapes/shape.js

@@ -1,5 +1,5 @@
 import { suspend } from "../animation/index.js";
-import { Box, BoxMath, Cell, cell, derive, effect, lazy, MatrixMath, mean, Num, readNow, transformBox, transformPoint, Vec, } from "../core/index.js";
+import { Box, boxEdgeFrom, boxUnion, Cell, cell, derive, effect, lazy, matrixCompose, mean, Num, readNow, SKIP, toMatrixString, transformBox, transformPoint, Vec, } from "../core/index.js";
 import { dashedPath } from "./dashed.js";
 import { tokens } from "./tokens.js";
 export const SVG_NS = "http://www.w3.org/2000/svg";
@@ -70,7 +70,7 @@ export class Shape {
                 const cs = this._children.value
                     .filter(c => !c.aside)
                     .map(c => transformBox(c.localFrame.value, c.box.value));
-                return cs.length ? BoxMath.union(...cs) : { x: 0, y: 0, w: 0, h: 0 };
+                return cs.length ? boxUnion(...cs) : { x: 0, y: 0, w: 0, h: 0 };
             }));
         this.box = boxSig;
         // Identity short-circuit avoids reading `origin` on no-transform groups.
@@ -79,18 +79,18 @@ export class Shape {
             const r = this.rotate.value;
             const sc = this.scale.value;
             if (t.x === 0 && t.y === 0 && r === 0 && sc.x === 1 && sc.y === 1) {
-                return MatrixMath.compose(t, r, sc, { x: 0, y: 0 });
+                return matrixCompose(t, r, sc, { x: 0, y: 0 });
             }
-            return MatrixMath.compose(t, r, sc, this.origin.value);
+            return matrixCompose(t, r, sc, this.origin.value);
         });
         this.disposers.push(effect(() => {
-            this.el.style.transform = MatrixMath.toMatrixString(this.localFrame.value);
+            this.el.style.transform = toMatrixString(this.localFrame.value);
             this.el.style.opacity = String(this.opacity.value);
         }));
     }
     /** Parent-frame perimeter point toward `target`; tighter shapes override. */
     boundary(toward) {
-        return Vec.derive(() => BoxMath.edgeFrom(transformBox(this.localFrame.value, this.box.value), toward.value));
+        return Vec.derive(() => boxEdgeFrom(transformBox(this.localFrame.value, this.box.value), toward.value));
     }
     #makeAnchor(u, v) {
         // Reads box/localFrame/translate; writes only translate, shifted by the
@@ -103,8 +103,8 @@ export class Shape {
             const local = { x: b.x + u * b.w, y: b.y + v * b.h };
             const currentWorld = transformPoint(m, local);
             return [
-                undefined,
-                undefined,
+                SKIP,
+                SKIP,
                 {
                     x: tNow.x + (target.x - currentWorld.x),
                     y: tNow.y + (target.y - currentWorld.y),

package/dist/web/diagram.js

@@ -146,8 +146,8 @@ export class Diagram extends HTMLElement {
     view(w, h) {
         if (this.#viewSet)
             return this.#viewBox;
-        const ws = Num.from(w);
-        const hs = Num.from(h);
+        const ws = Num.coerce(w);
+        const hs = Num.coerce(h);
         effect(() => this.setViewBox(0, 0, ws.value, hs.value));
         this.#viewSet = true;
         return this.#viewBox;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bireactive",
-  "version": "0.2.4",
+  "version": "0.3.1",
   "description": "Bi-directional reactive programming.",
   "type": "module",
   "main": "./dist/index.js",
@@ -11,6 +11,18 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./automerge": {
+      "types": "./dist/automerge/index.d.ts",
+      "import": "./dist/automerge/index.js"
+    },
+    "./jsx-runtime": {
+      "types": "./dist/jsx-runtime.d.ts",
+      "import": "./dist/jsx-runtime.js"
+    },
+    "./jsx-dev-runtime": {
+      "types": "./dist/jsx-dev-runtime.d.ts",
+      "import": "./dist/jsx-dev-runtime.js"
+    },
     "./package.json": "./package.json"
   },
   "sideEffects": false,
@@ -21,7 +33,9 @@
   ],
   "scripts": {
     "dev": "vite --host",
-    "site": "vite build && typedoc",
+    "site": "vite build && typedoc && vitepress build docs",
+    "docs": "typedoc && vitepress build docs",
+    "docs:dev": "typedoc && vitepress dev docs --port 5556",
     "preview": "vite preview",
     "prebuild": "node -e \"require('fs').rmSync('dist', { recursive: true, force: true })\"",
     "build": "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json --resolve-full-paths",
@@ -38,6 +52,9 @@
     "postversion": "npm publish && git push --follow-tags"
   },
   "dependencies": {
+    "@automerge/automerge-repo": "^2.6.0-subduction.34",
+    "@automerge/automerge-repo-network-broadcastchannel": "^2.6.0-subduction.34",
+    "@automerge/automerge-repo-storage-indexeddb": "^2.6.0-subduction.34",
     "prism-esm": "^1.29.0-fix.6",
     "temml": "^0.13.3"
   },
@@ -54,9 +71,14 @@
     "reactive-framework-test-suite": "^0.0.2",
     "tsc-alias": "^1.8.17",
     "typedoc": "^0.28.19",
+    "typedoc-plugin-markdown": "^4.12.0",
+    "typedoc-vitepress-theme": "^1.1.3",
     "typescript": "^6.0.3",
     "vite": "^7.3.3",
     "vite-node": "^5.3.0",
+    "vite-plugin-top-level-await": "^1.6.0",
+    "vite-plugin-wasm": "^3.6.0",
+    "vitepress": "^1.6.4",
     "vitest": "^4.1.7"
   },
   "keywords": [

package/dist/propagators/network.d.ts

@@ -1,52 +0,0 @@
-import { type Cell } from "../core/index.js";
-import type { Propagator } from "./propagator.js";
-type AnySignal = Cell<any>;
-export interface PropagatorsOpts {
-    /** Max fixpoint iterations per body run. Default 1000. Hitting
-     *  the cap throws — propagators never silently diverge. */
-    iterations?: number;
-    /** Don't auto-run on read changes; advance via `.step()`. For
-     *  animated solvers, narrowing demos, or batched offline runs. */
-    manual?: boolean;
-}
-export declare class Propagators {
-    private readonly _entries;
-    private readonly _maxIterations;
-    private readonly _manual;
-    private _network?;
-    /** Propagators added but not yet first-fired; drained on the body's
-     *  next run. */
-    private _firstFireQueue;
-    /** Undrained fresh writes. Auto mode drains inline in the body;
-     *  manual mode persists between `step()` calls. */
-    private _pendingFresh;
-    constructor(opts?: PropagatorsOpts);
-    /** Add one or more propagators (combinators returning arrays may be
-     *  spread). Each gets one atomic "first fire" in the body; later
-     *  passes are freshness-gated. Returns `this` for chaining. */
-    add(...props: readonly (Propagator | readonly Propagator[])[]): this;
-    /** Advance the fixpoint loop. Runs to convergence by default; pass
-     *  a smaller `maxIterations` to step N waves at a time. Only
-     *  meaningful in `manual` mode (auto drains inline). */
-    step(maxIterations?: number): void;
-    private _addOne;
-    /** Number of propagators currently in the network. */
-    get count(): number;
-    /** Tear down the underlying reactive driver. */
-    dispose(): void;
-    private _install;
-    /** Drain `_pendingFresh` wave by wave for up to `maxIterations`
-     *  passes. Each wave consumes the current fresh set and re-fires
-     *  any propagator whose expanded read-set intersects it. */
-    private _drain;
-}
-/** Thrown when the fixpoint loop hits its iteration cap. `pending`
- *  lists signals still changing on the last pass. */
-export declare class PropagatorDivergedError extends Error {
-    readonly pending: ReadonlySet<AnySignal>;
-    constructor(message: string, pending: ReadonlySet<AnySignal>);
-}
-export declare function propagators(opts?: PropagatorsOpts): Propagators;
-/** One-shot sugar for `propagators().add(...props)`. */
-export declare function propagate(...props: readonly (Propagator | readonly Propagator[])[]): Propagators;
-export {};

package/dist/propagators/network.js

@@ -1,185 +0,0 @@
-// network.ts — propagator network holder.
-//
-// A single `network()` whose body runs a fixpoint loop over the
-// registered propagators, bounded by an `iterations` fuel cap. Each
-// pass is freshness-gated: only propagators whose reads changed in
-// the prior pass re-run.
-//
-// At install time each propagator's `reads` is expanded transitively
-// (via `transitiveDeps()`) into the effective read-set used for
-// subscription and gating. Without this, a propagator reading a lens
-// chain wouldn't re-fire when a write inside the loop updates the
-// chain's parent — a silent freshness gap.
-//
-// The network body self-excludes its own writes; external writes
-// re-fire it normally.
-import { network as makeNetwork, transitiveDeps } from "../core/index.js";
-export class Propagators {
-    _entries = [];
-    _maxIterations;
-    _manual;
-    _network;
-    /** Propagators added but not yet first-fired; drained on the body's
-     *  next run. */
-    _firstFireQueue = [];
-    /** Undrained fresh writes. Auto mode drains inline in the body;
-     *  manual mode persists between `step()` calls. */
-    _pendingFresh = new Set();
-    constructor(opts = {}) {
-        this._maxIterations = opts.iterations ?? 1000;
-        this._manual = opts.manual ?? false;
-    }
-    /** Add one or more propagators (combinators returning arrays may be
-     *  spread). Each gets one atomic "first fire" in the body; later
-     *  passes are freshness-gated. Returns `this` for chaining. */
-    add(...props) {
-        const startIndex = this._entries.length;
-        const newDeps = new Set();
-        for (const p of props) {
-            if (Array.isArray(p))
-                for (const pp of p)
-                    this._addOne(pp, newDeps);
-            else
-                this._addOne(p, newDeps);
-        }
-        for (let i = startIndex; i < this._entries.length; i++) {
-            this._firstFireQueue.push(this._entries[i].p);
-        }
-        if (this._network === undefined) {
-            // Install fires the body once, draining _firstFireQueue.
-            this._install();
-        }
-        else {
-            this._network.subscribe(...newDeps);
-            // Flush so the queue gets first-fired at add() time, even in
-            // manual mode (the user's `step()` controls later narrowing).
-            this._network.flush();
-        }
-        return this;
-    }
-    /** Advance the fixpoint loop. Runs to convergence by default; pass
-     *  a smaller `maxIterations` to step N waves at a time. Only
-     *  meaningful in `manual` mode (auto drains inline). */
-    step(maxIterations = this._maxIterations) {
-        if (this._network === undefined)
-            return;
-        // Pull external-dirty signals in; manual mode otherwise sits on them.
-        this._network.flush();
-        this._drain(maxIterations);
-    }
-    _addOne(p, newDeps) {
-        const expanded = expandReads(p.reads);
-        this._entries.push({ p, expanded });
-        for (const s of expanded)
-            newDeps.add(s);
-    }
-    /** Number of propagators currently in the network. */
-    get count() {
-        return this._entries.length;
-    }
-    /** Tear down the underlying reactive driver. */
-    dispose() {
-        this._network?.dispose();
-        this._network = undefined;
-    }
-    _install() {
-        // Seed the topology with every current propagator's expanded
-        // reads; later adds grow it via `network.subscribe(...)`.
-        const allDeps = new Set();
-        for (const { expanded } of this._entries) {
-            for (const s of expanded)
-                allDeps.add(s);
-        }
-        this._network = makeNetwork([...allDeps], dirty => {
-            // 1) First-fire any propagators that were just added.
-            for (const p of this._firstFireQueue) {
-                const changed = runPropagator(p);
-                for (const w of changed)
-                    this._pendingFresh.add(w);
-            }
-            this._firstFireQueue = [];
-            // 2) Fold external-dirty into pending fresh.
-            for (const s of dirty)
-                this._pendingFresh.add(s);
-            // 3) Auto mode: drain to convergence. Manual: leave for step().
-            if (!this._manual)
-                this._drain(this._maxIterations);
-        }, { manual: this._manual });
-    }
-    /** Drain `_pendingFresh` wave by wave for up to `maxIterations`
-     *  passes. Each wave consumes the current fresh set and re-fires
-     *  any propagator whose expanded read-set intersects it. */
-    _drain(maxIterations) {
-        if (this._entries.length === 0)
-            return;
-        let iters = 0;
-        while (this._pendingFresh.size > 0 && iters < maxIterations) {
-            iters++;
-            const fresh = this._pendingFresh;
-            this._pendingFresh = new Set();
-            for (const { p, expanded } of this._entries) {
-                if (!hasExpandedFreshRead(expanded, fresh))
-                    continue;
-                const changed = runPropagator(p);
-                for (const w of changed)
-                    this._pendingFresh.add(w);
-            }
-        }
-        // Auto mode: didn't converge → throw. Manual mode: leftover sits
-        // in _pendingFresh until the next step().
-        if (!this._manual && iters >= this._maxIterations && this._pendingFresh.size > 0) {
-            const stuck = this._pendingFresh;
-            this._pendingFresh = new Set();
-            throw new PropagatorDivergedError(`Propagators: did not converge after ${this._maxIterations} iterations. ` +
-                `${stuck.size} cell(s) still changing.`, stuck);
-        }
-    }
-}
-/** Thrown when the fixpoint loop hits its iteration cap. `pending`
- *  lists signals still changing on the last pass. */
-export class PropagatorDivergedError extends Error {
-    pending;
-    constructor(message, pending) {
-        super(message);
-        this.pending = pending;
-        this.name = "PropagatorDivergedError";
-    }
-}
-/** Expand declared reads to include transitive deps (lens-chain
- *  parents). The result drives both subscription and fire-gating. */
-function expandReads(reads) {
-    const set = new Set();
-    for (const r of reads) {
-        for (const dep of transitiveDeps(r))
-            set.add(dep);
-    }
-    return [...set];
-}
-/** Run a propagator's `step()` and return the set of WRITE signals
- *  whose values actually changed. */
-function runPropagator(p) {
-    const before = new Array(p.writes.length);
-    for (let i = 0; i < p.writes.length; i++)
-        before[i] = p.writes[i].peek();
-    p.step();
-    const changed = new Set();
-    for (let i = 0; i < p.writes.length; i++) {
-        if (p.writes[i].peek() !== before[i])
-            changed.add(p.writes[i]);
-    }
-    return changed;
-}
-/** True iff any signal in the expanded read-set is fresh. */
-function hasExpandedFreshRead(expanded, fresh) {
-    for (const r of expanded)
-        if (fresh.has(r))
-            return true;
-    return false;
-}
-export function propagators(opts = {}) {
-    return new Propagators(opts);
-}
-/** One-shot sugar for `propagators().add(...props)`. */
-export function propagate(...props) {
-    return new Propagators().add(...props);
-}

package/dist/propagators/propagator.d.ts

@@ -1,12 +0,0 @@
-import type { Cell, Writable } from "../core/index.js";
-/** Plain object, no new types required: `reads`/`writes` declare the
- *  topology, `step()` does the work.
- *
- *  `Cell<any>` (not `unknown`) lets variant subtypes assign without
- *  casts; the framework only uses identity / `peek()`, never the type. */
-export interface Propagator {
-    readonly reads: readonly Cell<any>[];
-    readonly writes: readonly Cell<any>[];
-    step(): void;
-}
-export declare function propagator(reads: readonly Cell<any>[], writes: readonly Writable<Cell<any>>[], step: () => void): Propagator;

package/dist/propagators/propagator.js

@@ -1,16 +0,0 @@
-// propagator.ts — Propagator type + helpers.
-//
-// A propagator is a triple: `reads`, `writes`, and `step()`. The
-// network subscribes to `reads` and freshness-gates on them, and
-// detects output changes by peek-comparing `writes`.
-//
-// Propagators are plain objects over plain signal arrays (not
-// classes) — the non-coloring entry point: any existing signal can
-// participate without adopting a new type.
-export function propagator(
-// biome-ignore lint/suspicious/noExplicitAny: see header
-reads, 
-// biome-ignore lint/suspicious/noExplicitAny: see header
-writes, step) {
-    return { reads, writes, step };
-}

package/dist/propagators/range.d.ts

@@ -1,45 +0,0 @@
-import { type Cell, type Writable } from "../core/index.js";
-import { type Propagator } from "./propagator.js";
-/** An interval `[lo, hi]`. `[-Infinity, Infinity]` = unconstrained.
- *  `lo > hi` = contradiction (empty interval). */
-export type Range = readonly [number, number];
-export declare const RANGE_TOP: Range;
-export declare function rangeEq(a: Range, b: Range): boolean;
-/** Range ∩ Range = intersection (greatest-lower-bound under the lattice). */
-export declare function rangeMeet(a: Range, b: Range): Range;
-/** True if the range has no values (lo > hi). */
-export declare function rangeIsContradiction(r: Range): boolean;
-/** True if the range is a single value (lo === hi). */
-export declare function rangeIsExact(r: Range): boolean;
-/** Width of the interval, or Infinity if unbounded. */
-export declare function rangeWidth(r: Range): number;
-export type RangeCell = Writable<Cell<Range>>;
-/** Construct a Range cell. Optionally seed with bounds. */
-export declare function rangeCell(lo?: number, hi?: number): RangeCell;
-/** Merge `partial` into `cell` via lattice intersection. Throws on
- *  contradiction. */
-export declare function rangeMerge(cell: RangeCell, partial: Range): void;
-export declare class RangeContradiction extends Error {
-    readonly cell: RangeCell;
-    constructor(message: string, cell: RangeCell);
-}
-export declare function intervalAdd(a: Range, b: Range): Range;
-export declare function intervalSub(a: Range, b: Range): Range;
-/** `a + b = c` over interval cells. Three propagators that each
- *  narrow their output; order-independent. */
-export declare function intervalAdder(a: RangeCell, b: RangeCell, c: RangeCell): Propagator[];
-/** `a = b` over interval cells. Each direction narrows to the same
- *  intersection, so order doesn't matter. */
-export declare function intervalEq(a: RangeCell, b: RangeCell): Propagator[];
-/** Constrain a Range cell to a fixed interval. The propagator
- *  re-applies on every fire (subscribes to itself), so external
- *  writes that widen the cell get re-narrowed. */
-export declare function constrain(cell: RangeCell, lo: number, hi: number): Propagator;
-/** Sum of N range cells = total. N+1 propagators (total from parts,
- *  each part from total minus the others); order-independent. */
-export declare function intervalSum(parts: readonly RangeCell[], total: RangeCell): Propagator[];
-/** Bridge a Range cell to an exact Num: the Num reflects the Range's
- *  midpoint; writing the Num forces the Range to that singleton
- *  (which may contradict a narrower existing bound). For wiring a
- *  Range cell into a UI. */
-export declare function snap(rangeC: RangeCell, exact: Writable<Cell<number>>): Propagator[];

package/dist/propagators/range.js

@@ -1,147 +0,0 @@
-// range.ts — interval cells + interval combinators.
-//
-// A `Range` cell holds an interval `[lo, hi]` of partial knowledge.
-// Operations narrow (intersect) rather than replace, so propagators
-// fire in any order without losing info, and termination is
-// structural (a bounded finite-height lattice; every fire shrinks
-// an interval or no-ops).
-//
-// A Range cell is just `cell<[number, number]>` with custom
-// equality — no new type. The "merge not replace" semantic lives in
-// each combinator's step body.
-//
-// Adapter combinators (`snap`) bridge to exact Num cells, so a
-// system can propagate partial info internally while exposing exact
-// signals to renderers / drag handlers / lens chains.
-import { cell } from "../core/index.js";
-import { propagator } from "./propagator.js";
-export const RANGE_TOP = [Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY];
-export function rangeEq(a, b) {
-    return a[0] === b[0] && a[1] === b[1];
-}
-/** Range ∩ Range = intersection (greatest-lower-bound under the lattice). */
-export function rangeMeet(a, b) {
-    return [Math.max(a[0], b[0]), Math.min(a[1], b[1])];
-}
-/** True if the range has no values (lo > hi). */
-export function rangeIsContradiction(r) {
-    return r[0] > r[1];
-}
-/** True if the range is a single value (lo === hi). */
-export function rangeIsExact(r) {
-    return r[0] === r[1] && Number.isFinite(r[0]);
-}
-/** Width of the interval, or Infinity if unbounded. */
-export function rangeWidth(r) {
-    return r[1] - r[0];
-}
-/** Construct a Range cell. Optionally seed with bounds. */
-export function rangeCell(lo = Number.NEGATIVE_INFINITY, hi = Number.POSITIVE_INFINITY) {
-    return cell([lo, hi], { equals: rangeEq });
-}
-/** Merge `partial` into `cell` via lattice intersection. Throws on
- *  contradiction. */
-export function rangeMerge(cell, partial) {
-    const cur = cell.peek();
-    const merged = rangeMeet(cur, partial);
-    if (rangeIsContradiction(merged)) {
-        throw new RangeContradiction(`Range contradiction: cur=[${cur.join(",")}], partial=[${partial.join(",")}]`, cell);
-    }
-    cell.value = merged;
-}
-export class RangeContradiction extends Error {
-    cell;
-    constructor(message, cell) {
-        super(message);
-        this.cell = cell;
-        this.name = "RangeContradiction";
-    }
-}
-export function intervalAdd(a, b) {
-    return [a[0] + b[0], a[1] + b[1]];
-}
-export function intervalSub(a, b) {
-    return [a[0] - b[1], a[1] - b[0]];
-}
-/** `a + b = c` over interval cells. Three propagators that each
- *  narrow their output; order-independent. */
-export function intervalAdder(a, b, c) {
-    return [
-        propagator([a, b], [c], () => {
-            rangeMerge(c, intervalAdd(a.value, b.value));
-        }),
-        propagator([a, c], [b], () => {
-            rangeMerge(b, intervalSub(c.value, a.value));
-        }),
-        propagator([b, c], [a], () => {
-            rangeMerge(a, intervalSub(c.value, b.value));
-        }),
-    ];
-}
-/** `a = b` over interval cells. Each direction narrows to the same
- *  intersection, so order doesn't matter. */
-export function intervalEq(a, b) {
-    return [
-        propagator([a], [b], () => rangeMerge(b, a.value)),
-        propagator([b], [a], () => rangeMerge(a, b.value)),
-    ];
-}
-/** Constrain a Range cell to a fixed interval. The propagator
- *  re-applies on every fire (subscribes to itself), so external
- *  writes that widen the cell get re-narrowed. */
-export function constrain(cell, lo, hi) {
-    return propagator([cell], [cell], () => {
-        rangeMerge(cell, [lo, hi]);
-    });
-}
-/** Sum of N range cells = total. N+1 propagators (total from parts,
- *  each part from total minus the others); order-independent. */
-export function intervalSum(parts, total) {
-    const props = [];
-    // total ⊆ sum(parts)
-    props.push(propagator(parts, [total], () => {
-        let lo = 0;
-        let hi = 0;
-        for (const p of parts) {
-            lo += p.value[0];
-            hi += p.value[1];
-        }
-        rangeMerge(total, [lo, hi]);
-    }));
-    // For each part: part ⊆ total − sum(other parts)
-    for (let i = 0; i < parts.length; i++) {
-        const target = parts[i];
-        const others = parts.filter((_, j) => j !== i);
-        props.push(propagator([total, ...others], [target], () => {
-            let oLo = 0;
-            let oHi = 0;
-            for (const o of others) {
-                oLo += o.value[0];
-                oHi += o.value[1];
-            }
-            rangeMerge(target, [total.value[0] - oHi, total.value[1] - oLo]);
-        }));
-    }
-    return props;
-}
-/** Bridge a Range cell to an exact Num: the Num reflects the Range's
- *  midpoint; writing the Num forces the Range to that singleton
- *  (which may contradict a narrower existing bound). For wiring a
- *  Range cell into a UI. */
-export function snap(rangeC, exact) {
-    return [
-        // range → exact midpoint
-        propagator([rangeC], [exact], () => {
-            const [lo, hi] = rangeC.value;
-            const mid = Number.isFinite(lo) && Number.isFinite(hi) ? (lo + hi) / 2 : 0;
-            exact.value = mid;
-        }),
-        // exact → range (forced singleton)
-        propagator([exact], [rangeC], () => {
-            const v = exact.value;
-            rangeMerge(rangeC, [v, v]);
-        }),
-    ];
-}
-// No `lift` sugar: bundling a fresh cell + its propagators doesn't
-// fit the "combinator returns Propagator[]" shape. Wire snap() by hand.