bireactive 0.2.0 → 0.2.2

package/dist/core/values/pose.js

@@ -4,7 +4,8 @@
 // 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 } from "../signal.js";
+import { Cell, field } from "../cell.js";
+import { Num } from "./num.js";
 export const add = (a, b) => ({
     x: a.x + b.x,
     y: a.y + b.y,
@@ -69,6 +70,15 @@ export class Pose extends Cell {
     constructor(v = { x: 0, y: 0, theta: 0 }) {
         super(v, { equals });
     }
+    get x() {
+        return field(this, "x", Num);
+    }
+    get y() {
+        return field(this, "y", Num);
+    }
+    get theta() {
+        return field(this, "theta", Num);
+    }
 }
 /** Writable `Pose`. Literal seeds a fresh cell; existing `Pose` passes
  *  through by identity. RO sources are rejected at the type level — use

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

@@ -1,6 +1,5 @@
-import type { Easing } from "../../animation/index.js";
-import { type Tween } from "../anim.js";
-import { Cell, type Init, type Val, type Writable, type WritableBrand } from "../signal.js";
+import { type Easing, type Tween } from "../../animation/index.js";
+import { Cell, type Init, type Val, type Writable, type WritableBrand } from "../cell.js";
 import type { Linear, Pack } from "../traits.js";
 import { Bool } from "./bool.js";
 import { Num } from "./num.js";
@@ -44,7 +43,10 @@ export declare class Range extends Cell<V> {
     /** End endpoint. Writes preserve `lo` (end-knob semantics). */
     get hi(): this extends WritableBrand ? Writable<Num> : Num;
     get width(): Num;
-    get center(): Num;
+    /** Midpoint body-drag: read returns the center; write shifts the range
+     *  so the center matches (width preserved). `.start` is the lo-anchored
+     *  variant; `.lo` / `.hi` edit the endpoints. */
+    get center(): Writable<Num>;
     /** Translate by `by`. Reads shift the interval; writes shift back. */
     shift(by: Val<number>): this;
     /** Scale uniformly about the origin. Iso for `k ≠ 0`. */

package/dist/core/values/range.js

@@ -1,13 +1,12 @@
 // range.ts — reactive numeric interval `[lo, hi]`.
 //
 // Home for sliders, scrollbars, and timeline clip spans. Field lenses
-// give start-knob (`.lo`) and end-knob (`.hi`) drag; `.start` is the
-// body-drag (shifts both, preserving width); `.slider(t)` is the
-// bidirectional `t ↔ lo + t·(hi - lo)` iso. Traits: `linear`, `lerp`,
-// `equals`, `pack` (scalar-only).
-import { tween } from "../anim.js";
-import { Cell, isComputed, reader, readNow, } from "../signal.js";
-import { derived, field } from "../writable.js";
+// give start-knob (`.lo`) and end-knob (`.hi`) drag; `.start` / `.center`
+// are body-drags (shift both, preserving width — anchored at lo / midpoint
+// 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 { 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 });
@@ -70,10 +69,16 @@ export class Range extends Cell {
         return field(this, "hi", Num);
     }
     get width() {
-        return derived(this, "width", Num, width);
+        return cachedDerive(this, "width", Num, width);
     }
+    /** Midpoint body-drag: read returns the center; write shifts the range
+     *  so the center matches (width preserved). `.start` is the lo-anchored
+     *  variant; `.lo` / `.hi` edit the endpoints. */
     get center() {
-        return derived(this, "center", Num, center);
+        return Num.lens(this, center, (c, src) => {
+            const half = (src.hi - src.lo) / 2;
+            return { lo: c - half, hi: c + half };
+        });
     }
     /** Translate by `by`. Reads shift the interval; writes shift back. */
     shift(by) {
@@ -116,9 +121,9 @@ export class Range extends Cell {
      *  endpoint by `eps`). Literal / RO inputs yield a bare RO `Bool`. */
     contains(v) {
         if (v instanceof Num) {
-            // RO computed Num has no backward path → RO branch. Sources and
+            // RO Num has no backward path → RO branch. Sources and
             // writable lenses both accept write-back.
-            if (!isComputed(v)) {
+            if (!isReadonly(v)) {
                 return Bool.lens([this, v], (vals) => contains(vals[0], vals[1]), (target, vals) => {
                     const [r, n] = vals;
                     if (contains(r, n) === target)

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

@@ -1,4 +1,4 @@
-import { Cell, type Init, type Writable } from "../signal.js";
+import { Cell, type Init, type Writable } from "../cell.js";
 type V = string;
 export declare const equals: (a: V, b: V) => boolean;
 /** Reverse a string by Unicode code points. */

package/dist/core/values/str.js

@@ -16,7 +16,7 @@
 //   uppercase    — dual of lowercase
 //   words        — separator pattern between words
 //   sortedUnique — source positions + original case per unique word
-import { Cell } from "../signal.js";
+import { Cell } from "../cell.js";
 // Complement-carrying endo lens.
 //
 // The complement is state recorded forward from the source and consumed

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

@@ -1,4 +1,4 @@
-import type { Read, Writable } from "../signal.js";
+import type { Read, 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/transform.d.ts

@@ -1,6 +1,5 @@
-import type { Easing } from "../../animation/index.js";
-import { type Tween } from "../anim.js";
-import { Cell, type Inner, type Val, type Writable } from "../signal.js";
+import { type Easing, type Tween } from "../../animation/index.js";
+import { Cell, type Inner, type Val, type Writable } from "../cell.js";
 import type { Linear } from "../traits.js";
 import { Num } from "./num.js";
 import { Vec } from "./vec.js";

package/dist/core/values/transform.js

@@ -5,9 +5,8 @@
 // Field-lens getters use `field()`, so writability propagates through
 // nested chains
 // (`Transform.translate.x.value = 5` works on writable receivers).
-import { tween } from "../anim.js";
-import { Cell, reader, readNow } from "../signal.js";
-import { field } from "../writable.js";
+import { tween } from "../../animation/index.js";
+import { Cell, field, 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 = {

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

@@ -1,4 +1,4 @@
-import { Cell, type Init, type Writable } from "../signal.js";
+import { Cell, type Init, type Writable } from "../cell.js";
 import type { Bool } from "./bool.js";
 type V = boolean | "mixed";
 /** Kleene negation: `true` / `false` swap, `"mixed"` is fixed. */
@@ -17,13 +17,15 @@ export declare class Tri extends Cell<V> {
     constructor(v?: V);
     /** Kleene negation. Involution; fixed at `"mixed"`. */
     not(): this;
-    /** Aggregate over N writable Bools. Read: all-true → `true`,
-     *  all-false → `false`, disagreement → `"mixed"`. Write: `true` /
-     *  `false` broadcast to every parent; `"mixed"` is a no-op. */
-    static allOf(parents: readonly Bool[]): Writable<Tri>;
-    /** Dual of `allOf` (Kleene OR): any-true → `true`, all-false →
-     *  `false`, else `"mixed"`. Same broadcast write policy. */
-    static anyOf(parents: readonly Bool[]): Writable<Tri>;
+    /** Aggregate over N writable `Bool` / `Tri` children. Read: all-true →
+     *  `true`, all-false → `false`, any disagreement (or any child already
+     *  `"mixed"`) → `"mixed"`. Write: `true` / `false` broadcast to every
+     *  child, recursing through nested aggregates; `"mixed"` is a no-op. */
+    static allOf(parents: readonly (Bool | Tri)[]): Writable<Tri>;
+    /** Dual of `allOf` (Kleene OR) over `Bool` / `Tri` children: any-true →
+     *  `true`, all-false → `false`, else (or any child `"mixed"`) →
+     *  `"mixed"`. Same broadcast write policy. */
+    static anyOf(parents: readonly (Bool | Tri)[]): Writable<Tri>;
 }
 /** Writable `Tri`. Strict factory: `Tri.value | Writable<Tri>` in,
  *  `Writable<Tri>` out. Default initial value is `"mixed"`. */

package/dist/core/values/tri.js

@@ -3,13 +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`).
-//
-// Headline use: aggregate N booleans via `Tri.allOf` / `Tri.anyOf`
-// (all-agree → that value, disagreement → `"mixed"`). Writing the
-// aggregate broadcasts to every parent ("select all" / "deselect all");
-// writing `"mixed"` is a no-op. Morally `Maybe<Bool>` — the basis for
-// mixed-state checkbox trees and "loading" predicate states.
-import { Cell } from "../signal.js";
+import { Cell } 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);
@@ -40,14 +34,17 @@ export class Tri extends Cell {
     not() {
         return this.lens(not, not);
     }
-    /** Aggregate over N writable Bools. Read: all-true → `true`,
-     *  all-false → `false`, disagreement → `"mixed"`. Write: `true` /
-     *  `false` broadcast to every parent; `"mixed"` is a no-op. */
+    /** Aggregate over N writable `Bool` / `Tri` children. Read: all-true →
+     *  `true`, all-false → `false`, any disagreement (or any child already
+     *  `"mixed"`) → `"mixed"`. Write: `true` / `false` broadcast to every
+     *  child, recursing through nested aggregates; `"mixed"` is a no-op. */
     static allOf(parents) {
         return Tri.lens(parents, (vs) => {
             let anyT = false;
             let anyF = false;
             for (const v of vs) {
+                if (v === "mixed")
+                    return "mixed";
                 if (v)
                     anyT = true;
                 else
@@ -62,13 +59,16 @@ export class Tri extends Cell {
             return parents.map(() => target);
         });
     }
-    /** Dual of `allOf` (Kleene OR): any-true → `true`, all-false →
-     *  `false`, else `"mixed"`. Same broadcast write policy. */
+    /** Dual of `allOf` (Kleene OR) over `Bool` / `Tri` children: any-true →
+     *  `true`, all-false → `false`, else (or any child `"mixed"`) →
+     *  `"mixed"`. Same broadcast write policy. */
     static anyOf(parents) {
         return Tri.lens(parents, (vs) => {
             let anyT = false;
             let anyF = false;
             for (const v of vs) {
+                if (v === "mixed")
+                    return "mixed";
                 if (v)
                     anyT = true;
                 else

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

@@ -1,6 +1,5 @@
-import type { Easing } from "../../animation/index.js";
-import { type Tween } from "../anim.js";
-import { Cell, type Init, type Val, type Writable } from "../signal.js";
+import { type Easing, type Tween } from "../../animation/index.js";
+import { Cell, type Init, type Val, type Writable } from "../cell.js";
 import type { Linear, Pack, Pivotal } from "../traits.js";
 import { Num } from "./num.js";
 type V = {
@@ -15,6 +14,8 @@ export declare const metric: (a: V, b: V) => number;
 export declare const equals: (a: V, b: V) => boolean;
 export declare const normalize: (v: V) => V;
 export declare const perp: (v: V) => V;
+export declare const rotateAbout: (v: V, p: V, dθ: number) => V;
+export declare const scaleAbout: (v: V, p: V, k: number) => V;
 /** Tangent point on the circle (radius `r`, centre `c`) from external
  *  point `p`. `side: -1` picks the CCW tangent from `pc`, `+1` the CW
  *  (y-down screen coords flip the visual sense). Returns `c` if `p` is
@@ -33,7 +34,12 @@ export declare class Vec extends Cell<V> {
     constructor(v?: V);
     add(b: Val<V>): this;
     sub(b: Val<V>): this;
-    scale(k: Val<number>): this;
+    /** Uniform scale by `k` about `pivot` (default origin). Inverse scales
+     *  by `1/k`; exact bijection for `k ≠ 0`. */
+    scale(k: Val<number>, pivot?: Val<V>): this;
+    /** Rotate by `angle` (radians) about `pivot` (default origin). Inverse
+     *  rotates by `−angle`; exact bijection. */
+    rotate(angle: Val<number>, pivot?: Val<V>): this;
     offset(dx: Val<number>, dy: Val<number>): this;
     up(n: Val<number>): this;
     down(n: Val<number>): this;

package/dist/core/values/vec.js

@@ -2,10 +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); `derived()` wraps RO views.
-import { tween } from "../anim.js";
-import { Cell, reader, readNow } from "../signal.js";
-import { derived, field } from "../writable.js";
+// `field()` (propagates writability); `cachedDerive()` wraps RO views.
+import { tween } from "../../animation/index.js";
+import { Cell, cachedDerive, field, reader, readNow, } 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 });
@@ -21,6 +20,18 @@ export const normalize = (v) => {
     return m === 0 ? { x: 0, y: 0 } : { x: v.x / m, y: v.y / m };
 };
 export const perp = (v) => ({ x: v.y, y: -v.x });
+export const rotateAbout = (v, p, dθ) => {
+    const cos = Math.cos(dθ);
+    const sin = Math.sin(dθ);
+    const dx = v.x - p.x;
+    const dy = v.y - p.y;
+    return { x: p.x + cos * dx - sin * dy, y: p.y + sin * dx + cos * dy };
+};
+export const scaleAbout = (v, p, k) => ({
+    x: p.x + k * (v.x - p.x),
+    y: p.y + k * (v.y - p.y),
+});
+const ORIGIN = { x: 0, y: 0 };
 /** Tangent point on the circle (radius `r`, centre `c`) from external
  *  point `p`. `side: -1` picks the CCW tangent from `pc`, `+1` the CW
  *  (y-down screen coords flip the visual sense). Returns `c` if `p` is
@@ -50,19 +61,7 @@ const packImpl = {
     },
     write: (a, o) => ({ x: a[o], y: a[o + 1] }),
 };
-const pivotalImpl = {
-    rotateAbout: (v, p, dθ) => {
-        const cos = Math.cos(dθ);
-        const sin = Math.sin(dθ);
-        const dx = v.x - p.x;
-        const dy = v.y - p.y;
-        return { x: p.x + cos * dx - sin * dy, y: p.y + sin * dx + cos * dy };
-    },
-    scaleAbout: (v, p, k) => ({
-        x: p.x + k * (v.x - p.x),
-        y: p.y + k * (v.y - p.y),
-    }),
-};
+const pivotalImpl = { rotateAbout, scaleAbout };
 export class Vec extends Cell {
     static traits = {
         linear: linearImpl,
@@ -95,16 +94,26 @@ export class Vec extends Cell {
             return { x: n.x + o.x, y: n.y + o.y };
         });
     }
-    scale(k) {
+    /** Uniform scale by `k` about `pivot` (default origin). Inverse scales
+     *  by `1/k`; exact bijection for `k ≠ 0`. */
+    scale(k, pivot) {
         const kf = reader(k);
+        const pf = pivot === undefined ? undefined : reader(pivot);
         return this.lens(v => {
             const k = kf();
-            return { x: v.x * k, y: v.y * k };
+            return pf ? scaleAbout(v, pf(), k) : { x: v.x * k, y: v.y * k };
         }, n => {
             const k = kf();
-            return { x: n.x / k, y: n.y / k };
+            return pf ? scaleAbout(n, pf(), 1 / k) : { x: n.x / k, y: n.y / k };
         });
     }
+    /** Rotate by `angle` (radians) about `pivot` (default origin). Inverse
+     *  rotates by `−angle`; exact bijection. */
+    rotate(angle, pivot = ORIGIN) {
+        const af = reader(angle);
+        const pf = reader(pivot);
+        return this.lens(v => rotateAbout(v, pf(), af()), n => rotateAbout(n, pf(), -af()));
+    }
     offset(dx, dy) {
         const xf = reader(dx);
         const yf = reader(dy);
@@ -146,7 +155,7 @@ export class Vec extends Cell {
         return field(this, "y", Num);
     }
     get magnitude() {
-        return derived(this, "magnitude", Num, v => Math.hypot(v.x, v.y));
+        return cachedDerive(this, "magnitude", Num, v => Math.hypot(v.x, v.y));
     }
     /** Tween-builder; `this: Writable<Vec>` gates the call to writable
      *  receivers. */

package/dist/ext/timeline.js

@@ -1,7 +1,7 @@
 // Timeline + Clip. A timeline is a clock plus named clips (each an
 // `[at, at + dur)` interval); `yield* tl` advances the clock to
 // `duration`. `sequential({...})` produces cumulative-start specs.
-import { derive, isComputed, Num, num, Range, span, } from "../core/index.js";
+import { derive, isReadonly, Num, num, Range, span, } from "../core/index.js";
 class TimelineImpl {
     clock;
     duration;
@@ -36,8 +36,8 @@ function makeClip(spec, clock) {
     const dur = Num.from(spec.dur);
     const end = Num.derive(() => at.value + dur.value);
     // Bidirectional span when both inputs are writable; RO derive when
-    // either is computed. Mirrors `ResolvedSpan`.
-    const sp = isComputed(at) || isComputed(dur)
+    // either is read-only. Mirrors `ResolvedSpan`.
+    const sp = isReadonly(at) || isReadonly(dur)
         ? Range.derive(() => ({ lo: at.value, hi: at.value + dur.value }))
         : span(at, dur);
     const t = Num.derive(() => {

package/dist/index.d.ts

@@ -5,4 +5,5 @@ export * from "./core/index.js";
 export * from "./ext/index.js";
 export * from "./shapes/index.js";
 export * from "./tex/index.js";
+export { allNodes, atPath, isLeaf, leavesOf, node as treeNode, nodeCount, type TreeNode, walkTree, } from "./tree.js";
 export * from "./web/index.js";

package/dist/index.js

@@ -7,4 +7,5 @@ export * from "./core/index.js";
 export * from "./ext/index.js";
 export * from "./shapes/index.js";
 export * from "./tex/index.js";
+export { allNodes, atPath, isLeaf, leavesOf, node as treeNode, nodeCount, walkTree, } from "./tree.js";
 export * from "./web/index.js";

package/dist/propagators/layout.js

@@ -10,7 +10,7 @@
 // `hstack` / `vstack` are CSS-flex-shaped (per-item grow/shrink vs
 // min/max). For rigid edge-to-edge layouts use `attach`,
 // `centerInside`, etc.
-import { isCell, readNow } from "../core/index.js";
+import { isCell, readNow, } from "../core/index.js";
 import { propagator } from "./propagator.js";
 const asW = (n) => n;
 function readDeps(...vs) {

package/dist/shapes/handle.js

@@ -1,5 +1,5 @@
 // handle.* — writable derived shapes (draggable circles wired to a Vec).
-import { cell, centroidLens, midpointLens, polar as polarLens, Vec, } from "../core/index.js";
+import { cell, mean, polar as polarLens, Vec, } from "../core/index.js";
 import { Circle } from "./circle.js";
 import { drag } from "./interaction.js";
 const COLOR = "var(--bireactive-handle, #2563eb)";
@@ -32,10 +32,10 @@ const anchor = (shape, u, v, opts) => handleFn(shape.at(u, v), opts);
 /** Drag handle at the centroid of N shapes' visual centers; drags translate
  *  all shapes rigidly. Reads the centroid of visible positions (cf. `centroid`
  *  in `shape.ts`, which works on translate deltas). */
-const centroidHandle = (...shapes) => handleFn(centroidLens(shapes.map(s => s.center)));
+const centroidHandle = (...shapes) => handleFn(mean(shapes.map(s => s.center)));
 /** Drag handle at the midpoint of two writable Points — drags both
  *  along with it. */
-const midpoint = (a, b, opts) => handleFn(midpointLens(a, b), opts);
+const midpoint = (a, b, opts) => handleFn(mean([a, b]), opts);
 /** Rotation knob orbiting the shape's center at `radius`; drag to write
  *  `shape.rotate`. */
 const rotate = (shape, radius = 40, opts) => {
@@ -73,7 +73,7 @@ const tOnPath = (p, t, opts) => {
         }
         return bestT;
     };
-    const pos = Vec.lens([t], ([tv]) => p.pointAt(tv).value, target => [project(target)]);
+    const pos = Vec.lens(t, tv => p.pointAt(tv).value, target => project(target));
     return handleFn(pos, opts);
 };
 /** `handle(point)` is the atom; `.move`, `.centroid`, etc. are sugar. */

package/dist/shapes/shape.js

@@ -1,5 +1,5 @@
 import { suspend } from "../animation/index.js";
-import { Box, BoxMath, Cell, cell, centroidLens, compose, derive, effect, lazy, meanLens, Num, readNow, toMatrixString, transformBox, transformPoint, Vec, } from "../core/index.js";
+import { Box, BoxMath, Cell, cell, derive, effect, lazy, MatrixMath, mean, Num, readNow, 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";
@@ -79,12 +79,12 @@ 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 compose(t, r, sc, { x: 0, y: 0 });
+                return MatrixMath.compose(t, r, sc, { x: 0, y: 0 });
             }
-            return compose(t, r, sc, this.origin.value);
+            return MatrixMath.compose(t, r, sc, this.origin.value);
         });
         this.disposers.push(effect(() => {
-            this.el.style.transform = toMatrixString(this.localFrame.value);
+            this.el.style.transform = MatrixMath.toMatrixString(this.localFrame.value);
             this.el.style.opacity = String(this.opacity.value);
         }));
     }
@@ -276,15 +276,15 @@ export class Shape {
 // evenly to all members.
 /** Writable centroid of shapes' translates. */
 export function centroid(...shapes) {
-    return centroidLens(shapes.map(s => s.translate));
+    return mean(shapes.map(s => s.translate));
 }
 /** Writable mean rotation. */
 export function meanRotation(...shapes) {
-    return meanLens(Num, shapes.map(s => s.rotate));
+    return mean(shapes.map(s => s.rotate));
 }
 /** Writable mean scale. */
 export function meanScale(...shapes) {
-    return meanLens(Vec, shapes.map(s => s.scale));
+    return mean(shapes.map(s => s.scale));
 }
 /** Lift a `Val<T>` to a `Writable<Cls<T>>` for Shape's animatable surface.
  *  Writable passes through; literal seeds a cell; signal/thunk drives it via

package/dist/shapes/transitions.js

@@ -1,8 +1,8 @@
 // Bounded transitions. Initial pose is written synchronously; the return value
 // is the time-varying part only — a `Tween` (single-axis) or `Yieldable[]`
 // (multi-axis). Either way callers `yield transitionName(s)`.
-import { easeIn, easeInOut, easeOut } from "../animation/index.js";
-import { Dir, tween } from "../core/index.js";
+import { easeIn, easeInOut, easeOut, tween, } from "../animation/index.js";
+import { Dir } from "../core/index.js";
 /** Fade opacity 0 → 1. */
 export const fadeIn = (s, sec = 0.3, ease = easeOut) => s.opacity.to(1, sec, ease).from(0);
 /** Fade opacity 1 → 0. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bireactive",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Bi-directional reactive programming.",
   "type": "module",
   "main": "./src/index.ts",
@@ -40,7 +40,12 @@
     "bench": "node --expose-gc node_modules/.bin/vite-node",
     "typecheck": "tsc --noEmit --pretty",
     "fmt": "biome check --write .",
-    "prepublishOnly": "npm test && npm run build"
+    "prepublishOnly": "npm test && npm run build",
+    "release": "npm run release:patch",
+    "release:patch": "npm version patch",
+    "release:minor": "npm version minor",
+    "release:major": "npm version major",
+    "postversion": "npm publish && git push --follow-tags"
   },
   "dependencies": {
     "prism-esm": "^1.29.0-fix.6",

package/dist/core/introspect.d.ts

@@ -1,5 +0,0 @@
-import type { Cell } from "./signal.js";
-/** Every cell `s` transitively depends on, including itself. Raw cells
- *  return `{s}`; lens chains return the chain plus all parents. BFS,
- *  peeking each Computed to populate deps; the `seen` set breaks cycles. */
-export declare function transitiveDeps(s: Cell<unknown>): Set<Cell<unknown>>;

package/dist/core/introspect.js

@@ -1,31 +0,0 @@
-// introspect.ts — read-only inspection of a cell's dependency graph.
-//
-// Used by `Propagators` to expand declared reads into their transitive
-// parent set, so a propagator reading a lens chain reacts to writes that
-// touch the chain's parents but not the chain's identity. Inspection is
-// safe: it only reads engine state and peeks `.value` to populate deps
-// for lazy Computeds (idempotent).
-/** Every cell `s` transitively depends on, including itself. Raw cells
- *  return `{s}`; lens chains return the chain plus all parents. BFS,
- *  peeking each Computed to populate deps; the `seen` set breaks cycles. */
-export function transitiveDeps(s) {
-    const seen = new Set();
-    const queue = [s];
-    while (queue.length > 0) {
-        const cur = queue.shift();
-        if (seen.has(cur))
-            continue;
-        seen.add(cur);
-        // Cast to reach engine fields the typed Cell<T> shape doesn't surface.
-        const c = cur;
-        if (c.getter !== undefined) {
-            void cur.value;
-            let l = c.deps;
-            while (l !== undefined) {
-                queue.push(l.dep);
-                l = l.nextDep;
-            }
-        }
-    }
-    return seen;
-}

package/dist/core/lenses/factor-lens.d.ts

@@ -1,42 +0,0 @@
-import { type Cell, Num, Vec, type Writable } from "../index.js";
-export interface FactorLensOpts {
-    /** Per-input mobility weights. 0 = pinned input. Defaults to all 1. */
-    inputWeights?: readonly number[];
-    /** Levenberg-Marquardt damping on the M×M normal matrix. Default 1e-6. */
-    damping?: number;
-    /** Finite-difference epsilon. Default 1e-5. */
-    eps?: number;
-}
-export declare function factorLens(inputs: readonly Num[], forwards: readonly ((xs: readonly number[]) => number)[], opts?: FactorLensOpts): Writable<Num>[];
-export declare function meanDiffLens(a: Num, b: Num): {
-    mean: Writable<Num>;
-    diff: Writable<Num>;
-};
-export declare function procrustesLens(points: readonly Writable<Vec>[]): {
-    centroid: Writable<Vec>;
-    rotation: Writable<Num>;
-    scale: Writable<Num>;
-};
-export declare function bboxLens(points: readonly Writable<Vec>[]): {
-    center: Writable<Vec>;
-    size: Writable<Vec>;
-};
-export declare function procrustesJacobianLens(points: readonly Writable<Vec>[]): {
-    centroidX: Writable<Num>;
-    centroidY: Writable<Num>;
-    rotation: Writable<Num>;
-    scale: Writable<Num>;
-};
-type PoseV = {
-    x: number;
-    y: number;
-    theta: number;
-};
-export declare function bundleLens(pose: Writable<Cell<PoseV>>, rotateAbout: {
-    x: number;
-    y: number;
-}): {
-    position: Writable<Vec>;
-    rotation: Writable<Num>;
-};
-export {};