bireactive 0.2.4 → 0.3.1

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();
+    });
+}

package/dist/learn/data.d.ts

@@ -0,0 +1,49 @@
+import { type Sample } from "./mlp.js";
+/** A 2D point dataset: each sample's `x` is `[px, py]`, `y` is `0|1`. */
+export type Points = Sample[];
+/** Two interleaving half-moons (the reliable "is it learning" classic). */
+export declare function moons(n: number, opts?: {
+    seed?: number;
+    noise?: number;
+}): Points;
+/** Concentric rings: inner blob (class 0) inside an outer ring (class 1). */
+export declare function circles(n: number, opts?: {
+    seed?: number;
+    noise?: number;
+}): Points;
+/** Four quadrant clusters; class 1 where the coordinate signs differ. */
+export declare function xor(n: number, opts?: {
+    seed?: number;
+    noise?: number;
+}): Points;
+/** Two intertwined spirals — the hard one (may need more steps/capacity). */
+export declare function spirals(n: number, opts?: {
+    seed?: number;
+    noise?: number;
+}): Points;
+/** A 2D dataset family selectable in the demo. */
+export type PointsKind = "moons" | "circles" | "xor" | "spirals";
+/** Build a 2D dataset by name. */
+export declare function points(kind: PointsKind, n: number, opts?: {
+    seed?: number;
+    noise?: number;
+}): Points;
+/** A rasterisable shape. The binary task is `circle` (class 1) vs the rest. */
+export type ShapeKind = "circle" | "square" | "triangle";
+/** Placement of a shape in normalised `[0,1]²` grid space. */
+export interface ShapePose {
+    cx: number;
+    cy: number;
+    r: number;
+    rot: number;
+}
+/** Rasterise a posed shape onto a `grid×grid` coverage buffer (0..1) via
+ *  3×3 supersampling. */
+export declare function rasterShape(kind: ShapeKind, grid: number, pose: ShapePose): Float64Array;
+/** Random pose for a roughly-centred shape (small jitter, moderate size,
+ *  free rotation) — learnable from raw pixels and legible when drawn. */
+export declare function randomPose(r: () => number): ShapePose;
+/** One labelled pixel sample: `circle` → class 1, `square`/`triangle` → 0. */
+export declare function shapeSample(grid: number, r: () => number, noise?: number): Sample;
+/** A batch of `n` fresh pixel samples. */
+export declare function shapeBatch(grid: number, n: number, r: () => number): Sample[];

package/dist/learn/data.js

@@ -0,0 +1,181 @@
+// data.ts — synthetic, reproducible datasets for the learning demos.
+//
+// Two families: 2D point clouds (moons / circles / xor / spirals) where the
+// learned decision boundary is the visual; and rasterised shapes on a small
+// pixel grid (circle vs square/triangle) generated on the fly, so training
+// data is endless and the label is whatever the generator drew.
+import { gaussian, rng } from "./mlp.js";
+/** Two interleaving half-moons (the reliable "is it learning" classic). */
+export function moons(n, opts = {}) {
+    const r = rng(opts.seed ?? 7);
+    const noise = opts.noise ?? 0.12;
+    const out = [];
+    for (let i = 0; i < n; i++) {
+        const top = i % 2 === 0;
+        const a = r() * Math.PI;
+        let px;
+        let py;
+        if (top) {
+            px = Math.cos(a);
+            py = Math.sin(a) - 0.25;
+        }
+        else {
+            px = 1 - Math.cos(a);
+            py = 0.25 - Math.sin(a);
+        }
+        out.push({
+            x: [px - 0.5 + gaussian(r) * noise, py + gaussian(r) * noise],
+            y: top ? 0 : 1,
+        });
+    }
+    return out;
+}
+/** Concentric rings: inner blob (class 0) inside an outer ring (class 1). */
+export function circles(n, opts = {}) {
+    const r = rng(opts.seed ?? 7);
+    const noise = opts.noise ?? 0.1;
+    const out = [];
+    for (let i = 0; i < n; i++) {
+        const inner = i % 2 === 0;
+        const rad = inner ? 0.35 : 0.9;
+        const a = r() * 2 * Math.PI;
+        out.push({
+            x: [Math.cos(a) * rad + gaussian(r) * noise, Math.sin(a) * rad + gaussian(r) * noise],
+            y: inner ? 0 : 1,
+        });
+    }
+    return out;
+}
+/** Four quadrant clusters; class 1 where the coordinate signs differ. */
+export function xor(n, opts = {}) {
+    const r = rng(opts.seed ?? 7);
+    const noise = opts.noise ?? 0.18;
+    const out = [];
+    for (let i = 0; i < n; i++) {
+        const sx = i & 1 ? 1 : -1;
+        const sy = i & 2 ? 1 : -1;
+        out.push({
+            x: [sx * 0.6 + gaussian(r) * noise, sy * 0.6 + gaussian(r) * noise],
+            y: sx === sy ? 0 : 1,
+        });
+    }
+    return out;
+}
+/** Two intertwined spirals — the hard one (may need more steps/capacity). */
+export function spirals(n, opts = {}) {
+    const r = rng(opts.seed ?? 7);
+    const noise = opts.noise ?? 0.06;
+    const out = [];
+    const per = Math.ceil(n / 2);
+    for (let c = 0; c < 2; c++) {
+        for (let i = 0; i < per; i++) {
+            const t = (i / per) * 3.2;
+            const a = t * Math.PI + c * Math.PI;
+            const rad = 0.15 + t * 0.26;
+            out.push({
+                x: [Math.cos(a) * rad + gaussian(r) * noise, Math.sin(a) * rad + gaussian(r) * noise],
+                y: c,
+            });
+        }
+    }
+    return out;
+}
+/** Build a 2D dataset by name. */
+export function points(kind, n, opts = {}) {
+    switch (kind) {
+        case "moons":
+            return moons(n, opts);
+        case "circles":
+            return circles(n, opts);
+        case "xor":
+            return xor(n, opts);
+        default:
+            return spirals(n, opts);
+    }
+}
+// Point-in-shape test in normalised coords.
+function inside(kind, p, x, y) {
+    const dx = x - p.cx;
+    const dy = y - p.cy;
+    if (kind === "circle")
+        return dx * dx + dy * dy <= p.r * p.r;
+    const cs = Math.cos(-p.rot);
+    const sn = Math.sin(-p.rot);
+    const rx = dx * cs - dy * sn;
+    const ry = dx * sn + dy * cs;
+    if (kind === "square") {
+        const s = p.r * 0.86;
+        return Math.abs(rx) <= s && Math.abs(ry) <= s;
+    }
+    // Equilateral triangle, circumradius r, vertices at 90°/210°/330°.
+    for (let k = 0; k < 3; k++) {
+        const a = (Math.PI / 2) * -1 + (k * 2 * Math.PI) / 3;
+        // Inward normal of the edge opposite vertex k points toward center;
+        // test the half-plane through the two other vertices.
+        const a1 = -Math.PI / 2 + (((k + 1) % 3) * 2 * Math.PI) / 3;
+        const a2 = -Math.PI / 2 + (((k + 2) % 3) * 2 * Math.PI) / 3;
+        const x1 = Math.cos(a1) * p.r;
+        const y1 = Math.sin(a1) * p.r;
+        const x2 = Math.cos(a2) * p.r;
+        const y2 = Math.sin(a2) * p.r;
+        const ex = x2 - x1;
+        const ey = y2 - y1;
+        // Cross product sign: center (0,0) must be on the same side as (rx,ry).
+        const side = ex * (ry - y1) - ey * (rx - x1);
+        const cside = ex * (0 - y1) - ey * (0 - x1);
+        if (Math.sign(side) !== Math.sign(cside) && side !== 0)
+            return false;
+        void a;
+    }
+    return true;
+}
+/** Rasterise a posed shape onto a `grid×grid` coverage buffer (0..1) via
+ *  3×3 supersampling. */
+export function rasterShape(kind, grid, pose) {
+    const out = new Float64Array(grid * grid);
+    const S = 3;
+    for (let gy = 0; gy < grid; gy++) {
+        for (let gx = 0; gx < grid; gx++) {
+            let hit = 0;
+            for (let sy = 0; sy < S; sy++) {
+                for (let sx = 0; sx < S; sx++) {
+                    const x = (gx + (sx + 0.5) / S) / grid;
+                    const y = (gy + (sy + 0.5) / S) / grid;
+                    if (inside(kind, pose, x, y))
+                        hit++;
+                }
+            }
+            out[gy * grid + gx] = hit / (S * S);
+        }
+    }
+    return out;
+}
+/** Random pose for a roughly-centred shape (small jitter, moderate size,
+ *  free rotation) — learnable from raw pixels and legible when drawn. */
+export function randomPose(r) {
+    return {
+        cx: 0.5 + (r() - 0.5) * 0.16,
+        cy: 0.5 + (r() - 0.5) * 0.16,
+        r: 0.26 + r() * 0.12,
+        rot: r() * Math.PI * 2,
+    };
+}
+/** One labelled pixel sample: `circle` → class 1, `square`/`triangle` → 0. */
+export function shapeSample(grid, r, noise = 0.04) {
+    const kind = r() < 0.5 ? "circle" : r() < 0.5 ? "square" : "triangle";
+    const buf = rasterShape(kind, grid, randomPose(r));
+    if (noise > 0)
+        for (let i = 0; i < buf.length; i++)
+            buf[i] = clamp01(buf[i] + gaussian(r) * noise);
+    return { x: buf, y: kind === "circle" ? 1 : 0 };
+}
+/** A batch of `n` fresh pixel samples. */
+export function shapeBatch(grid, n, r) {
+    const out = [];
+    for (let i = 0; i < n; i++)
+        out.push(shapeSample(grid, r));
+    return out;
+}
+function clamp01(v) {
+    return v < 0 ? 0 : v > 1 ? 1 : v;
+}

package/dist/learn/index.d.ts

@@ -0,0 +1,3 @@
+export { circles, moons, type Points, type PointsKind, points, randomPose, rasterShape, type ShapeKind, type ShapePose, shapeBatch, shapeSample, spirals, xor, } from "./data.js";
+export { accuracyOf, classifyOf, inputGradient, type LayerParams, type LensLayer, type LensNet, type LensNetCfg, lensNet, logitsOf, meanLossOf, probsOf, trainEpoch, trainExample, } from "./lens-net.js";
+export { type Activation, gaussian, rng, type Sample } from "./mlp.js";

package/dist/learn/index.js

@@ -0,0 +1,6 @@
+// learn — a tiny, dependency-free MLP framed as a stack of parametric lenses,
+// plus reproducible datasets for the classification demos. Imported by the
+// site via "@bireactive/learn"; not part of the main barrel.
+export { circles, moons, points, randomPose, rasterShape, shapeBatch, shapeSample, spirals, xor, } from "./data.js";
+export { accuracyOf, classifyOf, inputGradient, lensNet, logitsOf, meanLossOf, probsOf, trainEpoch, trainExample, } from "./lens-net.js";
+export { gaussian, rng } from "./mlp.js";

package/dist/learn/lens-net.d.ts

@@ -0,0 +1,63 @@
+import { type Cell, type Writable } from "../core/index.js";
+import { type Activation, type Sample } from "./mlp.js";
+/** Dense-layer parameters: row-major `out×in` weights + `out` biases. */
+export interface LayerParams {
+    W: Float64Array;
+    b: Float64Array;
+}
+/** Training knobs read live by every layer's backward map. */
+export interface LensNetCfg {
+    /** SGD learning rate for the weight step. */
+    lr: number;
+    /** Freeze the weights: their backward update is `SKIP`ped and only the input
+     *  cotangent flows — the inversion ("dream") leg. */
+    frozen: boolean;
+}
+/** One dense layer as a lens: `out = act(W·in + b)`, `params` its weight source. */
+export interface LensLayer {
+    inDim: number;
+    outDim: number;
+    act: Activation;
+    params: Writable<Cell<LayerParams>>;
+    out: Writable<Cell<Float64Array>>;
+}
+/** A net wired as a lens DAG `input → layer → … → logits`. Train by writing the
+ *  output cotangent to `logits`; the engine backpropagates to the sources. */
+export interface LensNet {
+    input: Writable<Cell<Float64Array>>;
+    layers: LensLayer[];
+    logits: Writable<Cell<Float64Array>>;
+    cfg: LensNetCfg;
+    dims: readonly number[];
+}
+/** Build a net as a lens DAG. `dims` is `[in, h1, …, out]`; hidden layers use
+ *  `hidden` activation, the output is `linear` (the squash folds into the loss). */
+export declare function lensNet(dims: readonly number[], opts?: {
+    seed?: number;
+    hidden?: Activation;
+    lr?: number;
+}): LensNet;
+/** Logits for `x`, reading the current weight cells (no training, untracked).
+ *  Applies any pending backward write first, so it always sees fresh weights. */
+export declare function logitsOf(net: LensNet, x: ArrayLike<number>): Float64Array;
+/** Class probabilities: sigmoid for a 1-logit (binary) net, else softmax. */
+export declare function probsOf(net: LensNet, x: ArrayLike<number>): Float64Array;
+/** Argmax class for a multi-logit net, or `P ≥ 0.5` for a binary net. */
+export declare function classifyOf(net: LensNet, x: ArrayLike<number>): number;
+/** Fraction of `data` classified correctly. */
+export declare function accuracyOf(net: LensNet, data: readonly Sample[]): number;
+/** Mean cross-entropy over a dataset (no update) — for monitoring/tests. */
+export declare function meanLossOf(net: LensNet, data: readonly Sample[]): number;
+/** Train one example with a single backward write: pin the input, read the
+ *  prediction (the forward pull), then write the output cotangent to `logits`.
+ *  The engine backpropagates and lands an SGD step on every weight cell. The
+ *  step is forced before returning (while the input still holds this example),
+ *  so callers may move on immediately. Returns the loss before the step. */
+export declare function trainExample(net: LensNet, x: ArrayLike<number>, y: number): number;
+/** Train one shuffled pass — one backward write per example (online SGD).
+ *  Returns the mean loss over the epoch. */
+export declare function trainEpoch(net: LensNet, data: readonly Sample[], r: () => number): number;
+/** Input-space gradient toward raising logit `cls`, by one frozen-weight
+ *  backward write: with the weights held fixed the cotangent flows past them to
+ *  the input cell, which then holds dL/dInput. Drives the "dream" / saliency. */
+export declare function inputGradient(net: LensNet, x: ArrayLike<number>, cls?: number): Float64Array;