@jgengine/core 0.10.0 → 0.11.0

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;

package/dist/puzzle/nonogram.js

@@ -0,0 +1,136 @@
+/** Run lengths of the filled cells in a boolean line — the clue a solved line yields.
+ * @internal
+ */
+export function runLengths(line) {
+    const runs = [];
+    let run = 0;
+    for (const cell of line) {
+        if (cell) {
+            run += 1;
+        }
+        else if (run > 0) {
+            runs.push(run);
+            run = 0;
+        }
+    }
+    if (run > 0)
+        runs.push(run);
+    return runs;
+}
+/** Row and column clues derived from a solution grid — the puzzle a solved board poses.
+ * @internal
+ */
+export function deriveClues(solution) {
+    const width = solution[0]?.length ?? 0;
+    const rows = solution.map((row) => runLengths(row));
+    const cols = [];
+    for (let c = 0; c < width; c += 1)
+        cols.push(runLengths(solution.map((row) => row[c] ?? false)));
+    return { rows, cols };
+}
+/**
+ * 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 function solveLine(line, clue) {
+    const n = line.length;
+    const everFilled = new Array(n).fill(false);
+    const everEmpty = new Array(n).fill(false);
+    const current = new Array(n).fill(false);
+    let arrangements = 0;
+    const record = () => {
+        arrangements += 1;
+        for (let k = 0; k < n; k += 1) {
+            if (current[k])
+                everFilled[k] = true;
+            else
+                everEmpty[k] = true;
+        }
+    };
+    const place = (pos, clueIndex) => {
+        if (clueIndex === clue.length) {
+            for (let k = pos; k < n; k += 1)
+                if (line[k] === "filled")
+                    return;
+            record();
+            return;
+        }
+        const len = clue[clueIndex];
+        for (let start = pos; start + len <= n; start += 1) {
+            let gapHasFilled = false;
+            for (let k = pos; k < start; k += 1)
+                if (line[k] === "filled") {
+                    gapHasFilled = true;
+                    break;
+                }
+            let runOk = true;
+            for (let k = start; k < start + len; k += 1)
+                if (line[k] === "empty") {
+                    runOk = false;
+                    break;
+                }
+            const separatorOk = start + len >= n || line[start + len] !== "filled";
+            if (!gapHasFilled && runOk && separatorOk) {
+                for (let k = start; k < start + len; k += 1)
+                    current[k] = true;
+                place(start + len + 1, clueIndex + 1);
+                for (let k = start; k < start + len; k += 1)
+                    current[k] = false;
+            }
+            if (line[start] === "filled")
+                break;
+        }
+    };
+    place(0, 0);
+    if (arrangements === 0)
+        return null;
+    const out = line.slice();
+    for (let k = 0; k < n; k += 1) {
+        if (everFilled[k] && !everEmpty[k])
+            out[k] = "filled";
+        else if (everEmpty[k] && !everFilled[k])
+            out[k] = "empty";
+    }
+    return out;
+}
+/**
+ * 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 function solveNonogram(rows, cols) {
+    const height = rows.length;
+    const width = cols.length;
+    const board = Array.from({ length: height }, () => new Array(width).fill("unknown"));
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (let r = 0; r < height; r += 1) {
+            const solved = solveLine(board[r], rows[r]);
+            if (solved === null)
+                return { solved: false, board };
+            for (let c = 0; c < width; c += 1)
+                if (solved[c] !== board[r][c]) {
+                    board[r][c] = solved[c];
+                    changed = true;
+                }
+        }
+        for (let c = 0; c < width; c += 1) {
+            const column = board.map((row) => row[c]);
+            const solved = solveLine(column, cols[c]);
+            if (solved === null)
+                return { solved: false, board };
+            for (let r = 0; r < height; r += 1)
+                if (solved[r] !== board[r][c]) {
+                    board[r][c] = solved[r];
+                    changed = true;
+                }
+        }
+    }
+    const solved = board.every((row) => row.every((cell) => cell !== "unknown"));
+    return { solved, board };
+}

package/dist/random/nameGen.d.ts

@@ -14,5 +14,10 @@ export interface NameGenerator {
     name(): string;
 }
 export declare function pickFrom(rng: () => number, bank: readonly string[]): string;
+/**
+ * Generate procedural names from templates and word banks with an injected random source.
+ *
+ * @capability name-generator generate procedural names from templates and word banks
+ */
 export declare function createNameGenerator(options: NameGeneratorOptions): NameGenerator;
 export declare function fillTemplate(template: string, vars: Record<string, () => string> | Record<string, string>): string;

package/dist/random/nameGen.js

@@ -3,6 +3,11 @@ export function pickFrom(rng, bank) {
         throw new Error("pickFrom: bank must not be empty");
     return bank[Math.floor(rng() * bank.length)];
 }
+/**
+ * Generate procedural names from templates and word banks with an injected random source.
+ *
+ * @capability name-generator generate procedural names from templates and word banks
+ */
 export function createNameGenerator(options) {
     const { rng, syllables } = options;
     const minSyllables = Math.max(1, options.minSyllables ?? 2);