@jokerized/decksmith 0.9.5 → 0.9.6

package/dist/types/literal/kinds/common.d.ts

@@ -0,0 +1,280 @@
+/**
+ * What the mechanism kinds share: the shape of their output, a seeded random
+ * source, and a few raster and layout helpers.
+ *
+ * A mechanism kind is a PURE function from typed inputs (a picture, a table of
+ * numbers, a graph) and the scene's region to a
+ * `MechanismResult`: rasters computed at build time, and frames of plain
+ * vector primitives in region pixels. The framework renders them (`svg.ts`
+ * draws one frame as SVG; an adapter turns rasters into files and frames into
+ * a fragment whose steps follow the narration).
+ *
+ * Determinism: no `Math.random`, no `Date`; every random draw comes from
+ * `mulberry32(seed)`. Same input, same bytes (`resultBytes` is what the tests
+ * hash).
+ *
+ * Words: a kind never writes language of its own. A text primitive carries
+ * either the input's own strings (tokens, item names, node labels) or a slot
+ * name plus the computed values the slot's text may name as `{var}`, exactly
+ * like the literal kinds' `slotText` (src/types.ts `LiteralSlot`).
+ */
+import type { LiteralSlot } from "../../types.js";
+/** FNV-1a, the repo's one copy (src/emit/motion.ts): a deterministic bucket from text. */
+export { fnv1a } from "../../emit/motion.js";
+import type { Rgb } from "../kit.js";
+export type { LiteralSlot, Rgb };
+/** A scalar map, 0..1 unless a kind says otherwise, row-major. */
+export interface Gray {
+    w: number;
+    h: number;
+    d: Float32Array;
+}
+/**
+ * A theme colour by name — the style pack's tokens and nothing else: ink (fg),
+ * muted, dim, rule, panel, accent and the four tones. The ground is the shell's;
+ * a kind never paints it.
+ */
+export type Role = "fg" | "muted" | "dim" | "rule" | "panel" | "accent" | "a" | "b" | "c" | "d";
+/** A picture with straight alpha, 0..1 per channel, RGBA row-major: drawn over the deck's ground. */
+export interface Rgba {
+    w: number;
+    h: number;
+    d: Float32Array;
+}
+/** A colour the data itself computes (a node's features), 0..1 per channel. */
+export type DataRgb = readonly [number, number, number];
+interface Paint {
+    /** Stable across frames, so the framework can tween one primitive from frame to frame. */
+    id?: string;
+    opacity?: number;
+    /**
+     * STAGING (src/literal/kinds/stage.ts). `at` ≥ 1: hidden when its frame
+     * opens, revealed as the frame's `at`-th sub-step, spread over the frame's
+     * sentence; `wipe`: revealed left to right by a clip, not a fade; `cam`: part
+     * of the frame's material the camera moves over once the reveals are done.
+     */
+    at?: number;
+    wipe?: boolean;
+    cam?: boolean;
+}
+export type Prim = (Paint & {
+    p: "line";
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    role: Role;
+    /** Tone weights (see the circle's `mix`): the line carries a data colour instead of `role`. */
+    mix?: number[];
+    width: number;
+    arrow?: boolean;
+    dash?: boolean;
+}) | (Paint & {
+    p: "path";
+    /** x0, y0, x1, y1, … */
+    pts: number[];
+    role: Role;
+    width: number;
+    closed?: boolean;
+    fill?: Role;
+    dash?: boolean;
+}) | (Paint & {
+    p: "rect";
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    /** Stroke. */
+    role?: Role;
+    width?: number;
+    fill?: Role;
+    /** 0..1 on the theme's ramp (background → accent), instead of `fill`. */
+    heat?: number;
+    mix?: number[];
+    rgb?: DataRgb;
+    radius?: number;
+}) | (Paint & {
+    p: "circle";
+    cx: number;
+    cy: number;
+    r: number;
+    role?: Role;
+    width?: number;
+    fill?: Role;
+    heat?: number;
+    /**
+     * Weights 0..1 on the tones a, b, c, d (in that order): the hue is their
+     * weighted mix, the strength their sum (capped at 1) over the panel.
+     */
+    mix?: number[];
+    rgb?: DataRgb;
+}) | (Paint & {
+    p: "ellipse";
+    cx: number;
+    cy: number;
+    rx: number;
+    ry: number;
+    /** Degrees, clockwise in screen space. */
+    angle: number;
+    role?: Role;
+    width?: number;
+    rgb?: DataRgb;
+}) | (Paint & {
+    p: "text";
+    x: number;
+    y: number;
+    /** Baseline-free: `y` is the top of the line. */
+    size: number;
+    /** "auto": the theme's ink (fg) or its panel, whichever reads better on what is under the text. */
+    role: Role | "auto";
+    anchor: "start" | "middle" | "end";
+    weight?: number;
+    /** The input's own string … */
+    text?: string;
+    /** … or a slot, filled with `vars`. */
+    slot?: string;
+    vars?: Readonly<Record<string, string | number>>;
+}) | (Paint & {
+    /**
+     * A formula, typeset in the page by the deck's KaTeX (`ds-tex`) in display
+     * style; `w`×`h` is its box as estimated at build (./tex.ts `texBox`).
+     */
+    p: "tex";
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    size: number;
+    tex: string;
+    role: Role;
+}) | (Paint & {
+    p: "image";
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    /** Key into `MechanismResult.rasters`. */
+    layer: string;
+    /** Nearest-neighbour upscaling (a patch grid stays a grid). */
+    pixelated?: boolean;
+    /** Keep the picture's own aspect inside the box (a figure, a layer of unknown size). */
+    fit?: boolean;
+    /** With `fit`, at the box's top rather than its middle (a picture under its title). */
+    top?: boolean;
+});
+/** A raster layer: a picture, or a scalar map drawn in a theme colour with alpha = value × `alpha`. */
+export type Raster = {
+    rgb: Rgb;
+} | {
+    rgba: Rgba;
+} | {
+    heat: Gray;
+    role: Role;
+    alpha: number;
+};
+export interface Frame {
+    id: string;
+    prims: Prim[];
+    /**
+     * Room left around the camera's material for its push-in, px a side: the
+     * camera's clip is its material's box grown by this, so text at the edge of
+     * a plot is not cut while the camera leans in (`text_clipped`).
+     */
+    pad?: {
+        x: number;
+        y: number;
+    };
+    /**
+     * The frame's faded reveals stand at `PREVIEW` opacity from the frame's
+     * first moment and come to full when spoken, so every hold shows the whole
+     * diagram (the fill gate measures the content's box at EVERY hold). For a
+     * diagram whose parts are known up front — a chain's stages, a plane's points,
+     * a set's members — never for a computed result, which must not show before
+     * the op that makes it. Wipes are untouched.
+     */
+    preview?: boolean;
+    /**
+     * Px the camera's material moves LEFT across the frame's time: a picture wider
+     * than the scene read along (a band of a figure), instead of a push-in.
+     */
+    pan?: number;
+    /**
+     * The camera back at rest before the frame ends: frames that must line up
+     * across their crossfade (a trace's rows, the lit one walking down). Pushed in
+     * at its end, a frame would fade into the next at rest and every row jump.
+     */
+    settle?: boolean;
+    /** Where the push leans in, in the frame's own coordinates: else its material's middle. */
+    focus?: {
+        x: number;
+        y: number;
+    };
+    /** The values this frame's slots may name. */
+    vars: Record<string, string | number>;
+}
+export interface MechanismResult {
+    rasters: Record<string, Raster>;
+    frames: Frame[];
+    /** The computed numbers, for tests and for a fragment that wants them. */
+    data: Record<string, unknown>;
+    /** Values the takeaway template names. */
+    vars: Record<string, string | number>;
+    /** What a later verb may take as input (src/literal/kit.ts `Material`). */
+    material?: import("../kit.js").Material;
+}
+export interface Region {
+    width: number;
+    height: number;
+}
+/** Text width in px; the adapter passes the deck's own measure (src/emit/svg.ts `textWidth`). */
+export type Measure = (text: string, size: number) => number;
+/** A conservative Latin estimate, for tests and previews. */
+export declare const roughMeasure: Measure;
+/**
+ * Han and kana: the scripts with no spaces between words, so a line breaks
+ * between any two characters — as the deck's own CSS lets Chinese and Japanese
+ * break (src/emit/composition.ts `cjkTypesetCss`). Hangul is not here: Korean
+ * breaks at spaces, and a Korean word stays whole (`keep-all`).
+ */
+export declare const BREAKS_ANYWHERE: RegExp;
+/**
+ * Greedy wrap by a measure. Breaks at spaces and, inside Han or kana, between
+ * characters — without that a Chinese label is one unbreakable word (a
+ * 14-character item ran 621px into a 582px part). A lone separator ("·") never
+ * opens a line. A unit wider than the line keeps its own line; the caller decides
+ * whether that is an error. An empty text is no lines.
+ */
+export declare function wrapBy(text: string, size: number, maxW: number, measure: Measure): string[];
+/** The deck's type, never below 40 px at 1920×1080 (invariant 5). */
+export declare const TYPE: {
+    readonly headline: 56;
+    readonly body: 44;
+    readonly label: 40;
+};
+/** Mulberry32: a 32-bit seeded generator, uniform on [0, 1). */
+export declare function mulberry32(seed: number): () => number;
+/** `{name}` in a template, replaced by `vars[name]`; throws on a name it was not given. */
+export declare function fillTemplate(template: string, vars: Readonly<Record<string, string | number>>): string;
+/** A number as a plain value: `digits` decimals, no trailing noise, "-0" never shown. */
+export declare function fmt(n: number, digits?: number): string;
+/** Area-average resample of a picture to w×h (any ratio). */
+export declare function resample(img: Rgb, w: number, h: number): Rgb;
+/** The largest w×h box of the picture's aspect inside bw×bh, centred at (bx, by). */
+export declare function fitBox(w: number, h: number, bx: number, by: number, bw: number, bh: number): {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};
+/** A polyline as flat points, rounded to 2 decimals (bytes do not drift). */
+export declare function flat(points: ReadonlyArray<readonly [number, number]>): number[];
+/** Clamped to 0..1. */
+export declare const clamp01: (n: number) => number;
+export declare const r2: (n: number) => number;
+/**
+ * Every byte a result carries, for determinism checks: each raster's floats and
+ * the frames and data as JSON (typed arrays as their bytes' hex).
+ */
+export declare function resultBytes(r: MechanismResult): Buffer;
+/** `p` moved by (dx, dy). */
+export declare function shiftPrim(p: Prim, dx: number, dy: number): Prim;

package/dist/types/literal/kinds/evolve.d.ts

@@ -0,0 +1,58 @@
+import type { MechanismResult, Raster } from "./common.js";
+import { type Role } from "./common.js";
+import { type VerbCtx } from "./stage.js";
+type Ctx = VerbCtx<"evolve">;
+export declare function evolve(c: Ctx): MechanismResult;
+/**
+ * THE ROW LOOK (the approved evolve, .planning/designs/2026-10-12-verb-looks/
+ * 2-evolve.png): one row per step, its number, what it carries on from (muted)
+ * and its parts in their tags' tones; the legend and the source's note beside.
+ * One frame per step: the step's row is lit on a panel, its parts arriving run
+ * by run (a struck part is crossed out as it arrives), the rows before it stay
+ * at ROW_DONE, the rows after it show only their numbers. Frames crossfade, so
+ * the lit row walks down the trace; each frame's push leans in on the lit row
+ * and `settle`s back to rest before the next, or every row would jump between
+ * two frames and break that walk. Too many
+ * rows for the height: a window of them, the lit one second from the bottom. A
+ * short trace is spread down the scene, as a chain's column is: the deck's gate
+ * wants the content to span the region (src/verify/fill.ts).
+ */
+export interface RowTag {
+    tag: string;
+    label: string;
+    tone: Role;
+    strike?: boolean;
+    /** Not in the legend: words that name their own row (a lane's name, its total). */
+    hidden?: boolean;
+}
+export interface Row {
+    lead?: string;
+    parts: ReadonlyArray<{
+        text: string;
+        tag: string;
+    }>;
+    /** A picture at the row's start: a raster layer. */
+    image?: string;
+    /** Bars after the words, each 0..1 of its rail in its tag's tone; a tick at `mark`; `dim` when frozen. */
+    bars?: ReadonlyArray<{
+        value: number;
+        tag: string;
+        mark?: {
+            at: number;
+            tag: string;
+        };
+        dim?: boolean;
+    }>;
+    /** A track of runs along the bar column: each from..to (0..1 of it) in `blocks` blocks. */
+    track?: ReadonlyArray<{
+        from: number;
+        to: number;
+        tag: string;
+        blocks: number;
+    }>;
+}
+export declare function rowsLook(c: Ctx, rows: readonly Row[], tags: readonly RowTag[], note: readonly string[], opts?: {
+    rasters?: Record<string, Raster>;
+    aspect?: number;
+}): MechanismResult;
+export {};

package/dist/types/literal/kinds/flow.d.ts

@@ -0,0 +1,13 @@
+import type { MechanismResult } from "./common.js";
+import { type VerbCtx } from "./stage.js";
+type Ctx = VerbCtx<"flow">;
+export declare function flow(c: Ctx): MechanismResult;
+/**
+ * A stage's `shape` as the tokens it counts, when it is a count the source
+ * states: a whole number (that many chips, unlabelled), or one symbol with an
+ * optional offset, alone or as the end of a run from 1 ("γ", "γ+1", "1…γ+1"),
+ * drawn as 1, 2, …, the symbol, so no value of the symbol is invented.
+ * Anything else ("H×W×C", "256×256") is not a count and stays words.
+ */
+export declare function tokenChips(shape: string): string[] | undefined;
+export {};

package/dist/types/literal/kinds/operate.d.ts

@@ -0,0 +1,27 @@
+/**
+ * operate — the approved look (.planning/designs/2026-10-12-verb-looks/
+ * 1-operate.png): what the source states on top, as chips, then one CELL per
+ * computed stage joined in reading order, each revealed on its sentence. Two
+ * forms:
+ *
+ * TERMS: a stated formula evaluated term by term on the values the source gives
+ * — the equation above, a cell a term, the terms combined into the result beside
+ * the source's own reported number, which it must match.
+ *
+ * CHAIN: an input run through KNOWN operations (src/literal/ops.ts), every output
+ * computed for real at build time — the input, then each step's output, a cell
+ * each: a picture or a matrix as itself, vectors as bars over their bins on each
+ * cell's own scale; a `compare` adds the other side's cell.
+ *
+ * WHAT IS EXACT. The ops and terms, with the values the source states (the gate
+ * grounds each in its role, src/plan/coverage.ts). WHAT IS EXAMPLE. A chain's
+ * input when it is a picture (always: a picture is never the method's own
+ * intermediate) or a vector the source does not print, and any `condition`;
+ * the scene then carries the example tag, and prints no computed value. No
+ * cell invents a number: no ticks, no values on example data.
+ */
+import type { MechanismResult } from "./common.js";
+import { type VerbCtx } from "./stage.js";
+type Ctx = VerbCtx<"operate">;
+export declare function operate(c: Ctx): MechanismResult;
+export {};

package/dist/types/literal/kinds/place-combos.d.ts

@@ -0,0 +1,33 @@
+/**
+ * ablation — the experiments a paper did not run, shown as the holes they
+ * leave. Every combination of its components (one or two) is a square of one
+ * small grid: the combinations the source reports are filled and their results
+ * stand under the grid, large; the rest are visibly empty, and one quiet mark
+ * says what an empty square means. Each setting the source fixes is its name and
+ * the ONE value tested, as words (no axis: the source states no range), and
+ * further comparisons it proposes are outlined.
+ *
+ * Nothing here is computed but the layout: the components, the reported
+ * results, the settings' values and the proposals are the plan's, held to the
+ * source by the truth gate. The empty cells are the point of the scene, not a
+ * placeholder: they are what the next experiment would fill.
+ */
+import { type KindImpl } from "../kind.js";
+export interface AblationData {
+    components: string[];
+    reported: Array<{
+        with: string[];
+        result: string;
+    }>;
+    settings: Array<{
+        name: string;
+        value: string;
+    }>;
+    others: string[];
+}
+/** Every combination of the components, as the components each one keeps, in grid order. */
+export declare function combinations(components: readonly string[]): string[][];
+/** The reported result of one combination, or undefined when the source reports none. */
+export declare function resultOf(d: AblationData, keep: readonly string[]): string | undefined;
+/** place, form combos: the experiments a source did not run, as empty cells. */
+export declare const combosForm: KindImpl;

package/dist/types/literal/kinds/place-lengths.d.ts

@@ -0,0 +1,36 @@
+/**
+ * place, measure length — reported quantities as AREAS to scale. Never bars.
+ *
+ * Each item is a block whose area is its value on one shared scale, drawn whole
+ * and faded in; nothing grows (the brief bans growing bars, and r2's "97M vs 6M"
+ * drew two horizontal bars that read as a bar chart however they arrived). A
+ * group of whole counts no larger than `UNITS_MAX` is drawn as that many unit
+ * cells (35 tokens are 35 cells); any other group as squares whose sides go as
+ * √value. A group's blocks sit on one baseline across the region's width, so the
+ * scene fills its frame however unequal the values are, with each item's name
+ * and value under its block.
+ *
+ * Squares: the smallest block's outline then slides onto the largest, so the two
+ * are compared at one scale; with `tile` the quotient the source states is
+ * printed beside it (`tileRatio`, the number the truth gate checks).
+ */
+import { type KindImpl } from "../kind.js";
+interface ScaleData {
+    groups: Array<{
+        label: string;
+        unit: string;
+        items: Array<{
+            label: string;
+            value: string;
+        }>;
+    }>;
+    tile: boolean;
+}
+/** A group of whole counts up to this is drawn as unit cells; larger values as squares. */
+export declare const UNITS_MAX = 100;
+type Group = ScaleData["groups"][number];
+/** Whether a group is drawn as unit cells: every value a whole count, 1–UNITS_MAX. */
+export declare const unitCells: (g: Group) => boolean;
+/** place, measure length: reported quantities as areas to scale. */
+export declare const lengthsForm: KindImpl;
+export {};

package/dist/types/literal/kinds/place-margins.d.ts

@@ -0,0 +1,44 @@
+/**
+ * margins — results against the best OTHER method, as positions: each setting
+ * (a dataset, a split) placed by its margin on one metric (a strip) or two (a
+ * plane), zero being "level with the best other method". Where the method leads
+ * and where it trails is then a place on screen, not a cell to read.
+ *
+ * EXACT ARITHMETIC ON THE SOURCE'S NUMBERS. The plan gives, per setting and
+ * metric, the method's value, the best other method's value and its name, as
+ * the source states them (the truth gate holds every one to the source); the
+ * margin is their difference, signed so that positive is better, printed with
+ * as many decimals as the values carry. Each axis is scaled to its own largest
+ * margin, which the `scaled` slot says on screen. No dataset picture is drawn:
+ * a source without one has none to show, and none is made up.
+ */
+import { type KindImpl } from "../kind.js";
+export interface MarginsData {
+    ours: string;
+    metrics: Array<{
+        name: string;
+        lowerIsBetter: boolean;
+    }>;
+    settings: Array<{
+        name: string;
+        values: Array<{
+            ours: string;
+            best: string;
+            rival: string;
+        }>;
+    }>;
+}
+export interface Margin {
+    /** Positive: the method is better than the best other method on this metric. */
+    gap: number;
+    /** The gap as printed: signed, with the values' own decimals. */
+    text: string;
+}
+/** One margin: ours − best (best − ours when lower is better), at the values' precision. */
+export declare function marginOf(ours: string, best: string, lowerIsBetter: boolean): Margin;
+/** Every setting's margins, metric by metric; refuses a setting with the wrong number of values. */
+export declare function marginsOf(d: MarginsData): Margin[][];
+/** Each axis's half-range: its largest |margin|, with room so no point sits on the frame. */
+export declare function axisSpan(margins: readonly Margin[][], m: number): number;
+/** place, measure margin: results against the best other method, as positions. */
+export declare const marginsForm: KindImpl;

package/dist/types/literal/kinds/place-sets.d.ts

@@ -0,0 +1,31 @@
+import { type KindImpl } from "../kind.js";
+export interface ScopeData {
+    rings: Array<{
+        label: string;
+        items: string[];
+    }>;
+}
+/** One part of the split: its column, its label's lines, its items' lines and where they sit. */
+export interface ScopePart {
+    x: number;
+    w: number;
+    label: string[];
+    items: Array<{
+        lines: string[];
+        y: number;
+    }>;
+}
+export interface ScopeLayout {
+    parts: ScopePart[];
+    /** Where the items start, under the rules and the labels. */
+    top: number;
+    captionY: number;
+}
+/**
+ * The split: 2–4 equal columns side by side, each its rule, its label and its
+ * items stacked down the column with the room shared out between them, so a
+ * short list still uses the height. Throws when a part cannot fit.
+ */
+export declare function scopeLayout(d: ScopeData, W: number, H: number, measure: (text: string, size: number) => number, captionH?: number): ScopeLayout;
+/** place, form sets: what a claim rests on and what lies outside it. */
+export declare const setsForm: KindImpl;

package/dist/types/literal/kinds/place.d.ts

@@ -0,0 +1,69 @@
+import type { Literal } from "../../types.js";
+import { type KindImpl } from "../kind.js";
+import type { Frame, MechanismResult } from "./common.js";
+import { type VerbCtx } from "./stage.js";
+type Ctx = VerbCtx<"place">;
+type PlaceLit = Extract<Literal, {
+    kind: "place";
+}>;
+/** The first number a value states ("88.84", "4.46 s", "3.4X"). */
+export declare function numberIn(v: string, what: string): number;
+/** Which renderer a place scene is drawn with. */
+export declare function placeForm(lit: PlaceLit): "points" | "margins" | "lengths" | "combos" | "sets";
+/**
+ * Points, inset for the camera's push (`withPushRoom`); with a `figure`, the
+ * plot takes the left of the scene and the source's own picture of what was
+ * measured stands at the right under its `scene` title (the approved look,
+ * .planning/designs/2026-10-12-verb-looks.md).
+ */
+export declare const points: (c: Ctx) => MechanismResult;
+/** A plane names each point beside it up to this many; past it, a key (`KEYED`). */
+export declare const NAMED_MAX = 8;
+interface Box {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+}
+/** A polyline (x0, y0, x1, y1, …) as small boxes every 10px along it, `w` px thick: an obstacle to a label. */
+export declare function segBoxes(pts: readonly number[], w: number): Box[];
+/**
+ * Where a point's label goes, and the leader that ties it to its dot when it
+ * sits more than `LEADER_PX` away: the first box, nearest first, inside the
+ * plot, that covers no word, point or line (`taken`, `strokes`) AND whose
+ * leader crosses no word or point.
+ * Null when there is none: the caller names the points by a key instead of
+ * drawing a word over a point, a line or another word.
+ *
+ * A plane tries beside the point, right then left, stepping 48px up and down.
+ * A strip tries its own side of the line first (`side`), then the other, at
+ * every level from the line out to the plot's edge — starting from level
+ * `spreadFrom` (the item's index), so a short strip's labels use the height
+ * rather than all hugging the axis.
+ */
+export declare function placeLabel(px: number, py: number, w: number, h: number, side: "beside" | "above" | "below", plot: {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}, taken: readonly Box[], strokes: readonly Box[], spreadFrom?: number, others?: ReadonlyArray<{
+    x: number;
+    y: number;
+}>, crossNot?: readonly Box[]): {
+    box: Box;
+    leader: number[][];
+} | null;
+/** Past this many px from its dot, a label is joined to it by a leader line. */
+export declare const LEADER_PX = 60;
+/** A label never sits further than this from its dot; past it the points are keyed. */
+export declare const LEADER_MAX = 150;
+/**
+ * 3–6 round tick values inside `[lo, hi]` (an axis's drawn range, in log10 on a
+ * log axis, where only powers of ten are ticked), each with its text.
+ */
+export declare function ticksOf(r: readonly [number, number], log: boolean): Array<{
+    v: number;
+    text: string;
+}>;
+export declare const placeKind: KindImpl;
+export type { Frame };

package/dist/types/literal/kinds/prior-work.d.ts

@@ -0,0 +1,29 @@
+/**
+ * prior-work — earlier approaches shown by what they do, family by family,
+ * side by side. A family is shown by what an earlier verb scene of this deck
+ * COMPUTED (`from`: that scene's layer, brought back), or, for a family of
+ * learned methods, only by the numbers the source reports for its members,
+ * each held to the source by the truth gate. A network the build does not have
+ * is never drawn working.
+ *
+ * Each lane carries the family, its members and where the source says it runs
+ * out (`gap`), all the plan's words in the deck's language.
+ */
+import { type KindImpl } from "../kind.js";
+export interface PriorWorkData {
+    lanes: Array<{
+        family: string;
+        members: string;
+        numbers: Array<{
+            label: string;
+            value: string;
+        }>;
+        from?: string | undefined;
+        gap: string;
+    }>;
+}
+/** Whether a lane shows an earlier scene's computed layer. */
+export declare const runsOnPicture: (l: PriorWorkData["lanes"][number]) => boolean;
+/** Checks a plan's lanes before anything is drawn: the counts and what each lane needs. */
+export declare function checkLanes(d: PriorWorkData): void;
+export declare const priorWorkKind: KindImpl;

package/dist/types/literal/kinds/read.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Reading a verb's plan into numbers and op steps: every number is written as
+ * the source writes it ("0.6", "1,024") and read here; a name an op does not
+ * take, a variant it does not have, a value that is not a number, is refused
+ * with the reason, at plan time (the verb's dry run) as at build time.
+ */
+import { type LiteralOpDoc, type LiteralOpName } from "../../types.js";
+import type { OpStep } from "../ops.js";
+/** A number as the source writes it. */
+export declare function num(value: string, what: string): number;
+export interface PlanParam {
+    name: string;
+    value: string;
+    symbol?: string | undefined;
+}
+/** A param list as numbers by name, against what the op (or rule) takes. */
+export declare function paramRecord(params: readonly PlanParam[], doc: Pick<LiteralOpDoc, "params">, what: string, free?: boolean): Record<string, number>;
+/** The schema's op step (src/types.ts `literalSchema` operate.chain). */
+export interface PlanStep {
+    op: LiteralOpName;
+    how?: string | undefined;
+    stat?: "mean" | "var" | "std" | undefined;
+    over?: "all" | "channel" | "row" | undefined;
+    params: readonly PlanParam[];
+    weights: readonly (readonly number[])[];
+    of: readonly number[];
+    expr?: string | undefined;
+    label: string;
+}
+/** A chain step read against the library: its variant, enums and params checked. */
+export declare function opStepOf(s: PlanStep, k: number): OpStep;
+/** A computed value as words: up to 3 significant decimals, no float dust. */
+export declare function plain(v: number): string;