bireactive 0.3.0 → 0.3.2

package/dist/core/values/transform.js

@@ -1,10 +1,3 @@
-// transform.ts — reactive 2D transform.
-//
-// Invertibles (`add`, `sub`) return `: this` and ride on
-// `Cell#lens(fwd, bwd)`; chained calls compose into a lens chain.
-// 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, fieldLens, reader, readNow } from "../cell.js";
 import { Num } from "./num.js";
@@ -58,8 +51,6 @@ export const metric = (a, b) => vMetric(a.translate, b.translate) +
 const linearImpl = { add, sub, scale };
 export class Transform extends Cell {
     static traits = { linear: linearImpl, lerp, metric, equals };
-    /** Scalar `scale` is the `.scale` Vec field lens, not an eager method;
-     *  scalar-multiply via `Transform.lens(...)` or field writes. */
     constructor(v = DEFAULT) {
         super(v, { equals });
     }
@@ -89,13 +80,13 @@ export class Transform extends Cell {
     get opacity() {
         return fieldLens(this, "opacity", Num);
     }
-    /** Tween-builder, implied by the lerp trait. */
+    /** Tween-builder. */
     to(target, dur, ease) {
         return tween(this, target, dur, ease);
     }
 }
-/** Seed a `Writable<Transform>` from literal values. For reactive
- *  sources, use `Transform.lens(...)` or field-write composition. */
+/** Writable `Transform` from literal fields. For reactive sources use
+ *  `Transform.lens` or field writes. */
 export function transform(init) {
     const tr = new Transform();
     if (init) {

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

@@ -15,19 +15,18 @@ export declare class Tri extends Cell<V> {
     };
     readonly _t: typeof Tri.traits;
     constructor(v?: V);
-    /** Kleene negation. Involution; fixed at `"mixed"`. */
+    /** Kleene negation. */
     not(): this;
-    /** 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. */
+    /** AND-aggregate over writable `Bool`/`Tri` children: `true` if all are true,
+     *  `false` if all false, else `"mixed"`. A `true`/`false` write broadcasts to
+     *  every child (recursing into 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. */
+    /** OR-aggregate over writable `Bool`/`Tri` children: `true` if any is true,
+     *  `false` if all false, else `"mixed"`. A `true`/`false` write broadcasts to
+     *  every child; `"mixed"` is a no-op. */
     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"`. */
+/** Writable `Tri` from a literal (new cell) or existing writable (passed
+ *  through). Defaults to `"mixed"`. */
 export declare function tri(v?: Init<Tri>): Writable<Tri>;
 export {};

package/dist/core/values/tri.js

@@ -1,8 +1,3 @@
-// tri.ts — three-valued logical type (Kleene logic).
-//
-// `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, SKIP } from "../cell.js";
 const equals = (a, b) => a === b;
 /** Kleene negation: `true` / `false` swap, `"mixed"` is fixed. */
@@ -30,14 +25,13 @@ export class Tri extends Cell {
     constructor(v = "mixed") {
         super(v, { equals });
     }
-    /** Kleene negation. Involution; fixed at `"mixed"`. */
+    /** Kleene negation. */
     not() {
         return this.lens(not, not);
     }
-    /** 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. */
+    /** AND-aggregate over writable `Bool`/`Tri` children: `true` if all are true,
+     *  `false` if all false, else `"mixed"`. A `true`/`false` write broadcasts to
+     *  every child (recursing into nested aggregates); `"mixed"` is a no-op. */
     static allOf(parents) {
         return Tri.lens(parents, (vs) => {
             let anyT = false;
@@ -59,9 +53,9 @@ export class Tri extends Cell {
             return parents.map(() => target);
         });
     }
-    /** 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. */
+    /** OR-aggregate over writable `Bool`/`Tri` children: `true` if any is true,
+     *  `false` if all false, else `"mixed"`. A `true`/`false` write broadcasts to
+     *  every child; `"mixed"` is a no-op. */
     static anyOf(parents) {
         return Tri.lens(parents, (vs) => {
             let anyT = false;
@@ -86,8 +80,8 @@ export class Tri extends Cell {
         });
     }
 }
-/** Writable `Tri`. Strict factory: `Tri.value | Writable<Tri>` in,
- *  `Writable<Tri>` out. Default initial value is `"mixed"`. */
+/** Writable `Tri` from a literal (new cell) or existing writable (passed
+ *  through). Defaults to `"mixed"`. */
 export function tri(v = "mixed") {
     if (v instanceof Tri)
         return v;

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

@@ -21,6 +21,9 @@ export declare const scaleAbout: (v: V, p: V, k: number) => V;
  *  (y-down screen coords flip the visual sense). Returns `c` if `p` is
  *  inside or on the circle. */
 export declare function tangentPoint(p: V, c: V, r: number, side?: 1 | -1): V;
+/** Representative of cyclic angle `target` closest to `current`
+ *  (shortest-arc inverse). */
+export declare const nearestAngle: (target: number, current: number) => number;
 export declare class Vec extends Cell<V> {
     static traits: {
         linear: Linear<V>;
@@ -34,11 +37,9 @@ export declare class Vec extends Cell<V> {
     constructor(v?: V);
     add(b: Val<V>): this;
     sub(b: Val<V>): this;
-    /** Uniform scale by `k` about `pivot` (default origin). Inverse scales
-     *  by `1/k`; exact bijection for `k ≠ 0`. */
+    /** Uniform scale by `k` about `pivot` (default origin). Invertible when 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 by `angle` (radians) about `pivot` (default origin). */
     rotate(angle: Val<number>, pivot?: Val<V>): this;
     offset(dx: Val<number>, dy: Val<number>): this;
     up(n: Val<number>): this;
@@ -52,27 +53,11 @@ export declare class Vec extends Cell<V> {
     get x(): this extends import("../index.js").WritableBrand ? Writable<Num> : Num;
     get y(): this extends import("../index.js").WritableBrand ? Writable<Num> : Num;
     get magnitude(): Num;
-    /** Tween-builder; `this: Writable<Vec>` gates the call to writable
-     *  receivers. */
+    /** Tween-builder. */
     to(this: Writable<Vec>, target: V, dur: Val<number>, ease?: Easing): Tween<V>;
 }
-/** Writable `Vec` at `(x, y)`. Each axis is a literal `number` (lifted
- *  to a fresh seed) or an existing `Writable<Num>` (identity passthrough).
- *  RO sources are rejected at the type level — use `Vec.derive(...)` for
- *  reactive RO tracking, or `cell.value` to snapshot. Lock an axis with
- *  `Num.pin(c)`: `vec(slider, Num.pin(100))`. */
+/** Writable `Vec` at `(x, y)`. Each axis is a literal (new cell) or existing
+ *  writable (passed through); for read-only sources use `Vec.derive`. Lock an
+ *  axis with `Num.pin`: `vec(slider, Num.pin(100))`. */
 export declare function vec(x?: Init<Num>, y?: Init<Num>): Writable<Vec>;
-/** Policy for `polar`'s inverse — which inputs absorb a write:
- *
- *  - `rotate`    — c fixed; write r and a to land on target.
- *  - `translate` — r and a fixed; shift c by Δ.
- *  - `radial`    — c and a fixed; project the drag onto the ray.
- *  - `circular`  — c and r fixed; project the drag onto the circle. */
-export type PolarPolicy = "rotate" | "translate" | "radial" | "circular";
-/** Vec at polar offset from `center`: `center + (r·cos a, r·sin a)`.
- *  Bidirectional; each input is a literal (lifted to a fresh seed) or an
- *  existing writable cell. RO inputs are rejected at the type level.
- *  `policy` selects which inputs absorb writes; lock one with
- *  `Num.pin(c)`: `polar(c, Num.pin(100), a)`. */
-export declare function polar(center: Init<Vec>, r: Init<Num>, a: Init<Num>, policy?: PolarPolicy): Writable<Vec>;
 export {};

package/dist/core/values/vec.js

@@ -1,10 +1,5 @@
-// vec.ts — reactive 2D point.
-//
-// Invertibles return `: this` and ride on `Cell#lens(fwd, bwd)`;
-// chained calls compose into a lens chain. Field-lens getters use
-// `fieldLens()` (propagates writability); `cachedDerive()` wraps RO views.
 import { tween } from "../../animation/index.js";
-import { Cell, cachedDerive, fieldLens, reader, readNow, SKIP, } from "../cell.js";
+import { Cell, cachedDerive, fieldLens, 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 });
@@ -51,7 +46,7 @@ export function tangentPoint(p, c, r, side = -1) {
 const wrapToPi = (x) => x - 2 * Math.PI * Math.round(x / (2 * Math.PI));
 /** Representative of cyclic angle `target` closest to `current`
  *  (shortest-arc inverse). */
-const nearestAngle = (target, current) => current + wrapToPi(target - current);
+export const nearestAngle = (target, current) => current + wrapToPi(target - current);
 const linearImpl = { add, sub, scale };
 const packImpl = {
     dim: 2,
@@ -94,8 +89,7 @@ export class Vec extends Cell {
             return { x: n.x + o.x, y: n.y + o.y };
         });
     }
-    /** Uniform scale by `k` about `pivot` (default origin). Inverse scales
-     *  by `1/k`; exact bijection for `k ≠ 0`. */
+    /** Uniform scale by `k` about `pivot` (default origin). Invertible when k ≠ 0. */
     scale(k, pivot) {
         const kf = reader(k);
         const pf = pivot === undefined ? undefined : reader(pivot);
@@ -107,8 +101,7 @@ export class Vec extends Cell {
             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 by `angle` (radians) about `pivot` (default origin). */
     rotate(angle, pivot = ORIGIN) {
         const af = reader(angle);
         const pf = reader(pivot);
@@ -119,7 +112,6 @@ export class Vec extends Cell {
         const yf = reader(dy);
         return this.lens(v => ({ x: v.x + xf(), y: v.y + yf() }), n => ({ x: n.x - xf(), y: n.y - yf() }));
     }
-    // Axis-aligned offset sugar — same fwd/bwd shape as offset.
     up(n) {
         const f = reader(n);
         return this.lens(v => ({ x: v.x, y: v.y - f() }), o => ({ x: o.x, y: o.y + f() }));
@@ -157,68 +149,21 @@ export class Vec extends Cell {
     get magnitude() {
         return cachedDerive(this, "magnitude", Num, v => Math.hypot(v.x, v.y));
     }
-    /** Tween-builder; `this: Writable<Vec>` gates the call to writable
-     *  receivers. */
+    /** Tween-builder. */
     to(target, dur, ease) {
         return tween(this, target, dur, ease);
     }
 }
-/** @internal — 2-input lens over two writable `Num`s; `vec()` delegates
- *  here after lifting literals. */
+/** Lens combining two writable `Num`s into a `Vec`. */
 function axes(x, y) {
-    // The view fully reconstructs both axes (1-arg bwd ⇒ no source read).
     return Vec.lens([x, y], ([xv, yv]) => ({ x: xv, y: yv }), v => [v.x, v.y]);
 }
-/** Writable `Vec` at `(x, y)`. Each axis is a literal `number` (lifted
- *  to a fresh seed) or an existing `Writable<Num>` (identity passthrough).
- *  RO sources are rejected at the type level — use `Vec.derive(...)` for
- *  reactive RO tracking, or `cell.value` to snapshot. Lock an axis with
- *  `Num.pin(c)`: `vec(slider, Num.pin(100))`. */
+/** Writable `Vec` at `(x, y)`. Each axis is a literal (new cell) or existing
+ *  writable (passed through); for read-only sources use `Vec.derive`. Lock an
+ *  axis with `Num.pin`: `vec(slider, Num.pin(100))`. */
 export function vec(x = 0, y = 0) {
     if (typeof x === "number" && typeof y === "number") {
         return new Vec({ x, y });
     }
     return axes(num(x), num(y));
 }
-/** Vec at polar offset from `center`: `center + (r·cos a, r·sin a)`.
- *  Bidirectional; each input is a literal (lifted to a fresh seed) or an
- *  existing writable cell. RO inputs are rejected at the type level.
- *  `policy` selects which inputs absorb writes; lock one with
- *  `Num.pin(c)`: `polar(c, Num.pin(100), a)`. */
-export function polar(center, r, a, policy = "rotate") {
-    // Lift literals; already-writable inputs pass through by identity.
-    const cSig = center instanceof Vec ? center : vec(center.x, center.y);
-    const rSig = num(r);
-    const aSig = num(a);
-    const project = (c, rv, av) => ({
-        x: c.x + rv * Math.cos(av),
-        y: c.y + rv * Math.sin(av),
-    });
-    let bwd;
-    switch (policy) {
-        case "rotate":
-            bwd = (p, [cv, , av]) => {
-                const dx = p.x - cv.x;
-                const dy = p.y - cv.y;
-                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) }, SKIP, SKIP];
-            };
-            break;
-        case "radial":
-            bwd = (p, [cv, , av]) => {
-                const dx = p.x - cv.x;
-                const dy = p.y - cv.y;
-                return [SKIP, dx * Math.cos(av) + dy * Math.sin(av), SKIP];
-            };
-            break;
-        case "circular":
-            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/formats/lens.js

@@ -36,19 +36,16 @@ export function valueHub(initial) {
  *  the error regions. */
 export function formatSpoke(hub, adapter) {
     return lens(hub, {
-        init: ([v]) => fromValue(adapter, v),
-        step: ([v], c) => (v === c.synced ? c : absorb(adapter, c, v)),
-        fwd: (_vals, c) => c.text,
-        bwd: (target, _vals, c) => {
+        init: v => fromValue(adapter, v),
+        step: (v, c) => (v === c.synced ? c : absorb(adapter, c, v)),
+        fwd: (_v, c) => c.text,
+        bwd: (target, _v, c) => {
             const { tree, errors } = adapter.parse(target);
             if (errors.length === 0) {
                 const v = valueOf(tree);
-                return { updates: [v], complement: { text: target, tree, errors, synced: v } };
+                return { update: v, complement: { text: target, tree, errors, synced: v } };
             }
-            return {
-                updates: [SKIP],
-                complement: { text: target, tree, errors, synced: c.synced },
-            };
+            return { update: SKIP, complement: { text: target, tree, errors, synced: c.synced } };
         },
     });
 }

package/dist/index.d.ts

@@ -1,20 +1,9 @@
-/** @group Reactivity */
-/** @group Animation */
 export * from "./animation/index.js";
-/** @group Utilities */
 export * from "./assert/index.js";
-/** @group Rendering */
 export { type CodeOpts, CodeShape, code, codeStyles, type Token, tokenize } from "./code/index.js";
-/** @group Utilities */
-export * from "./coll.js";
 export * from "./core/index.js";
-/** @group Utilities */
 export * from "./ext/index.js";
-/** @group Shapes */
 export * from "./shapes/index.js";
-/** @group Rendering */
 export * from "./tex/index.js";
-/** @group Utilities */
 export { allNodes, atPath, isLeaf, leavesOf, node as treeNode, nodeCount, type TreeNode, walkTree, } from "./tree.js";
-/** @group Web */
 export * from "./web/index.js";

package/dist/index.js

@@ -1,22 +1,12 @@
-/** @group Reactivity */
-/** @group Animation */
+// API-reference groups are assigned by source folder in theme/group-by-source.mjs.
 export * from "./animation/index.js";
-/** @group Utilities */
 export * from "./assert/index.js";
 // `code` and `tex` both export `Part`; re-export `code`'s other symbols
 // explicitly so the wildcard below lets `tex`'s `Part` win.
-/** @group Rendering */
 export { CodeShape, code, codeStyles, tokenize } from "./code/index.js";
-/** @group Utilities */
-export * from "./coll.js";
 export * from "./core/index.js";
-/** @group Utilities */
 export * from "./ext/index.js";
-/** @group Shapes */
 export * from "./shapes/index.js";
-/** @group Rendering */
 export * from "./tex/index.js";
-/** @group Utilities */
 export { allNodes, atPath, isLeaf, leavesOf, node as treeNode, nodeCount, walkTree, } from "./tree.js";
-/** @group Web */
 export * from "./web/index.js";

package/dist/jsx-dev-runtime.d.ts

@@ -0,0 +1,2 @@
+export * from "./jsx-runtime.js";
+export { jsx as jsxDEV } from "./jsx-runtime.js";

package/dist/jsx-dev-runtime.js

@@ -0,0 +1,5 @@
+// Development entry for the automatic JSX runtime. esbuild/tsc import this when
+// `jsxDev` is enabled; the dev signature carries extra debug args we ignore, so
+// `jsxDEV` just forwards to `jsx`.
+export * from "./jsx-runtime.js";
+export { jsx as jsxDEV } from "./jsx-runtime.js";

package/dist/jsx-runtime.d.ts

@@ -0,0 +1,54 @@
+import { Cell } from "./core/cell.js";
+/** Marker for `<>…</>`; lowered to `jsx(Fragment, …)`. */
+export declare const Fragment: unique symbol;
+type Disposer = () => void;
+/** Register a teardown with the active scope (`mount` / `scope` / an `each`
+ *  item) — for raw `effect`s or listeners created in a component body, which
+ *  the JSX helpers otherwise track for you. No-op outside a scope. */
+export declare function onCleanup(fn: Disposer): void;
+type Props = Record<string, unknown> & {
+    children?: unknown;
+};
+type Component = (props: Props) => Node;
+/** Build a DOM node for one JSX element. */
+export declare function jsx(type: string | symbol | Component, props?: Props): Node;
+/** Static-children variant; behaviourally identical in a runtime builder. */
+export declare const jsxs: typeof jsx;
+/** Render `component` into `host`, collecting reactive teardowns. The returned
+ *  disposer releases them — call it on unmount (e.g. `disconnectedCallback`). */
+export declare function mount(component: () => Node, host: Node): Disposer;
+/** Run `fn` under a fresh reactive scope, returning its result and a disposer
+ *  for every effect created during it — `mount` without a host. `each` gives
+ *  each keyed item its own scope so its effects die when the item leaves. */
+export declare function scope<T>(fn: () => T): [T, Disposer];
+/** Keyed list rendering: keep `parent`'s children in sync with a reactive array,
+ *  reusing and reordering nodes by key, disposing those that leave. Each item is
+ *  rendered in its own `scope` (untracked from the list effect, so item-internal
+ *  reads don't retrigger the whole list). Attach via `ref`:
+ *  `<div ref={el => each(el, items, s => s.id, render)} />`. */
+export declare function each<T>(parent: Element, items: Cell<T[]> | (() => readonly T[]), key: (item: T, index: number) => string, render: (item: T, index: number) => Node): void;
+type Reactive<T> = T | Cell<T> | (() => T);
+export declare namespace JSX {
+    export type Element = Node;
+    export interface ElementChildrenAttribute {
+        children: unknown;
+    }
+    export interface IntrinsicAttributes {
+        children?: unknown;
+    }
+    export interface CommonProps {
+        class?: Reactive<string>;
+        style?: Reactive<string | Partial<CSSStyleDeclaration>>;
+        id?: Reactive<string>;
+        lens?: Cell<any>;
+        ref?: (el: Element) => void;
+        children?: unknown;
+        [attr: string]: any;
+    }
+    type Tag = keyof HTMLElementTagNameMap | keyof SVGElementTagNameMap;
+    export type IntrinsicElements = {
+        [K in Tag]: CommonProps;
+    };
+    export {};
+}
+export {};

package/dist/jsx-runtime.js

@@ -0,0 +1,219 @@
+// jsx-runtime.ts — minimal runtime JSX for bireactive (no compiler step).
+//
+// esbuild's automatic runtime (`jsxImportSource: "@bireactive"`) lowers JSX to
+// `jsx`/`jsxs`/`Fragment` calls; this module builds real DOM nodes and wires
+// reactive props and children through `effect`. The one binding with no React
+// analogue is the `lens` prop: a single bidirectional terminal — the dual of
+// the value-plus-onInput pair — that reads a writable cell forward into the
+// control and writes edits back, so a chain of lenses can be driven from the
+// leaf. Components are plain `props → Node`; reactive expressions are passed as
+// thunks (`{() => expr}`) or cells, since there is no compile step to wrap them.
+import { Cell, effect, untracked } from "./core/cell.js";
+/** Marker for `<>…</>`; lowered to `jsx(Fragment, …)`. */
+export const Fragment = Symbol.for("bireactive.jsx.Fragment");
+// The active mount scope: reactive teardowns created while building a tree are
+// collected here so `mount` can release them all on unmount. Non-reentrant —
+// `mount` saves/restores the previous owner around the render.
+let currentOwner = null;
+function track(d) {
+    currentOwner?.push(d);
+}
+/** Register a teardown with the active scope (`mount` / `scope` / an `each`
+ *  item) — for raw `effect`s or listeners created in a component body, which
+ *  the JSX helpers otherwise track for you. No-op outside a scope. */
+export function onCleanup(fn) {
+    track(fn);
+}
+/** Build a DOM node for one JSX element. */
+export function jsx(type, props) {
+    if (typeof type === "function")
+        return type(props ?? {});
+    if (type === Fragment) {
+        const frag = document.createDocumentFragment();
+        append(frag, props?.children);
+        return frag;
+    }
+    const el = document.createElement(type);
+    if (props)
+        for (const key in props)
+            applyProp(el, key, props[key]);
+    return el;
+}
+/** Static-children variant; behaviourally identical in a runtime builder. */
+export const jsxs = jsx;
+function applyProp(el, key, value) {
+    if (key === "children")
+        return append(el, value);
+    if (key === "ref") {
+        if (typeof value === "function")
+            value(el);
+        return;
+    }
+    if (key === "lens")
+        return bindLens(el, value);
+    if (key.startsWith("on") && typeof value === "function") {
+        el.addEventListener(key.slice(2).toLowerCase(), value);
+        return;
+    }
+    if (value instanceof Cell) {
+        track(effect(() => setProp(el, key, value.value)));
+        return;
+    }
+    if (typeof value === "function") {
+        track(effect(() => setProp(el, key, value())));
+        return;
+    }
+    setProp(el, key, value);
+}
+function setProp(el, key, value) {
+    if (key === "class" || key === "className") {
+        el.setAttribute("class", value == null ? "" : String(value));
+    }
+    else if (key === "style") {
+        if (value && typeof value === "object")
+            Object.assign(el.style, value);
+        else
+            el.setAttribute("style", value == null ? "" : String(value));
+    }
+    else if (key === "value") {
+        el.value = value == null ? "" : String(value);
+    }
+    else if (key === "checked" || key === "disabled" || key === "selected") {
+        // biome-ignore lint/suspicious/noExplicitAny: boolean DOM properties
+        el[key] = !!value;
+    }
+    else if (value == null || value === false) {
+        el.removeAttribute(key);
+    }
+    else {
+        el.setAttribute(key, value === true ? "" : String(value));
+    }
+}
+/** Append a child (array / Node / text / cell / thunk) to `parent`. */
+function append(parent, child) {
+    if (Array.isArray(child)) {
+        for (const c of child)
+            append(parent, c);
+    }
+    else if (child instanceof Node) {
+        parent.appendChild(child);
+    }
+    else if (child instanceof Cell) {
+        parent.appendChild(reactiveText(() => child.value));
+    }
+    else if (typeof child === "function") {
+        parent.appendChild(reactiveText(child));
+    }
+    else if (child != null && child !== false && child !== true) {
+        parent.appendChild(document.createTextNode(String(child)));
+    }
+}
+/** A text node whose content tracks `get()`. Primitive children only — the
+ *  minimal runtime does not reconcile dynamic element children. */
+function reactiveText(get) {
+    const node = document.createTextNode("");
+    track(effect(() => {
+        const v = get();
+        node.data = v == null ? "" : String(v);
+    }));
+    return node;
+}
+/** Two-way bind a form control to a writable cell: read forward into the
+ *  control, write back on input. The forward write is skipped while the
+ *  control is focused, so a live edit is never clobbered mid-drag (the
+ *  controlled-input focus guard, written once). */
+function bindLens(el, lens) {
+    const checkbox = el.type === "checkbox";
+    track(effect(() => {
+        const v = lens.value;
+        if (checkbox) {
+            el.checked = !!v;
+            return;
+        }
+        const next = v == null ? "" : String(v);
+        const root = el.getRootNode();
+        if (root.activeElement !== el && el.value !== next)
+            el.value = next;
+    }));
+    const evt = checkbox || el.tagName === "SELECT" ? "change" : "input";
+    el.addEventListener(evt, () => {
+        lens.value = checkbox
+            ? el.checked
+            : el.type === "range" || el.type === "number"
+                ? Number(el.value)
+                : el.value;
+    });
+}
+/** Render `component` into `host`, collecting reactive teardowns. The returned
+ *  disposer releases them — call it on unmount (e.g. `disconnectedCallback`). */
+export function mount(component, host) {
+    const [node, dispose] = scope(component);
+    host.appendChild(node);
+    return dispose;
+}
+/** Run `fn` under a fresh reactive scope, returning its result and a disposer
+ *  for every effect created during it — `mount` without a host. `each` gives
+ *  each keyed item its own scope so its effects die when the item leaves. */
+export function scope(fn) {
+    const prev = currentOwner;
+    const owner = [];
+    currentOwner = owner;
+    try {
+        return [
+            fn(),
+            () => {
+                for (const d of owner)
+                    d();
+                owner.length = 0;
+            },
+        ];
+    }
+    finally {
+        currentOwner = prev;
+    }
+}
+/** Keyed list rendering: keep `parent`'s children in sync with a reactive array,
+ *  reusing and reordering nodes by key, disposing those that leave. Each item is
+ *  rendered in its own `scope` (untracked from the list effect, so item-internal
+ *  reads don't retrigger the whole list). Attach via `ref`:
+ *  `<div ref={el => each(el, items, s => s.id, render)} />`. */
+export function each(parent, items, key, render) {
+    const read = typeof items === "function" ? items : () => items.value;
+    const cache = new Map();
+    const stop = effect(() => {
+        const arr = read();
+        const seen = new Set();
+        const nodes = [];
+        arr.forEach((item, i) => {
+            const k = key(item, i);
+            seen.add(k);
+            let entry = cache.get(k);
+            if (entry === undefined) {
+                const [node, dispose] = untracked(() => scope(() => render(item, i)));
+                entry = { node, dispose };
+                cache.set(k, entry);
+            }
+            nodes.push(entry.node);
+        });
+        for (const [k, entry] of cache) {
+            if (!seen.has(k)) {
+                entry.dispose();
+                cache.delete(k);
+            }
+        }
+        // Only touch the DOM when the ordered node set actually changed — re-inserting
+        // identical children mid-interaction would steal focus and reset clicks.
+        const cur = parent.childNodes;
+        let same = cur.length === nodes.length;
+        for (let i = 0; same && i < nodes.length; i++)
+            same = cur[i] === nodes[i];
+        if (!same)
+            parent.replaceChildren(...nodes);
+    });
+    track(() => {
+        stop();
+        for (const entry of cache.values())
+            entry.dispose();
+        cache.clear();
+    });
+}