bireactive 0.2.3 → 0.3.0

package/dist/learn/mlp.js

@@ -0,0 +1,292 @@
+// mlp.ts — a tiny dense neural net, written as a stack of parametric lenses.
+//
+// Backprop is the lens pattern: each layer is a forward map (compute the
+// activation) paired with a backward map (pull a gradient back to the input
+// and deposit gradients on the parameters). Composing layers composes their
+// backward passes in reverse — reverse-mode autodiff *is* lens composition,
+// exactly the `pipe` of the schema kit but over differentiable maps. The
+// "complement" a layer needs for its backward pass is the cached forward
+// activation, stashed on the layer during `forward`.
+//
+// Deliberately coarse-grained: one layer = one matmul over Float64Arrays, not
+// a cell per scalar. The reactive/bidirectional payoff lives in the demos
+// (live data, watch-it-learn); this core stays plain and fast so it is cheap
+// to run and easy to test offline.
+/** Deterministic PRNG (mulberry32) so init and data are reproducible. */
+export function rng(seed) {
+    let a = seed >>> 0;
+    return () => {
+        a = (a + 0x6d2b79f5) | 0;
+        let t = Math.imul(a ^ (a >>> 15), 1 | a);
+        t ^= t + Math.imul(t ^ (t >>> 7), 61 | t);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+/** Standard normal via Box–Muller, driven by a uniform source. */
+export function gaussian(r) {
+    let u = 0;
+    let v = 0;
+    while (u === 0)
+        u = r();
+    while (v === 0)
+        v = r();
+    return Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
+}
+/** Build an MLP. `dims` is `[in, h1, …, out]`; hidden layers use `hidden`
+ *  activation, the output layer is `linear` (loss folds in the squashing). */
+export function mlp(dims, opts = {}) {
+    const hidden = opts.hidden ?? "tanh";
+    const r = rng(opts.seed ?? 1);
+    const layers = [];
+    for (let i = 0; i + 1 < dims.length; i++) {
+        const inDim = dims[i];
+        const outDim = dims[i + 1];
+        const act = i + 2 < dims.length ? hidden : "linear";
+        // He for relu, Xavier otherwise — keeps early activations well-scaled.
+        const scale = act === "relu" ? Math.sqrt(2 / inDim) : Math.sqrt(1 / inDim);
+        const W = new Float64Array(outDim * inDim);
+        for (let k = 0; k < W.length; k++)
+            W[k] = gaussian(r) * scale;
+        layers.push({
+            inDim,
+            outDim,
+            act,
+            W,
+            b: new Float64Array(outDim),
+            gW: new Float64Array(outDim * inDim),
+            gb: new Float64Array(outDim),
+            mW: new Float64Array(outDim * inDim),
+            vW: new Float64Array(outDim * inDim),
+            mb: new Float64Array(outDim),
+            vb: new Float64Array(outDim),
+            inBuf: new Float64Array(inDim),
+            preBuf: new Float64Array(outDim),
+            outBuf: new Float64Array(outDim),
+        });
+    }
+    return {
+        layers,
+        t: 0,
+        lr: opts.lr ?? 0.02,
+        beta1: 0.9,
+        beta2: 0.999,
+        l2: opts.l2 ?? 0,
+    };
+}
+/** Pointwise activation `a = σ(z)`. */
+export function applyAct(act, z) {
+    switch (act) {
+        case "tanh":
+            return Math.tanh(z);
+        case "relu":
+            return z > 0 ? z : 0;
+        case "sigmoid":
+            return 1 / (1 + Math.exp(-z));
+        default:
+            return z;
+    }
+}
+/** Activation derivative `σ'`, given the *output* `a` (cheap for tanh/sigmoid). */
+export function actGrad(act, a) {
+    switch (act) {
+        case "tanh":
+            return 1 - a * a;
+        case "relu":
+            return a > 0 ? 1 : 0;
+        case "sigmoid":
+            return a * (1 - a);
+        default:
+            return 1;
+    }
+}
+// Forward through one layer (the lens `fwd`): caches input + output as the
+// complement, returns the activation buffer (reused — copy if you must keep).
+function forwardLayer(L, x) {
+    L.inBuf.set(x);
+    for (let o = 0; o < L.outDim; o++) {
+        let z = L.b[o];
+        const base = o * L.inDim;
+        for (let i = 0; i < L.inDim; i++)
+            z += L.W[base + i] * x[i];
+        L.preBuf[o] = z;
+        L.outBuf[o] = applyAct(L.act, z);
+    }
+    return L.outBuf;
+}
+// Backward through one layer (the lens `bwd`): given dL/da, accumulate the
+// parameter gradients and return dL/dx for the previous layer.
+function backwardLayer(L, dOut) {
+    const dIn = new Float64Array(L.inDim);
+    for (let o = 0; o < L.outDim; o++) {
+        const dz = dOut[o] * actGrad(L.act, L.outBuf[o]);
+        L.gb[o] = L.gb[o] + dz;
+        const base = o * L.inDim;
+        for (let i = 0; i < L.inDim; i++) {
+            L.gW[base + i] = L.gW[base + i] + dz * L.inBuf[i];
+            dIn[i] = dIn[i] + L.W[base + i] * dz;
+        }
+    }
+    return dIn;
+}
+/** Forward pass: logits (pre-squash output) for one input vector. */
+export function forward(net, x) {
+    let a = x instanceof Float64Array ? x : Float64Array.from(x);
+    for (const L of net.layers)
+        a = forwardLayer(L, a);
+    return a;
+}
+/** Softmax of a logit vector (numerically stabilised). */
+export function softmax(logits) {
+    let max = Number.NEGATIVE_INFINITY;
+    for (const z of logits)
+        if (z > max)
+            max = z;
+    const out = new Float64Array(logits.length);
+    let sum = 0;
+    for (let i = 0; i < logits.length; i++) {
+        const e = Math.exp(logits[i] - max);
+        out[i] = e;
+        sum += e;
+    }
+    for (let i = 0; i < out.length; i++)
+        out[i] = out[i] / sum;
+    return out;
+}
+/** Class probabilities: sigmoid for a 1-logit (binary) net, else softmax.
+ *  A binary net returns `[P(class 1)]`. */
+export function predict(net, x) {
+    const logits = forward(net, x);
+    if (logits.length === 1)
+        return Float64Array.of(1 / (1 + Math.exp(-logits[0])));
+    return softmax(logits);
+}
+/** Argmax class for a multi-logit net, or `prob ≥ 0.5` for a binary net. */
+export function classify(net, x) {
+    const p = predict(net, x);
+    if (p.length === 1)
+        return p[0] >= 0.5 ? 1 : 0;
+    let best = 0;
+    for (let i = 1; i < p.length; i++)
+        if (p[i] > p[best])
+            best = i;
+    return best;
+}
+// Cross-entropy loss + the gradient on the logits, written into `dLogit`.
+// Binary (1 logit): BCE-with-logits, dz = sigmoid(z) − y.
+// Multi (K logits): softmax CE, dz = softmax(z) − onehot(y).
+function lossAndGrad(logits, y, dLogit) {
+    if (logits.length === 1) {
+        const z = logits[0];
+        const p = 1 / (1 + Math.exp(-z));
+        dLogit[0] = p - y;
+        const eps = 1e-12;
+        return -(y * Math.log(p + eps) + (1 - y) * Math.log(1 - p + eps));
+    }
+    const p = softmax(logits);
+    for (let k = 0; k < logits.length; k++)
+        dLogit[k] = p[k] - (k === y ? 1 : 0);
+    return -Math.log(p[y] + 1e-12);
+}
+function adamStep(net, param, g, m, v) {
+    const { lr, beta1, beta2, t } = net;
+    const bc1 = 1 - beta1 ** t;
+    const bc2 = 1 - beta2 ** t;
+    for (let i = 0; i < param.length; i++) {
+        const gi = g[i];
+        const mi = (m[i] = beta1 * m[i] + (1 - beta1) * gi);
+        const vi = (v[i] = beta2 * v[i] + (1 - beta2) * gi * gi);
+        param[i] = param[i] - (lr * (mi / bc1)) / (Math.sqrt(vi / bc2) + 1e-8);
+    }
+}
+/** One full-batch gradient step over `batch`. Returns the mean loss before
+ *  the update. This is the dynamical step on the weights — call it from a
+ *  clock to train. */
+export function trainStep(net, batch) {
+    for (const L of net.layers) {
+        L.gW.fill(0);
+        L.gb.fill(0);
+    }
+    const outDim = net.layers[net.layers.length - 1].outDim;
+    const dLogit = new Float64Array(outDim);
+    let total = 0;
+    for (const s of batch) {
+        const logits = forward(net, s.x);
+        total += lossAndGrad(logits, s.y, dLogit);
+        let g = dLogit;
+        for (let li = net.layers.length - 1; li >= 0; li--)
+            g = backwardLayer(net.layers[li], g);
+    }
+    const inv = 1 / Math.max(1, batch.length);
+    net.t += 1;
+    for (const L of net.layers) {
+        for (let i = 0; i < L.gW.length; i++)
+            L.gW[i] = L.gW[i] * inv + net.l2 * L.W[i];
+        for (let i = 0; i < L.gb.length; i++)
+            L.gb[i] = L.gb[i] * inv;
+        adamStep(net, L.W, L.gW, L.mW, L.vW);
+        adamStep(net, L.b, L.gb, L.mb, L.vb);
+    }
+    return total * inv;
+}
+/** Mean cross-entropy over a dataset (no update) — for monitoring/tests. */
+export function meanLoss(net, data) {
+    const outDim = net.layers[net.layers.length - 1].outDim;
+    const dLogit = new Float64Array(outDim);
+    let total = 0;
+    for (const s of data)
+        total += lossAndGrad(forward(net, s.x), s.y, dLogit);
+    return total / Math.max(1, data.length);
+}
+/** Fraction of `data` classified correctly. */
+export function accuracy(net, data) {
+    let ok = 0;
+    for (const s of data)
+        if (classify(net, s.x) === s.y)
+            ok++;
+    return ok / Math.max(1, data.length);
+}
+/** Flattened parameter buffers `[W0, b0, W1, b1, …]` (live views). */
+export function parameters(net) {
+    const out = [];
+    for (const L of net.layers) {
+        out.push(L.W);
+        out.push(L.b);
+    }
+    return out;
+}
+/** Mean-loss gradients over `batch` with no update and no weight decay,
+ *  aligned with `parameters(net)`. For gradient checking / inspection. */
+export function gradients(net, batch) {
+    for (const L of net.layers) {
+        L.gW.fill(0);
+        L.gb.fill(0);
+    }
+    const outDim = net.layers[net.layers.length - 1].outDim;
+    const dLogit = new Float64Array(outDim);
+    for (const s of batch) {
+        lossAndGrad(forward(net, s.x), s.y, dLogit);
+        let g = dLogit;
+        for (let li = net.layers.length - 1; li >= 0; li--)
+            g = backwardLayer(net.layers[li], g);
+    }
+    const inv = 1 / Math.max(1, batch.length);
+    const out = [];
+    for (const L of net.layers) {
+        out.push(L.gW.map(v => v * inv));
+        out.push(L.gb.map(v => v * inv));
+    }
+    return out;
+}
+/** Input-space gradient of a chosen logit, by one backward pass with a unit
+ *  seed. Drives the "dream" view (ascend pixels toward a class) and saliency.
+ *  Leaves parameter-gradient accumulators dirty; not for use mid-train-step. */
+export function inputGradient(net, x, cls = 0) {
+    forward(net, x);
+    const outDim = net.layers[net.layers.length - 1].outDim;
+    const seed = new Float64Array(outDim);
+    seed[Math.min(cls, outDim - 1)] = 1;
+    let g = seed;
+    for (let li = net.layers.length - 1; li >= 0; li--)
+        g = backwardLayer(net.layers[li], g);
+    return g;
+}

package/dist/propagators/csp.d.ts

@@ -0,0 +1,13 @@
+import { type LatticeCell } from "./lattice.js";
+import { type Propagator } from "./solver.js";
+type S<E> = LatticeCell<ReadonlySet<E>>;
+/** "These cells hold DIFFERENT values." When one collapses to a
+ *  singleton `{v}`, eliminate `v` from the others (naked-single
+ *  propagation). N(N−1) narrowers. */
+export declare function allDifferent<E>(...cells: S<E>[]): Propagator[];
+/** `a` and `b` hold the same value: intersect both candidate sets.
+ *  Unification, lifted to sets. */
+export declare function same<E>(a: S<E>, b: S<E>): Propagator[];
+/** Restrict `cell` to `allowed` (intersect). Self-applying. */
+export declare function restrict<E>(cell: S<E>, allowed: Iterable<E>): Propagator;
+export {};

package/dist/propagators/csp.js

@@ -0,0 +1,52 @@
+// csp.ts — set-narrowing relations over candidate-set cells.
+//
+// The discrete sibling of `numeric.ts`: same monotone-narrowing model,
+// finite-set lattice. Height is bounded by the universe size, so these
+// terminate structurally — sudoku, map colouring, type unification.
+import { merge } from "./lattice.js";
+import { propagator } from "./solver.js";
+/** "These cells hold DIFFERENT values." When one collapses to a
+ *  singleton `{v}`, eliminate `v` from the others (naked-single
+ *  propagation). N(N−1) narrowers. */
+export function allDifferent(...cells) {
+    const props = [];
+    for (let i = 0; i < cells.length; i++) {
+        for (let j = 0; j < cells.length; j++) {
+            if (i === j)
+                continue;
+            const src = cells[i];
+            const dst = cells[j];
+            props.push(propagator([src], [dst], () => {
+                const sv = src.value;
+                if (sv.size !== 1)
+                    return;
+                const [only] = sv;
+                if (!dst.value.has(only))
+                    return;
+                const next = new Set(dst.value);
+                next.delete(only);
+                merge(dst, next);
+            }));
+        }
+    }
+    return props;
+}
+/** `a` and `b` hold the same value: intersect both candidate sets.
+ *  Unification, lifted to sets. */
+export function same(a, b) {
+    return [
+        propagator([a], [b], () => {
+            merge(b, a.value);
+        }),
+        propagator([b], [a], () => {
+            merge(a, b.value);
+        }),
+    ];
+}
+/** Restrict `cell` to `allowed` (intersect). Self-applying. */
+export function restrict(cell, allowed) {
+    const allow = new Set(allowed);
+    return propagator([cell], [cell], () => {
+        merge(cell, allow);
+    });
+}

package/dist/propagators/flex.d.ts

@@ -0,0 +1,31 @@
+import { type Box, type Num as NumClass, type Read, type Writable } from "../core/index.js";
+import { type Propagator } from "./solver.js";
+type ValOrSig = number | Read<number>;
+/** A flex child. A bare `Box` takes defaults (grow 1, shrink 1, no
+ *  bounds); tag it to set per-item flex. `basis` seeds the size the
+ *  distribution grows/shrinks from (defaults to the box's current main
+ *  size). */
+export type Item = Box | {
+    box: Box;
+    grow?: number;
+    shrink?: number;
+    min?: number;
+    max?: number;
+    basis?: number;
+};
+export interface FlexOpts {
+    /** Space between adjacent items. Default 0. */
+    gap?: ValOrSig;
+    /** Padding inside the container on every side. Default 0. */
+    padding?: ValOrSig;
+    /** Cross-axis placement. Default "stretch". */
+    align?: "start" | "center" | "end" | "stretch";
+    /** Set to `true` on the frame(s) where the content can't fit (Σmin >
+     *  content). Drives "this layout is impossible" UI. */
+    report?: Writable<NumClass> | ((infeasible: boolean) => void);
+}
+/** Horizontal flex line over plain `Box` cells. */
+export declare function row(c: Box, items: readonly Item[], opts?: FlexOpts): Propagator;
+/** Vertical flex line over plain `Box` cells. */
+export declare function col(c: Box, items: readonly Item[], opts?: FlexOpts): Propagator;
+export {};

package/dist/propagators/flex.js

@@ -0,0 +1,189 @@
+// flex.ts — flexbox as interval propagation.
+//
+// A flex line is two phases, both grounded in the interval lattice:
+//
+//   1. FEASIBILITY (narrowing). Given the container's content size and
+//      each item's [min, max], the `total` relation narrows every item
+//      to the band it could occupy: `wᵢ ∈ content − Σ(others)`. If any
+//      band comes back empty the line can't fit — that's a real lattice
+//      contradiction, reported, not a silent overflow.
+//
+//   2. RESOLUTION (point pick). Within the feasible bands, grow/shrink
+//      weights distribute the slack to a single size per item. This is
+//      the one place a *preference* (not a constraint) enters, so it's
+//      kept out of the narrowing.
+//
+// The line operates on plain `Box` cells — zero ceremony, nothing is
+// coloured. Nesting composes through the ordinary reactive graph: a
+// child container is just an item of its parent, so resizing the root
+// re-runs each line top-down. `row`/`col` are the only public surface;
+// everything else is the two phases above.
+import { isCell, readNow, } from "../core/index.js";
+import { interval } from "./lattice.js";
+import { propagator } from "./solver.js";
+const asW = (n) => n;
+function readDeps(...vs) {
+    return vs.filter(isCell);
+}
+const clamp = (v, lo, hi) => 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,
+            basis: it.basis,
+        }
+        : { box: it, grow: 1, shrink: 1, min: 0, max: Number.POSITIVE_INFINITY });
+}
+/** Horizontal flex line over plain `Box` cells. */
+export function row(c, items, opts = {}) {
+    return line(c, items, opts, "x");
+}
+/** Vertical flex line over plain `Box` cells. */
+export function col(c, items, opts = {}) {
+    return line(c, items, opts, "y");
+}
+function line(c, rawItems, opts, main) {
+    const items = specs(rawItems);
+    const horizontal = main === "x";
+    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 align = opts.align ?? "stretch";
+    const reads = [
+        mainPos(c),
+        mainSize(c),
+        crossPos(c),
+        crossSize(c),
+        ...items.map(it => crossSize(it.box)),
+        ...readDeps(opts.gap ?? 0, opts.padding ?? 0),
+    ];
+    const writes = [];
+    for (const it of items) {
+        writes.push(mainPos(it.box), mainSize(it.box), crossPos(it.box));
+        if (align === "stretch")
+            writes.push(crossSize(it.box));
+    }
+    if (typeof opts.report !== "function" && opts.report)
+        writes.push(opts.report);
+    return propagator(reads, writes, () => {
+        const gap = readNow(opts.gap ?? 0);
+        const pad = readNow(opts.padding ?? 0);
+        const n = items.length;
+        if (n === 0)
+            return;
+        const content = mainSize(c).value - 2 * pad - (n - 1) * gap;
+        const mins = items.map(it => it.min);
+        const maxs = items.map(it => it.max);
+        const sumMin = mins.reduce((a, b) => a + b, 0);
+        const sumMax = maxs.reduce((a, b) => a + b, 0);
+        // Phase 1 — feasibility. Per-item band from the `total` relation:
+        //   wᵢ ∈ [content − Σmax(others), content − Σmin(others)] ∩ [minᵢ, maxᵢ].
+        const bands = items.map((_, i) => {
+            const lo = content - (sumMax - maxs[i]);
+            const hi = content - (sumMin - mins[i]);
+            return interval.meet([Math.max(lo, mins[i]), Math.min(hi, maxs[i])], [mins[i], maxs[i]]);
+        });
+        const infeasible = content < sumMin - 1e-9 || bands.some(interval.isBottom);
+        report(opts, infeasible);
+        // Phase 2 — resolution. Distribute slack from the basis sizes,
+        // weighted by grow (free > 0) / shrink (free < 0), clamped into the
+        // feasible band each pass and redistributed.
+        const base = items.map((it, i) => clamp(it.basis ?? mainSize(it.box).value, mins[i], maxs[i]));
+        const sizes = distribute(base, items, mins, maxs, content);
+        let cursor = mainPos(c).value + pad;
+        for (let i = 0; i < n; i++) {
+            mainPos(items[i].box).value = cursor;
+            mainSize(items[i].box).value = sizes[i];
+            cursor += sizes[i] + gap;
+        }
+        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 (align) {
+                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;
+            }
+        }
+    });
+}
+/** CSS-flex slack distribution, clamped into [min, max] with overflow
+ *  redistributed across still-eligible items. */
+function distribute(base, items, mins, maxs, content) {
+    const n = base.length;
+    const sizes = base.slice();
+    const free = content - base.reduce((a, b) => a + b, 0);
+    if (free > 1e-9) {
+        let remaining = free;
+        const eligible = new Set();
+        for (let i = 0; i < n; i++)
+            if (items[i].grow > 0 && sizes[i] < maxs[i])
+                eligible.add(i);
+        while (remaining > 1e-9 && eligible.size > 0) {
+            let weight = 0;
+            for (const i of eligible)
+                weight += items[i].grow;
+            if (weight === 0)
+                break;
+            let absorbed = 0;
+            for (const i of [...eligible]) {
+                const next = Math.min(sizes[i] + (remaining * items[i].grow) / weight, maxs[i]);
+                absorbed += next - sizes[i];
+                sizes[i] = next;
+                if (next >= maxs[i])
+                    eligible.delete(i);
+            }
+            if (absorbed < 1e-9)
+                break;
+            remaining -= absorbed;
+        }
+    }
+    else if (free < -1e-9) {
+        let remaining = -free;
+        const eligible = new Set();
+        for (let i = 0; i < n; i++)
+            if (items[i].shrink > 0 && sizes[i] > mins[i])
+                eligible.add(i);
+        while (remaining > 1e-9 && eligible.size > 0) {
+            let weight = 0;
+            for (const i of eligible)
+                weight += items[i].shrink;
+            if (weight === 0)
+                break;
+            let absorbed = 0;
+            for (const i of [...eligible]) {
+                const next = Math.max(sizes[i] - (remaining * items[i].shrink) / weight, mins[i]);
+                absorbed += sizes[i] - next;
+                sizes[i] = next;
+                if (next <= mins[i])
+                    eligible.delete(i);
+            }
+            if (absorbed < 1e-9)
+                break;
+            remaining -= absorbed;
+        }
+    }
+    return sizes;
+}
+function report(opts, infeasible) {
+    if (typeof opts.report === "function")
+        opts.report(infeasible);
+    else if (opts.report)
+        asW(opts.report).value = infeasible ? 1 : 0;
+}

package/dist/propagators/graph.d.ts

@@ -0,0 +1,73 @@
+/** A directed graph. Edges are `[from, to]`; nodes carry any identity. */
+export interface Graph<N> {
+    readonly nodes: readonly N[];
+    readonly edges: readonly (readonly [N, N])[];
+}
+export type Direction = "TB" | "BT" | "LR" | "RL";
+/** Intrinsic size of a node's box. */
+export interface Size {
+    w: number;
+    h: number;
+}
+/** Top-left placement of a node's box. */
+export interface Placement {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export interface LayeredOpts<N> {
+    direction?: Direction;
+    /** Centre-to-centre distance between adjacent layers. Default 90. */
+    layerGap?: number;
+    /** Minimum edge-to-edge distance within a layer. Default 28. */
+    nodeGap?: number;
+    /** Intrinsic node size. Default 46×34. */
+    sizeOf?: (n: N) => Size;
+    /** Crossing-reduction sweeps. Default 6. */
+    sweeps?: number;
+    /** Barycenter source: "both" (DAG), "down" (parents over children,
+     *  the tree look), "up". Default "both". */
+    align?: "both" | "down" | "up";
+}
+/** Assign each node an integer layer so every edge increases layer by
+ *  ≥1. Cycles are broken (back edges reversed for ranking only). The
+ *  value is the longest path from a source — computed as the lower
+ *  bound the `order` atoms narrow each layer cell to. */
+export declare function rank<N>(g: Graph<N>): Map<N, number>;
+/** Strongly-connected components (Tarjan), each a list of mutually
+ *  reachable nodes, in reverse-topological order of the condensation.
+ *  Singletons are size-1 components; a self-loop still reports size 1.
+ *  The cyclic cores of a graph are exactly the components of size > 1. */
+export declare function scc<N>(g: Graph<N>): N[][];
+/** Count edge crossings given per-layer orderings (for tests / quality). */
+export declare function crossings<N>(g: Graph<N>, layer: Map<N, number>, layers: N[][]): number;
+/** Full layered layout → top-left placement per node. */
+export declare function layered<N>(g: Graph<N>, opts?: LayeredOpts<N>): Map<N, Placement>;
+/** Tree layout: parents centred over their children. A `layered` with
+ *  downward barycenter and tighter defaults. */
+export declare function tree<N>(g: Graph<N>, opts?: LayeredOpts<N>): Map<N, Placement>;
+/** Radial layout: layers become concentric rings, cross-axis position
+ *  becomes angle. Reads a `layered` (TB) result and re-maps to polar. */
+export declare function radial<N>(g: Graph<N>, opts?: LayeredOpts<N>): Map<N, Placement>;
+/** Recurrent-hierarchy layout: decompose into strongly-connected
+ *  components, lay the condensation (a DAG of SCCs) out hierarchically,
+ *  and draw every cyclic component as a ring centred on its condensation
+ *  slot. The cycle closes by going around the circle — no backward edge.
+ *  Singleton components are placed as ordinary nodes. */
+export declare function recurrent<N>(g: Graph<N>, opts?: LayeredOpts<N>): Map<N, Placement>;
+export interface LanesOpts<N> {
+    /** Row height (topological order axis). Default 56. */
+    rowGap?: number;
+    /** Lane width (column axis). Default 46. */
+    laneGap?: number;
+    sizeOf?: (n: N) => Size;
+}
+/** Git-style lane packing: nodes flow top-to-bottom in topological
+ *  order (one row each), each assigned the first free column ("lane")
+ *  that no live edge occupies. Branch points open lanes, merges free
+ *  them. Expects a DAG whose `nodes` are in commit order (parents
+ *  before children). */
+export declare function lanes<N>(g: Graph<N>, opts?: LanesOpts<N>): Map<N, Placement>;
+/** Bounding size of a placement map. */
+export declare function extent<N>(p: Map<N, Placement>): Size;