bireactive 0.2.3 → 0.3.0

package/dist/propagators/lattice.js

@@ -0,0 +1,113 @@
+// lattice.ts — the partial-information substrate for real propagators.
+//
+// A propagator network is monotone: cells hold *partial knowledge* that
+// only ever sharpens. The thing that makes that work is a lattice —
+// a `top` (no information), a `meet` (combine two pieces of knowledge),
+// and a `bottom` test (the knowledge contradicts itself).
+//
+// Because `meet` only narrows and lattices here have well-founded
+// descent (finite sets shrink; intervals shrink toward a point),
+// fixpoint iteration TERMINATES by construction. No fuel cap, no
+// divergence panic — the structure of the lattice is the guarantee.
+//
+// Two instances cover everything downstream:
+//   • `interval`        — `[lo, hi]` numeric bounds (layout, ranges, layering)
+//   • `set(universe)`   — finite candidate sets (CSP, sudoku, type inference)
+//
+// A `LatticeCell<T>` is a plain `cell<T>` tagged with its lattice (via a
+// WeakMap), so `merge()` and the solver can narrow generically without a
+// new cell type — the non-coloring property is preserved.
+import { cell } from "../core/index.js";
+const latticeOf = new WeakMap();
+/** The lattice a cell was minted with, or `undefined` for a plain cell. */
+export function latticeFor(c) {
+    return latticeOf.get(c);
+}
+/** Mint a cell over `lat`, seeded at `top` (no information) by default. */
+export function latticeCell(lat, init = lat.top) {
+    const c = cell(init, { equals: lat.equals });
+    latticeOf.set(c, lat);
+    return c;
+}
+/** Narrow `c` by `info` (monotone meet). No-ops when nothing sharpens, so
+ *  it's safe to call in any order and any number of times. Returns true
+ *  iff the cell actually narrowed. */
+export function merge(c, info) {
+    const lat = latticeOf.get(c);
+    if (lat === undefined)
+        throw new Error("merge: cell was not minted via latticeCell");
+    const cur = c.peek();
+    const next = lat.meet(cur, info);
+    if (lat.equals(next, cur))
+        return false;
+    c.value = next;
+    return true;
+}
+/** True when the cell's knowledge has collapsed to a contradiction. */
+export function isContradiction(c) {
+    const lat = latticeOf.get(c);
+    return lat?.isBottom(c.peek()) ?? false;
+}
+/** True when the cell still holds no information (its lattice `top`). */
+export function isTop(c) {
+    const lat = latticeOf.get(c);
+    if (lat === undefined)
+        return false;
+    return lat.equals(c.peek(), lat.top);
+}
+/** Float slop so a hair of rounding doesn't read as a contradiction. */
+const EPS = 1e-9;
+export const interval = {
+    top: [Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY],
+    meet: (a, b) => [Math.max(a[0], b[0]), Math.min(a[1], b[1])],
+    equals: (a, b) => a[0] === b[0] && a[1] === b[1],
+    isBottom: a => a[0] > a[1] + EPS,
+};
+/** Interval cell, optionally seeded with bounds (defaults to `top`). */
+export function intervalCell(lo = Number.NEGATIVE_INFINITY, hi = Number.POSITIVE_INFINITY) {
+    return latticeCell(interval, [lo, hi]);
+}
+/** Width of an interval (`Infinity` if unbounded, negative if bottom). */
+export function width(i) {
+    return i[1] - i[0];
+}
+/** A single value, or `undefined` when the interval isn't a point. */
+export function point(i) {
+    return i[1] - i[0] <= EPS && Number.isFinite(i[0]) ? (i[0] + i[1]) / 2 : undefined;
+}
+// ── set lattice ─────────────────────────────────────────────────────
+/** A finite candidate-set lattice over `universe`. `top` is the whole
+ *  universe (all candidates open); `meet` intersects; bottom is empty.
+ *  Height is `|universe|`, so narrowing always terminates. */
+export function set(universe) {
+    const top = new Set(universe);
+    const eq = (a, b) => {
+        if (a === b)
+            return true;
+        if (a.size !== b.size)
+            return false;
+        for (const v of a)
+            if (!b.has(v))
+                return false;
+        return true;
+    };
+    return {
+        top,
+        meet: (a, b) => {
+            const [small, big] = a.size <= b.size ? [a, b] : [b, a];
+            const out = new Set();
+            for (const v of small)
+                if (big.has(v))
+                    out.add(v);
+            return out;
+        },
+        equals: eq,
+        isBottom: a => a.size === 0,
+    };
+}
+/** Candidate-set cell over `universe`, seeded with `init` (defaults to
+ *  the whole universe). */
+export function setCell(universe, init) {
+    const lat = set(universe);
+    return latticeCell(lat, init === undefined ? lat.top : new Set(init));
+}

package/dist/propagators/layout.d.ts

@@ -1,32 +1,6 @@
 import { type Box, type Read } from "../core/index.js";
-import { type Propagator } from "./propagator.js";
+import { type Propagator } from "./solver.js";
 type ValOrSig = number | Read<number>;
-/** Item in an `hstack` / `vstack`. Bare `Box` uses defaults (grow 1,
- *  shrink 1, no min/max); tag for per-item flex. Per-item opts are
- *  plain numbers (not reactive). */
-export type StackItem = Box | {
-    box: Box;
-    grow?: number;
-    shrink?: number;
-    min?: number;
-    max?: number;
-};
-export interface StackOpts {
-    /** Space between adjacent items. Default 0. */
-    gap?: ValOrSig;
-    /** Padding inside container on each side. Default 0. */
-    padding?: ValOrSig;
-    /** Cross-axis alignment. Default "start". */
-    align?: "start" | "center" | "end" | "stretch";
-    /** "fit" (default): items grow/shrink to fill container.
-     *  "hug": items keep their authored size; container resizes. */
-    mode?: "fit" | "hug";
-}
-/** Horizontal CSS-flex stack: per-item grow/shrink/min/max along the
- *  main axis, cross-axis handled by `align`. */
-export declare function hstack(c: Box, items: readonly StackItem[], opts?: StackOpts): Propagator;
-/** Vertical stack — top-to-bottom version of `hstack`. */
-export declare function vstack(c: Box, items: readonly StackItem[], opts?: StackOpts): Propagator;
 export interface GridOpts {
     /** Cells per row. */
     cols: number;

package/dist/propagators/layout.js

@@ -1,184 +1,15 @@
-// layout.ts — Box-relational layout combinators.
+// layout.ts — rigid Box-relational combinators.
 //
-// Every combinator operates on `Box` value-types. Reactive opts
-// (`gap`, `padding`, …) accept a number or a Num signal.
-//
-//   const c = box(0, 0, 300, 200);
-//   const items = [box(), box(), box()];
-//   p.add(hstack(c, items, { gap: 8, align: "stretch" }));
-//
-// `hstack` / `vstack` are CSS-flex-shaped (per-item grow/shrink vs
-// min/max). For rigid edge-to-edge layouts use `attach`,
-// `centerInside`, etc.
+// The bidirectional, whole-box anchoring relations (edge-to-edge,
+// centring, insets, grids). Flex lives in `flex.ts`; these are the
+// fixed structural pieces you compose around it. Reactive opts (`gap`,
+// `padding`, …) accept a number or a Num signal.
 import { isCell, readNow, } from "../core/index.js";
-import { propagator } from "./propagator.js";
+import { propagator } from "./solver.js";
 const asW = (n) => n;
 function readDeps(...vs) {
     return vs.filter(isCell);
 }
-function clamp(v, lo, hi) {
-    return Math.min(Math.max(v, lo), hi);
-}
-function specs(items) {
-    return items.map(it => "box" in it
-        ? {
-            box: it.box,
-            grow: it.grow ?? 1,
-            shrink: it.shrink ?? 1,
-            min: it.min ?? 0,
-            max: it.max ?? Number.POSITIVE_INFINITY,
-        }
-        : { box: it, grow: 1, shrink: 1, min: 0, max: Number.POSITIVE_INFINITY });
-}
-/** Horizontal CSS-flex stack: per-item grow/shrink/min/max along the
- *  main axis, cross-axis handled by `align`. */
-export function hstack(c, items, opts = {}) {
-    return _stack(c, items, opts, "horizontal");
-}
-/** Vertical stack — top-to-bottom version of `hstack`. */
-export function vstack(c, items, opts = {}) {
-    return _stack(c, items, opts, "vertical");
-}
-function _stack(c, rawItems, opts, dir) {
-    const items = specs(rawItems);
-    const horizontal = dir === "horizontal";
-    const mainPos = (b) => asW(horizontal ? b.x : b.y);
-    const mainSize = (b) => asW(horizontal ? b.w : b.h);
-    const crossPos = (b) => asW(horizontal ? b.y : b.x);
-    const crossSize = (b) => asW(horizontal ? b.h : b.w);
-    const mode = opts.mode ?? "fit";
-    const alignKind = opts.align ?? "start";
-    const reads = [
-        mainPos(c),
-        mainSize(c),
-        crossPos(c),
-        crossSize(c),
-        ...items.map(it => mainSize(it.box)),
-        ...items.map(it => crossSize(it.box)),
-        ...readDeps(opts.gap ?? 0, opts.padding ?? 0),
-    ];
-    const writes = [];
-    for (const it of items) {
-        writes.push(asW(mainPos(it.box)));
-        if (mode === "fit")
-            writes.push(asW(mainSize(it.box)));
-        writes.push(asW(crossPos(it.box)));
-        if (alignKind === "stretch")
-            writes.push(asW(crossSize(it.box)));
-    }
-    return propagator(reads, writes, () => {
-        const gap = readNow(opts.gap ?? 0);
-        const pad = readNow(opts.padding ?? 0);
-        const n = items.length;
-        let sizes;
-        if (mode === "fit") {
-            // Start each item at its hypothetical size (current main-size,
-            // clamped to [min, max]).
-            sizes = new Array(n);
-            let sumW = 0;
-            for (let i = 0; i < n; i++) {
-                const it = items[i];
-                const w0 = clamp(mainSize(it.box).value, it.min, it.max);
-                sizes[i] = w0;
-                sumW += w0;
-            }
-            const slack = mainSize(c).value - 2 * pad - (n - 1) * gap - sumW;
-            if (slack > 1e-9) {
-                // Grow.
-                let remaining = slack;
-                const eligible = new Set();
-                for (let i = 0; i < n; i++) {
-                    if (items[i].grow > 0 && sizes[i] < items[i].max)
-                        eligible.add(i);
-                }
-                while (remaining > 1e-9 && eligible.size > 0) {
-                    let weights = 0;
-                    for (const i of eligible)
-                        weights += items[i].grow;
-                    if (weights === 0)
-                        break;
-                    let absorbed = 0;
-                    for (const i of [...eligible]) {
-                        const share = (remaining * items[i].grow) / weights;
-                        const newW = Math.min(sizes[i] + share, items[i].max);
-                        absorbed += newW - sizes[i];
-                        sizes[i] = newW;
-                        if (newW >= items[i].max)
-                            eligible.delete(i);
-                    }
-                    if (absorbed < 1e-9)
-                        break;
-                    remaining -= absorbed;
-                }
-            }
-            else if (slack < -1e-9) {
-                // Shrink.
-                let remaining = -slack;
-                const eligible = new Set();
-                for (let i = 0; i < n; i++) {
-                    if (items[i].shrink > 0 && sizes[i] > items[i].min)
-                        eligible.add(i);
-                }
-                while (remaining > 1e-9 && eligible.size > 0) {
-                    let weights = 0;
-                    for (const i of eligible)
-                        weights += items[i].shrink;
-                    if (weights === 0)
-                        break;
-                    let absorbed = 0;
-                    for (const i of [...eligible]) {
-                        const share = (remaining * items[i].shrink) / weights;
-                        const newW = Math.max(sizes[i] - share, items[i].min);
-                        absorbed += sizes[i] - newW;
-                        sizes[i] = newW;
-                        if (newW <= items[i].min)
-                            eligible.delete(i);
-                    }
-                    if (absorbed < 1e-9)
-                        break;
-                    remaining -= absorbed;
-                }
-            }
-        }
-        else {
-            // hug: item sizes drive container.
-            sizes = items.map(it => clamp(mainSize(it.box).value, it.min, it.max));
-            let total = 2 * pad + (n - 1) * gap;
-            for (const s of sizes)
-                total += s;
-            mainSize(c).value = total;
-        }
-        // Place items along main axis.
-        let cursor = mainPos(c).value + pad;
-        for (let i = 0; i < n; i++) {
-            mainPos(items[i].box).value = cursor;
-            if (mode === "fit")
-                mainSize(items[i].box).value = sizes[i];
-            cursor += sizes[i] + gap;
-        }
-        // Cross-axis alignment.
-        const cBase = crossPos(c).value + pad;
-        const cAvail = crossSize(c).value - 2 * pad;
-        for (const it of items) {
-            const itSize = crossSize(it.box).value;
-            switch (alignKind) {
-                case "start":
-                    crossPos(it.box).value = cBase;
-                    break;
-                case "center":
-                    crossPos(it.box).value = cBase + (cAvail - itSize) / 2;
-                    break;
-                case "end":
-                    crossPos(it.box).value = cBase + cAvail - itSize;
-                    break;
-                case "stretch":
-                    crossPos(it.box).value = cBase;
-                    crossSize(it.box).value = cAvail;
-                    break;
-            }
-        }
-    });
-}
 /** Regular grid: items placed in a `cols`-wide grid. Cells equal-size,
  *  computed from container minus padding and gaps. */
 export function grid(c, items, opts) {

package/dist/propagators/numeric.d.ts

@@ -0,0 +1,17 @@
+import { type Interval, type LatticeCell } from "./lattice.js";
+import { type Propagator } from "./solver.js";
+type I = LatticeCell<Interval>;
+/** `x ∈ [lo, hi]`. Self-applying, so a widening write gets re-narrowed. */
+export declare function bound(x: I, lo: number, hi: number): Propagator;
+/** Pin `x` to a single value. */
+export declare function fix(x: I, v: number): Propagator;
+/** `a = b`. Each side narrows to the intersection, so order is irrelevant. */
+export declare function equal(a: I, b: I): Propagator[];
+/** `a + gap ≤ b`. Narrows `a` from above and `b` from below. */
+export declare function order(a: I, b: I, gap?: number): Propagator[];
+/** `a + b = c`. Three narrowers; any two bound the third. */
+export declare function add(a: I, b: I, c: I): Propagator[];
+/** `Σ parts = whole`. N+1 narrowers: whole from the parts, and each part
+ *  from whole minus the others. Order-independent. */
+export declare function total(parts: readonly I[], whole: I): Propagator[];
+export {};

package/dist/propagators/numeric.js

@@ -0,0 +1,93 @@
+// numeric.ts — the handful of interval atoms.
+//
+// Every relation here narrows interval cells via `merge` and nothing
+// else, so each is monotone and the whole set composes into bigger
+// relations that inherit termination and order-independence for free.
+//
+// These are the primitives layout and graph layering desugar to:
+//   bound   — x ∈ [lo, hi]
+//   equal   — a = b            (alignment)
+//   order   — a + gap ≤ b      (spacing / ordering / packing / layering)
+//   add     — a + b = c        (offsets, content sizes)
+//   total   — Σ parts + slack = whole   (flex main axis, distribution)
+import { merge } from "./lattice.js";
+import { propagator } from "./solver.js";
+const ninf = Number.NEGATIVE_INFINITY;
+const pinf = Number.POSITIVE_INFINITY;
+/** `x ∈ [lo, hi]`. Self-applying, so a widening write gets re-narrowed. */
+export function bound(x, lo, hi) {
+    return propagator([x], [x], () => {
+        merge(x, [lo, hi]);
+    });
+}
+/** Pin `x` to a single value. */
+export function fix(x, v) {
+    return bound(x, v, v);
+}
+/** `a = b`. Each side narrows to the intersection, so order is irrelevant. */
+export function equal(a, b) {
+    return [
+        propagator([a], [b], () => {
+            merge(b, a.value);
+        }),
+        propagator([b], [a], () => {
+            merge(a, b.value);
+        }),
+    ];
+}
+/** `a + gap ≤ b`. Narrows `a` from above and `b` from below. */
+export function order(a, b, gap = 0) {
+    return [
+        propagator([b], [a], () => {
+            merge(a, [ninf, b.value[1] - gap]);
+        }),
+        propagator([a], [b], () => {
+            merge(b, [a.value[0] + gap, pinf]);
+        }),
+    ];
+}
+/** `a + b = c`. Three narrowers; any two bound the third. */
+export function add(a, b, c) {
+    return [
+        propagator([a, b], [c], () => {
+            merge(c, [a.value[0] + b.value[0], a.value[1] + b.value[1]]);
+        }),
+        propagator([a, c], [b], () => {
+            merge(b, [c.value[0] - a.value[1], c.value[1] - a.value[0]]);
+        }),
+        propagator([b, c], [a], () => {
+            merge(a, [c.value[0] - b.value[1], c.value[1] - b.value[0]]);
+        }),
+    ];
+}
+/** `Σ parts = whole`. N+1 narrowers: whole from the parts, and each part
+ *  from whole minus the others. Order-independent. */
+export function total(parts, whole) {
+    if (parts.length === 0)
+        return [];
+    const props = [
+        propagator(parts, [whole], () => {
+            let lo = 0;
+            let hi = 0;
+            for (const p of parts) {
+                lo += p.value[0];
+                hi += p.value[1];
+            }
+            merge(whole, [lo, hi]);
+        }),
+    ];
+    for (let i = 0; i < parts.length; i++) {
+        const target = parts[i];
+        const others = parts.filter((_, j) => j !== i);
+        props.push(propagator([whole, ...others], [target], () => {
+            let oLo = 0;
+            let oHi = 0;
+            for (const o of others) {
+                oLo += o.value[0];
+                oHi += o.value[1];
+            }
+            merge(target, [whole.value[0] - oHi, whole.value[1] - oLo]);
+        }));
+    }
+    return props;
+}

package/dist/propagators/solver.d.ts

@@ -0,0 +1,51 @@
+import { type Cell } from "../core/index.js";
+type AnyCell = Cell<any>;
+/** Reads/writes declare the topology; `step()` narrows the writes. */
+export interface Propagator {
+    readonly reads: readonly Cell<any>[];
+    readonly writes: readonly Cell<any>[];
+    step(): void;
+}
+/** Plain-object propagator: no new cell type required to participate. */
+export declare function propagator(reads: readonly Cell<any>[], writes: readonly Cell<any>[], step: () => void): Propagator;
+export interface SolverOpts {
+    /** Safety bound on fixpoint waves for cyclic real-interval descent
+     *  that converges only in the limit. Default 10_000. Finite lattices
+     *  reach a fixpoint long before this. Hitting it stops with a sound
+     *  result — it never throws. */
+    maxWaves?: number;
+    /** Don't auto-run on read changes; advance via `.step()`. For animated
+     *  solvers and narrowing visualisations. */
+    manual?: boolean;
+}
+export declare class Solver {
+    private readonly _entries;
+    private readonly _maxWaves;
+    private readonly _manual;
+    private _network?;
+    private _firstFire;
+    private _fresh;
+    /** True iff the last drain hit `maxWaves` without reaching a fixpoint
+     *  (still sound, just not fully converged). */
+    stalled: boolean;
+    constructor(opts?: SolverOpts);
+    /** Register propagators (arrays from combinators may be spread). Each
+     *  first-fires once; later waves are freshness-gated. */
+    add(...props: readonly (Propagator | readonly Propagator[])[]): this;
+    /** Advance the fixpoint up to `waves` passes (default: to convergence).
+     *  Meaningful in `manual` mode; auto mode drains inline. */
+    step(waves?: number): void;
+    /** Cells whose knowledge has collapsed to a contradiction. */
+    contradictions(): AnyCell[];
+    /** True iff any participating cell is a contradiction. */
+    get feasible(): boolean;
+    get count(): number;
+    dispose(): void;
+    private _addOne;
+    private _install;
+    private _drain;
+}
+/** A solver holding `props`. */
+export declare function solve(...props: readonly (Propagator | readonly Propagator[])[]): Solver;
+export declare function solver(opts?: SolverOpts): Solver;
+export {};

package/dist/propagators/solver.js

@@ -0,0 +1,175 @@
+// solver.ts — the monotone fixpoint engine.
+//
+// A propagator declares the cells it `reads` and `writes` and a `step()`
+// that narrows its writes via `merge()`. The solver runs them to a
+// fixpoint, freshness-gated: only propagators whose reads narrowed in
+// the prior wave re-run.
+//
+// Termination is a property of the lattice, not a fuel cap. Finite-set
+// cells shrink to a floor; interval cells shrink toward a point. So a
+// run either reaches a fixpoint or (for cyclic real-interval descent
+// that only converges in the limit) stops at `maxWaves` holding a SOUND
+// over-approximation — never a wrong or oscillating value. There is no
+// `DivergedError`: monotone narrowing cannot diverge, only slow-converge.
+//
+// Reads are expanded transitively at install time (via `transitiveDeps`)
+// so a propagator reading a lens chain also re-fires when a parent of
+// that chain narrows — no silent freshness gaps.
+import { network as makeNetwork, transitiveDeps } from "../core/index.js";
+import { isContradiction } from "./lattice.js";
+/** Plain-object propagator: no new cell type required to participate. */
+export function propagator(
+// biome-ignore lint/suspicious/noExplicitAny: see header
+reads, 
+// biome-ignore lint/suspicious/noExplicitAny: see header
+writes, step) {
+    return { reads, writes, step };
+}
+export class Solver {
+    _entries = [];
+    _maxWaves;
+    _manual;
+    _network;
+    _firstFire = [];
+    _fresh = new Set();
+    /** True iff the last drain hit `maxWaves` without reaching a fixpoint
+     *  (still sound, just not fully converged). */
+    stalled = false;
+    constructor(opts = {}) {
+        this._maxWaves = opts.maxWaves ?? 10_000;
+        this._manual = opts.manual ?? false;
+    }
+    /** Register propagators (arrays from combinators may be spread). Each
+     *  first-fires once; later waves are freshness-gated. */
+    add(...props) {
+        const start = 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 = start; i < this._entries.length; i++)
+            this._firstFire.push(this._entries[i].p);
+        if (this._network === undefined) {
+            this._install();
+        }
+        else {
+            this._network.subscribe(...newDeps);
+            this._network.flush();
+        }
+        return this;
+    }
+    /** Advance the fixpoint up to `waves` passes (default: to convergence).
+     *  Meaningful in `manual` mode; auto mode drains inline. */
+    step(waves = this._maxWaves) {
+        if (this._network === undefined)
+            return;
+        this._network.flush();
+        this._drain(waves);
+    }
+    /** Cells whose knowledge has collapsed to a contradiction. */
+    contradictions() {
+        const out = new Set();
+        for (const { p } of this._entries) {
+            for (const w of p.writes)
+                if (isContradiction(w))
+                    out.add(w);
+            for (const r of p.reads)
+                if (isContradiction(r))
+                    out.add(r);
+        }
+        return [...out];
+    }
+    /** True iff any participating cell is a contradiction. */
+    get feasible() {
+        return this.contradictions().length === 0;
+    }
+    get count() {
+        return this._entries.length;
+    }
+    dispose() {
+        this._network?.dispose();
+        this._network = undefined;
+    }
+    _addOne(p, newDeps) {
+        const expanded = expandReads(p.reads);
+        this._entries.push({ p, expanded });
+        for (const s of expanded)
+            newDeps.add(s);
+    }
+    _install() {
+        const allDeps = new Set();
+        for (const { expanded } of this._entries)
+            for (const s of expanded)
+                allDeps.add(s);
+        this._network = makeNetwork([...allDeps], dirty => {
+            for (const p of this._firstFire) {
+                for (const w of runPropagator(p))
+                    this._fresh.add(w);
+            }
+            this._firstFire = [];
+            for (const s of dirty)
+                this._fresh.add(s);
+            if (!this._manual)
+                this._drain(this._maxWaves);
+        }, { manual: this._manual });
+    }
+    _drain(maxWaves) {
+        if (this._entries.length === 0)
+            return;
+        let waves = 0;
+        while (this._fresh.size > 0 && waves < maxWaves) {
+            waves++;
+            const fresh = this._fresh;
+            this._fresh = new Set();
+            for (const { p, expanded } of this._entries) {
+                if (!intersects(expanded, fresh))
+                    continue;
+                for (const w of runPropagator(p))
+                    this._fresh.add(w);
+            }
+        }
+        // Sound either way: leftover fresh just means more narrowing was
+        // available than `maxWaves` allowed. Flag it; never throw.
+        this.stalled = this._fresh.size > 0;
+        if (this.stalled)
+            this._fresh = new Set();
+    }
+}
+/** Expand declared reads to include transitive (lens-chain) parents. */
+function expandReads(reads) {
+    const out = new Set();
+    for (const r of reads)
+        for (const dep of transitiveDeps(r))
+            out.add(dep);
+    return [...out];
+}
+/** Run `step()`; return the writes whose value 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;
+}
+function intersects(expanded, fresh) {
+    for (const r of expanded)
+        if (fresh.has(r))
+            return true;
+    return false;
+}
+/** A solver holding `props`. */
+export function solve(...props) {
+    return new Solver().add(...props);
+}
+export function solver(opts = {}) {
+    return new Solver(opts);
+}

package/dist/schema/index.d.ts

@@ -0,0 +1 @@
+export { addField, addV, each, eachBy, type FieldMap, headField, headV, inField, into, mapElems, mapField, nestFields, nestV, type Obj, type OLens, onField, pipe, recurse, removeField, removeV, renameField, renameV, type SplitSpec, type Step, seq, splitField, splitV, toStep, type VLens, wrapField, wrapV, } from "./lens.js";

package/dist/schema/index.js

@@ -0,0 +1,3 @@
+// schema — composable, complement-carrying lenses between plain-POJO schema
+// versions. See lens.ts for the kit and the design rationale.
+export { addField, addV, each, eachBy, headField, headV, inField, into, mapElems, mapField, nestFields, nestV, onField, pipe, recurse, removeField, removeV, renameField, renameV, seq, splitField, splitV, toStep, wrapField, wrapV, } from "./lens.js";