@jgengine/core 0.10.0 → 0.12.0

package/dist/progression/statGraph.d.ts

@@ -0,0 +1,116 @@
+import type { StatModifierSet } from "../stats/statModifiers.js";
+/**
+ * A game-owned named input value. The engine ships no attribute vocabulary — ids,
+ * bounds, defaults, and metadata are entirely caller data, so the same graph can
+ * model STR/AGI/INT, SPECIAL scores, skills, difficulty knobs, or anything else.
+ */
+export interface StatInputDef {
+    id: string;
+    /** Default base value a fresh sheet starts at. Defaults to `min ?? 0`. */
+    base?: number;
+    /** Lower bound applied to the resolved value. */
+    min?: number;
+    /** Upper bound applied to the resolved value. */
+    max?: number;
+    /** Free-form, engine-ignored metadata (labels, descriptions, UI hints). */
+    meta?: Readonly<Record<string, unknown>>;
+}
+/** How a single contribution folds into a running value. */
+export type StatOp = "add" | "mul" | "override" | "clampMin" | "clampMax";
+/**
+ * One folded contribution to a value, retained so a sheet can explain
+ * "why is this value 42?" — every step carries the source that produced it.
+ */
+export interface StatContribution {
+    /** Provenance label — who/what produced this contribution. */
+    source: string;
+    op: StatOp;
+    value: number;
+}
+/** A modifier entry targeting one stat: a single contribution or an ordered list. */
+export type StatModEntry = StatContribution | readonly StatContribution[];
+/** The read-only view a derived formula gets: resolved values of its declared dependencies. */
+export interface StatDeriveContext {
+    /** Resolved (fully modified) value of a declared dependency (input or derived). */
+    value(id: string): number;
+}
+/**
+ * A derived value whose formula and dependencies are caller-owned. `compute` may
+ * return a scalar (shorthand for a single `add`) or an ordered list of contributions
+ * folded left-to-right, so additive/multiplicative/clamped and conditional modifiers
+ * are all expressed as plain data or branches inside the function.
+ */
+export interface StatDerivedDef {
+    id: string;
+    /** ids (inputs or other derived) this formula reads — drives ordering, cycle detection, and selective recompute. */
+    deps?: readonly string[];
+    min?: number;
+    max?: number;
+    round?: "floor" | "ceil" | "round";
+    meta?: Readonly<Record<string, unknown>>;
+    compute(ctx: StatDeriveContext): number | readonly StatContribution[];
+}
+/** The full schema of a stat graph: its named inputs and caller-authored derived formulas. */
+export interface StatGraphDef {
+    inputs: readonly StatInputDef[];
+    derived?: readonly StatDerivedDef[];
+}
+/** Plain-data, JSON-safe sheet state: input base values plus registered modifier sources. */
+export interface StatSheetState {
+    base: Record<string, number>;
+    sources: Record<string, Record<string, StatContribution[]>>;
+}
+/** One line of a provenance trace: a contribution plus the running total after it folds in. */
+export interface StatContributionStep extends StatContribution {
+    /** Running total after this contribution folds in. */
+    subtotal: number;
+}
+/** A full provenance trace for one stat: the ordered steps that produced its value. */
+export interface StatExplanation {
+    id: string;
+    value: number;
+    steps: StatContributionStep[];
+}
+/** A live per-entity instance of a {@link StatGraph}: mutable base values and modifier sources over a shared schema. */
+export interface StatSheet {
+    /** Resolve the fully modified value of an input or derived stat. */
+    get(id: string): number;
+    /** The stored base of an input stat (before modifiers/clamping). */
+    getBase(id: string): number;
+    setBase(id: string, value: number): void;
+    /** Register (or replace) a named modifier source targeting one or more stats. */
+    addSource(sourceId: string, mods: Record<string, StatModEntry>): void;
+    removeSource(sourceId: string): boolean;
+    hasSource(sourceId: string): boolean;
+    sources(): string[];
+    /** Resolve every input and derived stat into a plain record. */
+    values(): Record<string, number>;
+    /** Ordered contribution trace explaining a stat's current value. */
+    explain(id: string): StatExplanation;
+    /** Resolve values under a proposed, uncommitted mutation (e.g. a previewed allocation). */
+    preview(mutate: (draft: StatSheet) => void): Record<string, number>;
+    toJSON(): StatSheetState;
+}
+/** A compiled, immutable stat-graph schema that mints per-entity {@link StatSheet}s from base values or saved state. */
+export interface StatGraph {
+    readonly inputIds: readonly string[];
+    readonly derivedIds: readonly string[];
+    create(base?: Record<string, number>): StatSheet;
+    restore(state: StatSheetState): StatSheet;
+}
+/**
+ * A data-driven stat graph: game-owned named inputs feed caller-authored derived
+ * formulas, with contribution provenance, uncommitted previews, cycle detection, and
+ * selective recomputation. Formula semantics and numeric tables stay entirely game-defined.
+ *
+ * @capability stat-graph derive game-defined stats from named inputs with provenance and preview
+ */
+export declare function createStatGraph(def: StatGraphDef): StatGraph;
+/**
+ * Bridge the shared {@link StatModifierSet} shape (add/multiply, used by talents, items,
+ * and buffs) into stat-graph contributions, so a ranked talent tree or gear roll feeds
+ * the graph as one named source instead of a parallel store.
+ *
+ * @capability stat-graph-bridge feed an existing StatModifierSet into a stat-graph source
+ */
+export declare function statModifierContributions<TStat extends string>(source: string, set: StatModifierSet<TStat>): Record<string, StatContribution[]>;

package/dist/progression/statGraph.js

@@ -0,0 +1,318 @@
+const OP_ORDER = { override: 0, add: 1, mul: 2, clampMin: 3, clampMax: 4 };
+function applyOp(acc, op, value) {
+    switch (op) {
+        case "add":
+            return acc + value;
+        case "mul":
+            return acc * value;
+        case "override":
+            return value;
+        case "clampMin":
+            return Math.max(acc, value);
+        case "clampMax":
+            return Math.min(acc, value);
+    }
+}
+function normalizeEntry(entry) {
+    return Array.isArray(entry) ? [...entry] : [entry];
+}
+function applyBounds(value, bounds) {
+    let out = value;
+    if (bounds.min !== undefined)
+        out = Math.max(bounds.min, out);
+    if (bounds.max !== undefined)
+        out = Math.min(bounds.max, out);
+    switch (bounds.round) {
+        case "floor":
+            return Math.floor(out);
+        case "ceil":
+            return Math.ceil(out);
+        case "round":
+            return Math.round(out);
+        default:
+            return out;
+    }
+}
+/**
+ * A data-driven stat graph: game-owned named inputs feed caller-authored derived
+ * formulas, with contribution provenance, uncommitted previews, cycle detection, and
+ * selective recomputation. Formula semantics and numeric tables stay entirely game-defined.
+ *
+ * @capability stat-graph derive game-defined stats from named inputs with provenance and preview
+ */
+export function createStatGraph(def) {
+    const inputs = new Map();
+    for (const input of def.inputs) {
+        if (inputs.has(input.id))
+            throw new Error(`duplicate stat input id: ${input.id}`);
+        inputs.set(input.id, input);
+    }
+    const derived = new Map();
+    for (const node of def.derived ?? []) {
+        if (inputs.has(node.id) || derived.has(node.id))
+            throw new Error(`duplicate stat id: ${node.id}`);
+        derived.set(node.id, node);
+    }
+    // Validate dependencies and topologically order derived nodes (cycle detection).
+    for (const node of derived.values()) {
+        for (const dep of node.deps ?? []) {
+            if (!inputs.has(dep) && !derived.has(dep)) {
+                throw new Error(`stat "${node.id}" depends on unknown stat "${dep}"`);
+            }
+        }
+    }
+    const order = [];
+    const visiting = new Set();
+    const done = new Set();
+    const visit = (id) => {
+        if (done.has(id) || inputs.has(id))
+            return;
+        if (visiting.has(id))
+            throw new Error(`stat dependency cycle through "${id}"`);
+        visiting.add(id);
+        for (const dep of derived.get(id)?.deps ?? [])
+            visit(dep);
+        visiting.delete(id);
+        done.add(id);
+        order.push(id);
+    };
+    for (const id of derived.keys())
+        visit(id);
+    // Transitive dependents: changing X invalidates X and everything downstream of it.
+    const dependents = new Map();
+    for (const node of derived.values()) {
+        for (const dep of node.deps ?? []) {
+            let set = dependents.get(dep);
+            if (!set)
+                dependents.set(dep, (set = new Set()));
+            set.add(node.id);
+        }
+    }
+    const affected = (id) => {
+        const out = new Set([id]);
+        const stack = [id];
+        while (stack.length > 0) {
+            const cur = stack.pop();
+            for (const dep of dependents.get(cur) ?? []) {
+                if (!out.has(dep)) {
+                    out.add(dep);
+                    stack.push(dep);
+                }
+            }
+        }
+        return out;
+    };
+    const inputIds = Array.from(inputs.keys());
+    const derivedIds = Array.from(derived.keys());
+    const allIds = [...inputIds, ...order];
+    function makeSheet(baseState, sourceState) {
+        const baseValues = new Map(Object.entries(baseState));
+        const sources = sourceState;
+        const valueCache = new Map();
+        const stepCache = new Map();
+        const knows = (id) => inputs.has(id) || derived.has(id);
+        function externalSteps(id) {
+            const collected = [];
+            for (const mods of sources.values()) {
+                const list = mods.get(id);
+                if (list)
+                    collected.push(...list);
+            }
+            // Stable sort by op precedence; registration order is preserved within an op.
+            return collected
+                .map((c, index) => ({ c, index }))
+                .sort((a, b) => OP_ORDER[a.c.op] - OP_ORDER[b.c.op] || a.index - b.index)
+                .map((entry) => entry.c);
+        }
+        function resolveSteps(id) {
+            const cached = stepCache.get(id);
+            if (cached)
+                return cached;
+            const inputDef = inputs.get(id);
+            const steps = [];
+            let acc;
+            if (inputDef) {
+                acc = baseValues.get(id) ?? inputDef.base ?? inputDef.min ?? 0;
+                steps.push({ source: "base", op: "add", value: acc, subtotal: acc });
+            }
+            else {
+                const node = derived.get(id);
+                if (!node)
+                    throw new Error(`unknown stat: ${id}`);
+                const deps = new Set(node.deps ?? []);
+                const ctx = {
+                    value: (dep) => {
+                        if (!deps.has(dep))
+                            throw new Error(`stat "${id}" read undeclared dependency "${dep}"`);
+                        return resolveValue(dep);
+                    },
+                };
+                const out = node.compute(ctx);
+                const contribs = typeof out === "number" ? [{ source: "formula", op: "add", value: out }] : out;
+                acc = 0;
+                for (const c of contribs) {
+                    acc = applyOp(acc, c.op, c.value);
+                    steps.push({ ...c, subtotal: acc });
+                }
+            }
+            for (const c of externalSteps(id)) {
+                acc = applyOp(acc, c.op, c.value);
+                steps.push({ ...c, subtotal: acc });
+            }
+            const bounds = inputDef ?? derived.get(id);
+            const bounded = applyBounds(acc, bounds);
+            if (bounded !== acc) {
+                steps.push({ source: "bounds", op: "override", value: bounded, subtotal: bounded });
+            }
+            stepCache.set(id, steps);
+            return steps;
+        }
+        function resolveValue(id) {
+            const cached = valueCache.get(id);
+            if (cached !== undefined)
+                return cached;
+            const steps = resolveSteps(id);
+            const value = steps.length === 0 ? 0 : steps[steps.length - 1].subtotal;
+            valueCache.set(id, value);
+            return value;
+        }
+        function invalidate(ids) {
+            for (const id of ids) {
+                for (const target of affected(id)) {
+                    valueCache.delete(target);
+                    stepCache.delete(target);
+                }
+            }
+        }
+        function cloneBase() {
+            const out = {};
+            for (const [id, value] of baseValues)
+                out[id] = value;
+            return out;
+        }
+        function cloneSourceMaps() {
+            const clone = new Map();
+            for (const [sourceId, mods] of sources) {
+                const inner = new Map();
+                for (const [statId, list] of mods)
+                    inner.set(statId, list.map((c) => ({ ...c })));
+                clone.set(sourceId, inner);
+            }
+            return clone;
+        }
+        return {
+            get(id) {
+                if (!knows(id))
+                    throw new Error(`unknown stat: ${id}`);
+                return resolveValue(id);
+            },
+            getBase(id) {
+                const inputDef = inputs.get(id);
+                if (!inputDef)
+                    throw new Error(`not an input stat: ${id}`);
+                return baseValues.get(id) ?? inputDef.base ?? inputDef.min ?? 0;
+            },
+            setBase(id, value) {
+                if (!inputs.has(id))
+                    throw new Error(`not an input stat: ${id}`);
+                baseValues.set(id, value);
+                invalidate([id]);
+            },
+            addSource(sourceId, mods) {
+                const map = new Map();
+                for (const [statId, entry] of Object.entries(mods)) {
+                    if (!knows(statId))
+                        throw new Error(`source "${sourceId}" targets unknown stat "${statId}"`);
+                    map.set(statId, normalizeEntry(entry));
+                }
+                // Replacing a source must invalidate stats it USED to target, not just its new targets.
+                const touched = new Set(map.keys());
+                for (const statId of sources.get(sourceId)?.keys() ?? [])
+                    touched.add(statId);
+                sources.set(sourceId, map);
+                invalidate(touched);
+            },
+            removeSource(sourceId) {
+                const map = sources.get(sourceId);
+                if (!map)
+                    return false;
+                sources.delete(sourceId);
+                invalidate(map.keys());
+                return true;
+            },
+            hasSource(sourceId) {
+                return sources.has(sourceId);
+            },
+            sources() {
+                return Array.from(sources.keys());
+            },
+            values() {
+                const out = {};
+                for (const id of allIds)
+                    out[id] = resolveValue(id);
+                return out;
+            },
+            explain(id) {
+                if (!knows(id))
+                    throw new Error(`unknown stat: ${id}`);
+                const steps = resolveSteps(id).map((step) => ({ ...step }));
+                return { id, value: resolveValue(id), steps };
+            },
+            preview(mutate) {
+                const draft = makeSheet(cloneBase(), cloneSourceMaps());
+                mutate(draft);
+                return draft.values();
+            },
+            toJSON() {
+                const sourcesOut = {};
+                for (const [sourceId, mods] of sources) {
+                    const inner = {};
+                    for (const [statId, list] of mods)
+                        inner[statId] = list.map((c) => ({ ...c }));
+                    sourcesOut[sourceId] = inner;
+                }
+                return { base: cloneBase(), sources: sourcesOut };
+            },
+        };
+    }
+    return {
+        inputIds,
+        derivedIds,
+        create(base) {
+            return makeSheet({ ...(base ?? {}) }, new Map());
+        },
+        restore(state) {
+            const sources = new Map();
+            for (const [sourceId, mods] of Object.entries(state.sources ?? {})) {
+                const inner = new Map();
+                for (const [statId, list] of Object.entries(mods))
+                    inner.set(statId, list.map((c) => ({ ...c })));
+                sources.set(sourceId, inner);
+            }
+            return makeSheet({ ...(state.base ?? {}) }, sources);
+        },
+    };
+}
+/**
+ * Bridge the shared {@link StatModifierSet} shape (add/multiply, used by talents, items,
+ * and buffs) into stat-graph contributions, so a ranked talent tree or gear roll feeds
+ * the graph as one named source instead of a parallel store.
+ *
+ * @capability stat-graph-bridge feed an existing StatModifierSet into a stat-graph source
+ */
+export function statModifierContributions(source, set) {
+    const out = {};
+    for (const stat of Object.keys(set)) {
+        const modifier = set[stat];
+        if (!modifier)
+            continue;
+        const list = [];
+        if (modifier.add !== undefined)
+            list.push({ source, op: "add", value: modifier.add });
+        if (modifier.multiply !== undefined)
+            list.push({ source, op: "mul", value: modifier.multiply });
+        if (list.length > 0)
+            out[stat] = list;
+    }
+    return out;
+}

package/dist/puzzle/cellGrid.d.ts

@@ -11,16 +11,25 @@ export interface CellRun<T> {
     }[];
     readonly direction: "row" | "column";
 }
+/** @internal */
 export declare function createCellGrid<T>(width: number, height: number): CellGrid<T>;
+/** @internal */
 export declare function inGridBounds<T>(grid: CellGrid<T>, x: number, y: number): boolean;
+/** @internal */
 export declare function cellAt<T>(grid: CellGrid<T>, x: number, y: number): T | null;
+/** @internal */
 export declare function withCell<T>(grid: CellGrid<T>, x: number, y: number, value: T | null): CellGrid<T>;
+/** @internal */
 export declare function withCells<T>(grid: CellGrid<T>, entries: readonly {
     readonly x: number;
     readonly y: number;
     readonly value: T | null;
 }[]): CellGrid<T>;
+/** @internal */
 export declare function fullRows<T>(grid: CellGrid<T>): number[];
+/** @internal */
 export declare function clearRows<T>(grid: CellGrid<T>, rows: readonly number[]): CellGrid<T>;
+/** @internal */
 export declare function collapseColumns<T>(grid: CellGrid<T>): CellGrid<T>;
+/** @internal */
 export declare function findRuns<T>(grid: CellGrid<T>, minLength: number, matches?: (a: T, b: T) => boolean): CellRun<T>[];

package/dist/puzzle/cellGrid.js

@@ -1,14 +1,18 @@
+/** @internal */
 export function createCellGrid(width, height) {
     return { width, height, cells: new Array(width * height).fill(null) };
 }
+/** @internal */
 export function inGridBounds(grid, x, y) {
     return x >= 0 && x < grid.width && y >= 0 && y < grid.height;
 }
+/** @internal */
 export function cellAt(grid, x, y) {
     if (!inGridBounds(grid, x, y))
         return null;
     return grid.cells[y * grid.width + x] ?? null;
 }
+/** @internal */
 export function withCell(grid, x, y, value) {
     if (!inGridBounds(grid, x, y))
         return grid;
@@ -16,6 +20,7 @@ export function withCell(grid, x, y, value) {
     cells[y * grid.width + x] = value;
     return { width: grid.width, height: grid.height, cells };
 }
+/** @internal */
 export function withCells(grid, entries) {
     const cells = grid.cells.slice();
     for (const entry of entries) {
@@ -24,6 +29,7 @@ export function withCells(grid, entries) {
     }
     return { width: grid.width, height: grid.height, cells };
 }
+/** @internal */
 export function fullRows(grid) {
     const rows = [];
     for (let y = 0; y < grid.height; y += 1) {
@@ -39,6 +45,7 @@ export function fullRows(grid) {
     }
     return rows;
 }
+/** @internal */
 export function clearRows(grid, rows) {
     const removed = new Set(rows);
     const kept = [];
@@ -55,6 +62,7 @@ export function clearRows(grid, rows) {
         cells.push(...row);
     return { width: grid.width, height: grid.height, cells };
 }
+/** @internal */
 export function collapseColumns(grid) {
     const cells = grid.cells.slice();
     for (let x = 0; x < grid.width; x += 1) {
@@ -88,6 +96,7 @@ function scanRuns(length, cellAtIndex, minLength, matches) {
     }
     return runs;
 }
+/** @internal */
 export function findRuns(grid, minLength, matches = (a, b) => a === b) {
     const runs = [];
     for (let y = 0; y < grid.height; y += 1) {

package/dist/puzzle/fallingPiece.d.ts

@@ -6,18 +6,27 @@ export interface FallingPiece<TShape extends string = string> {
     readonly y: number;
 }
 export type ShapeTable<TShape extends string = string> = Record<TShape, readonly (readonly (readonly [number, number])[])[]>;
+/** @internal */
 export declare function pieceCells<TShape extends string>(table: ShapeTable<TShape>, piece: FallingPiece<TShape>): readonly (readonly [number, number])[];
+/** @internal */
 export declare function pieceCollides<T, TShape extends string>(grid: CellGrid<T>, table: ShapeTable<TShape>, piece: FallingPiece<TShape>): boolean;
+/** @internal */
 export declare function mergePiece<T, TShape extends string>(grid: CellGrid<T>, table: ShapeTable<TShape>, piece: FallingPiece<TShape>, value: T): CellGrid<T>;
+/** @internal */
 export declare function dropDistance<T, TShape extends string>(grid: CellGrid<T>, table: ShapeTable<TShape>, piece: FallingPiece<TShape>): number;
+/** @internal */
 export declare function gravityInterval(level: number, base?: number, perLevel?: number, min?: number): number;
+/** @internal */
 export declare function levelForLines(lines: number, linesPerLevel?: number): number;
+/** @internal */
 export declare function lineScore(cleared: number, level: number, table?: readonly number[]): number;
 export interface LockDelayState {
     readonly delaySeconds: number;
     readonly elapsed: number;
 }
+/** @internal */
 export declare function createLockDelay(delaySeconds: number): LockDelayState;
+/** @internal */
 export declare function stepLockDelay(state: LockDelayState, grounded: boolean, dt: number): {
     state: LockDelayState;
     locked: boolean;

package/dist/puzzle/fallingPiece.js

@@ -1,10 +1,12 @@
 import { cellAt } from "./cellGrid.js";
+/** @internal */
 export function pieceCells(table, piece) {
     const rotations = table[piece.shape];
     const index = ((piece.rotation % rotations.length) + rotations.length) % rotations.length;
     const state = rotations[index];
     return state.map(([ox, oy]) => [piece.x + ox, piece.y + oy]);
 }
+/** @internal */
 export function pieceCollides(grid, table, piece) {
     for (const [x, y] of pieceCells(table, piece)) {
         if (x < 0 || x >= grid.width || y >= grid.height)
@@ -14,6 +16,7 @@ export function pieceCollides(grid, table, piece) {
     }
     return false;
 }
+/** @internal */
 export function mergePiece(grid, table, piece, value) {
     const cells = grid.cells.slice();
     for (const [x, y] of pieceCells(table, piece)) {
@@ -22,25 +25,31 @@ export function mergePiece(grid, table, piece, value) {
     }
     return { width: grid.width, height: grid.height, cells };
 }
+/** @internal */
 export function dropDistance(grid, table, piece) {
     let distance = 0;
     while (!pieceCollides(grid, table, { ...piece, y: piece.y + distance + 1 }))
         distance += 1;
     return distance;
 }
+/** @internal */
 export function gravityInterval(level, base = 0.8, perLevel = 0.07, min = 0.05) {
     return Math.max(min, base - level * perLevel);
 }
+/** @internal */
 export function levelForLines(lines, linesPerLevel = 10) {
     return Math.floor(lines / linesPerLevel);
 }
 const CLASSIC_LINE_SCORE = [0, 40, 100, 300, 1200];
+/** @internal */
 export function lineScore(cleared, level, table = CLASSIC_LINE_SCORE) {
     return (table[cleared] ?? 0) * (level + 1);
 }
+/** @internal */
 export function createLockDelay(delaySeconds) {
     return { delaySeconds, elapsed: 0 };
 }
+/** @internal */
 export function stepLockDelay(state, grounded, dt) {
     if (!grounded)
         return { state: { ...state, elapsed: 0 }, locked: false };

package/dist/puzzle/nonogram.d.ts

@@ -0,0 +1,39 @@
+/** A cell in a nonogram line: not yet determined, painted, or ruled out. */
+export type NonogramCell = "unknown" | "filled" | "empty";
+/** A line clue — the lengths of its consecutive filled runs, in order. */
+export type NonogramClue = readonly number[];
+/** A solved grid, row-major; `true` is a filled cell. */
+export type NonogramSolution = readonly (readonly boolean[])[];
+/** Run lengths of the filled cells in a boolean line — the clue a solved line yields.
+ * @internal
+ */
+export declare function runLengths(line: readonly boolean[]): number[];
+/** Row and column clues derived from a solution grid — the puzzle a solved board poses.
+ * @internal
+ */
+export declare function deriveClues(solution: NonogramSolution): {
+    rows: number[][];
+    cols: number[][];
+};
+/**
+ * Constraint-propagate one line against its `clue`: intersect every clue-consistent arrangement, forcing a
+ * cell `filled` when it is filled in all of them and `empty` when empty in all, leaving the rest `unknown`.
+ * Returns the tightened line, or `null` on contradiction (no arrangement fits the current cells) — the
+ * per-line deduction step at the heart of every nonogram/picross solver.
+  * @internal
+  */
+export declare function solveLine(line: readonly NonogramCell[], clue: NonogramClue): NonogramCell[] | null;
+/** Outcome of {@link solveNonogram}: the deduced board and whether propagation fully determined it. */
+export interface NonogramSolveResult {
+    /** True when every cell is decided by line propagation alone (the puzzle is uniquely line-solvable). */
+    solved: boolean;
+    /** The board after propagation stalls — `unknown` cells remain when solving needs guessing. */
+    board: NonogramCell[][];
+}
+/**
+ * Solve a nonogram from its row and column clues by iterated line propagation until the board stops
+ * changing. `solved` is true iff the board is fully determined without guessing — the standard test for
+ * whether a nonogram is fair. Returns `solved: false` with a partial board on contradiction or ambiguity.
+  * @internal
+  */
+export declare function solveNonogram(rows: readonly NonogramClue[], cols: readonly NonogramClue[]): NonogramSolveResult;