tallyd 0.0.0-stage → 0.1.0

package/dist/dashboard/charts.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Two charts, drawn as SVG by hand.
+ *
+ * Not a library, because the whole artefact is one file that has to open from
+ * a file path on a machine with no network — and because two charts do not
+ * justify shipping a charting engine inside a bookkeeping report.
+ *
+ * Both answer a question rather than decorating a panel. The cash position
+ * line answers "when was the account tight"; the confidence distribution
+ * answers "how much of this did the matcher actually know". Neither carries a
+ * legend: each is a single series, and the heading names it, so a legend box
+ * would be a second label for the same thing.
+ *
+ * Colour does no identifying work here. One series takes the categorical blue;
+ * the distribution is ordinal, so it steps one hue light to dark — never a
+ * hue per bar, which would imply four unrelated categories.
+ */
+import type { SeriesPoint } from "./model.js";
+export interface ChartOptions {
+    readonly width?: number;
+    readonly height?: number;
+    readonly exponent: number;
+    readonly symbol: string;
+}
+/** Cash position across the period, as a line with a soft fill beneath it. */
+export declare function cashPositionChart(points: readonly SeriesPoint[], options: ChartOptions): string;
+/**
+ * Distribution of match confidence, as horizontal bars.
+ *
+ * Horizontal because the labels are words: rotated axis text is a readability
+ * cost paid for nothing when there are four categories.
+ */
+export declare function confidenceChart(bands: readonly {
+    readonly label: string;
+    readonly count: number;
+}[], options?: {
+    readonly width?: number;
+}): string;

package/dist/dashboard/charts.js

@@ -0,0 +1,173 @@
+/**
+ * Two charts, drawn as SVG by hand.
+ *
+ * Not a library, because the whole artefact is one file that has to open from
+ * a file path on a machine with no network — and because two charts do not
+ * justify shipping a charting engine inside a bookkeeping report.
+ *
+ * Both answer a question rather than decorating a panel. The cash position
+ * line answers "when was the account tight"; the confidence distribution
+ * answers "how much of this did the matcher actually know". Neither carries a
+ * legend: each is a single series, and the heading names it, so a legend box
+ * would be a second label for the same thing.
+ *
+ * Colour does no identifying work here. One series takes the categorical blue;
+ * the distribution is ordinal, so it steps one hue light to dark — never a
+ * hue per bar, which would imply four unrelated categories.
+ */
+const escapeAttribute = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+function majorUnits(minor, exponent) {
+    return minor / 10 ** exponent;
+}
+function formatAxisMoney(minor, exponent, symbol) {
+    const value = majorUnits(minor, exponent);
+    const abs = Math.abs(value);
+    if (abs >= 1000)
+        return `${symbol}${(value / 1000).toFixed(abs >= 10_000 ? 0 : 1)}k`;
+    return `${symbol}${value.toFixed(0)}`;
+}
+function formatMoney(minor, exponent, symbol) {
+    const negative = minor < 0;
+    const digits = Math.abs(minor).toString().padStart(exponent + 1, "0");
+    const whole = digits.slice(0, digits.length - exponent);
+    const fraction = exponent === 0 ? "" : `.${digits.slice(digits.length - exponent)}`;
+    const grouped = whole.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+    return `${negative ? "-" : ""}${symbol}${grouped}${fraction}`;
+}
+/**
+ * Round a range outward to friendly ticks. Axes that stop at 23,143.58 read as
+ * an accident; axes that stop at 25,000 read as a decision.
+ */
+function niceTicks(min, max, count = 4) {
+    if (min === max) {
+        const pad = Math.abs(min) || 1;
+        min -= pad;
+        max += pad;
+    }
+    const rawStep = (max - min) / count;
+    const magnitude = 10 ** Math.floor(Math.log10(Math.abs(rawStep) || 1));
+    const normalised = rawStep / magnitude;
+    const step = (normalised >= 5 ? 10 : normalised >= 2 ? 5 : normalised >= 1 ? 2 : 1) * magnitude;
+    const start = Math.floor(min / step) * step;
+    const end = Math.ceil(max / step) * step;
+    const ticks = [];
+    for (let value = start; value <= end + step / 2; value += step) {
+        ticks.push(Math.round(value));
+    }
+    return ticks;
+}
+/** Cash position across the period, as a line with a soft fill beneath it. */
+export function cashPositionChart(points, options) {
+    const width = options.width ?? 640;
+    const height = options.height ?? 200;
+    const padLeft = 52;
+    const padRight = 12;
+    const padTop = 12;
+    const padBottom = 26;
+    if (points.length === 0) {
+        return `<div class="empty"><strong>No movements</strong>Nothing has been posted to this account in the period.</div>`;
+    }
+    const values = points.map((point) => point.minor);
+    const ticks = niceTicks(Math.min(0, ...values), Math.max(0, ...values));
+    const low = Math.min(...ticks);
+    const high = Math.max(...ticks);
+    const plotWidth = width - padLeft - padRight;
+    const plotHeight = height - padTop - padBottom;
+    // Position by date, not by index. Spacing ten movements evenly across a
+    // month draws three days and thirteen days the same width, which is a lie
+    // about the one axis the chart exists to show.
+    const day = (iso) => {
+        const [year, month, dayOfMonth] = iso.split("-").map(Number);
+        return Math.floor(Date.UTC(year, month - 1, dayOfMonth) / 86_400_000);
+    };
+    const firstDay = day(points[0].date);
+    const lastDay = day(points[points.length - 1].date);
+    const span = lastDay - firstDay;
+    const x = (index) => {
+        if (points.length === 1 || span === 0)
+            return padLeft + plotWidth / 2;
+        const offset = day(points[index].date) - firstDay;
+        return padLeft + (offset / span) * plotWidth;
+    };
+    const y = (value) => padTop + plotHeight - ((value - low) / (high - low || 1)) * plotHeight;
+    const line = points.map((point, index) => `${index === 0 ? "M" : "L"}${x(index).toFixed(1)},${y(point.minor).toFixed(1)}`).join(" ");
+    const area = `${line} L${x(points.length - 1).toFixed(1)},${y(low).toFixed(1)} L${x(0).toFixed(1)},${y(low).toFixed(1)} Z`;
+    const gridLines = ticks
+        .map((tick) => `<line x1="${padLeft}" x2="${width - padRight}" y1="${y(tick).toFixed(1)}" y2="${y(tick).toFixed(1)}" />`)
+        .join("");
+    const axisLabels = ticks
+        .map((tick) => `<text x="${padLeft - 8}" y="${(y(tick) + 3).toFixed(1)}" text-anchor="end">${escapeAttribute(formatAxisMoney(tick, options.exponent, options.symbol))}</text>`)
+        .join("");
+    const first = points[0];
+    const last = points[points.length - 1];
+    const dateLabels = [
+        `<text x="${padLeft}" y="${height - 6}" text-anchor="start">${escapeAttribute(first.date)}</text>`,
+        points.length > 1
+            ? `<text x="${width - padRight}" y="${height - 6}" text-anchor="end">${escapeAttribute(last.date)}</text>`
+            : "",
+    ].join("");
+    const markers = points
+        .map((point, index) => `<circle class="marker" data-index="${index}" cx="${x(index).toFixed(1)}" cy="${y(point.minor).toFixed(1)}" r="4"><title>${escapeAttribute(`${point.date} · ${formatMoney(point.minor, options.exponent, options.symbol)}`)}</title></circle>`)
+        .join("");
+    // Wide invisible hit areas: a 4px dot is a poor target, and the tooltip
+    // should follow the pointer across the whole column, not just the mark.
+    const hitAreas = points
+        .map((point, index) => {
+        const here = x(index);
+        const before = index === 0 ? padLeft : (x(index - 1) + here) / 2;
+        const after = index === points.length - 1 ? width - padRight : (here + x(index + 1)) / 2;
+        const left = Math.max(padLeft, before);
+        const right = Math.min(width - padRight, after);
+        return `<rect class="hit" x="${left.toFixed(1)}" y="${padTop}" width="${(right - left).toFixed(1)}" height="${plotHeight}" fill="transparent" data-x="${x(index).toFixed(1)}" data-y="${y(point.minor).toFixed(1)}" data-label="${escapeAttribute(`${point.date}  ${formatMoney(point.minor, options.exponent, options.symbol)}`)}" />`;
+    })
+        .join("");
+    return `<div class="chart" data-chart="cash">
+  <svg viewBox="0 0 ${width} ${height}" role="img" aria-label="Cash position across the period">
+    <g class="grid">${gridLines}</g>
+    <path class="series-area" d="${area}" />
+    <path class="series-line" d="${line}" />
+    <g class="axis">${axisLabels}${dateLabels}</g>
+    ${markers}
+    <line class="crosshair" y1="${padTop}" y2="${padTop + plotHeight}" x1="0" x2="0" style="display:none" />
+    ${hitAreas}
+  </svg>
+  <div class="tooltip" role="status" aria-live="polite"></div>
+</div>`;
+}
+/**
+ * Distribution of match confidence, as horizontal bars.
+ *
+ * Horizontal because the labels are words: rotated axis text is a readability
+ * cost paid for nothing when there are four categories.
+ */
+export function confidenceChart(bands, options = {}) {
+    const width = options.width ?? 340;
+    const rowHeight = 32;
+    const labelWidth = 66;
+    const countWidth = 28;
+    const height = bands.length * rowHeight;
+    const total = bands.reduce((sum, band) => sum + band.count, 0);
+    if (total === 0) {
+        return `<div class="empty"><strong>Nothing matched</strong>No pair scored high enough to appear.</div>`;
+    }
+    const most = Math.max(...bands.map((band) => band.count));
+    const barWidth = width - labelWidth - countWidth;
+    const rows = bands
+        .map((band, index) => {
+        const y = index * rowHeight;
+        const length = most === 0 ? 0 : (band.count / most) * barWidth;
+        const fill = `var(--seq-${4 - index})`;
+        const share = total === 0 ? 0 : Math.round((band.count / total) * 100);
+        return `<g>
+      <text class="bar-label" x="0" y="${y + 19}">${escapeAttribute(band.label)}</text>
+      <rect class="bar" x="${labelWidth}" y="${y + 8}" width="${Math.max(length, band.count > 0 ? 3 : 0).toFixed(1)}" height="14" rx="4" fill="${fill}"><title>${escapeAttribute(`${band.count} ${band.count === 1 ? "match" : "matches"} · ${share}%`)}</title></rect>
+      <text class="bar-label" x="${width}" y="${y + 19}" text-anchor="end">${band.count}</text>
+    </g>`;
+    })
+        .join("");
+    return `<div class="chart" data-chart="confidence">
+  <svg viewBox="0 0 ${width} ${height}" role="img" aria-label="Distribution of match confidence">
+    ${rows}
+  </svg>
+</div>`;
+}

package/dist/dashboard/index.d.ts

@@ -0,0 +1,3 @@
+export { type AmountView, type LineView, type MatchView, type AccountView, type PostingView, type SeriesPoint, type DashboardData, type DashboardInput, dashboardData, } from "./model.js";
+export { escapeHtml, embedJson, renderDashboard } from "./render.js";
+export { cashPositionChart, confidenceChart, type ChartOptions } from "./charts.js";

package/dist/dashboard/index.js

@@ -0,0 +1,3 @@
+export { dashboardData, } from "./model.js";
+export { escapeHtml, embedJson, renderDashboard } from "./render.js";
+export { cashPositionChart, confidenceChart } from "./charts.js";

package/dist/dashboard/model.d.ts

@@ -0,0 +1,137 @@
+/**
+ * What the page needs to know.
+ *
+ * The dashboard is a single HTML file with its data baked in, so this module
+ * flattens a ledger, a statement and a reconciliation into something that
+ * survives `JSON.stringify` — plain strings and numbers, no `Money`, no
+ * `bigint`, no class instances.
+ *
+ * Amounts cross that boundary twice: once as a decimal string for display, and
+ * once as a count of minor units for arithmetic in the browser. Keeping both is
+ * deliberate. The browser has to re-add the bridge every time a match is
+ * accepted, and doing that on formatted strings — or on floats parsed from them
+ * — is how a reconciliation ends up out by a penny in the one place a penny
+ * matters.
+ */
+import { Money } from "../money/money.js";
+import type { Ledger } from "../ledger/ledger.js";
+import type { StatementLine } from "../statement/line.js";
+import type { BookLine } from "../reconcile/bankView.js";
+import type { Match, ReconciliationResult } from "../reconcile/matcher.js";
+import { type DecisionPayload } from "../reconcile/decisions.js";
+import type { Proposal } from "../reconcile/posting.js";
+export interface AmountView {
+    /** For display: `-1850.00`. */
+    readonly text: string;
+    /** For arithmetic: signed minor units, as a JSON-safe number. */
+    readonly minor: number;
+}
+export interface LineView {
+    readonly id: string;
+    readonly date: string;
+    readonly description: string;
+    readonly amount: AmountView;
+    /** `book` or `bank`, so the page can label a line without being told twice. */
+    readonly side: "book" | "bank";
+    readonly reference: string | null;
+}
+export interface MatchView {
+    readonly id: string;
+    readonly kind: Match["kind"];
+    readonly confidence: string;
+    readonly score: number;
+    readonly book: readonly LineView[];
+    readonly statement: readonly LineView[];
+    readonly reasons: readonly string[];
+    readonly amount: AmountView;
+    /**
+     * What deciding this suggestion should write to the decisions file, minus
+     * the verdict and the date. Built here rather than in the browser so the
+     * shape is type-checked and tested; see `reconcile/decisions.ts`.
+     */
+    readonly decision: readonly DecisionPayload[];
+}
+export interface AccountView {
+    readonly code: string;
+    readonly name: string;
+    readonly type: string;
+    readonly depth: number;
+    readonly balance: AmountView;
+    readonly postings: number;
+}
+export interface PostingView {
+    readonly entryId: string;
+    readonly date: string;
+    readonly narration: string;
+    readonly account: string;
+    readonly amount: AmountView;
+    readonly contra: readonly string[];
+}
+/**
+ * A journal entry a statement line implies, flattened for the page.
+ *
+ * One of these exists for *every* statement line, not only the ones currently
+ * unmatched, because the page has to be able to show what a rejection implies
+ * the moment it is made. Which of them are live is decided in the browser from
+ * the leftovers, which is state the browser already maintains.
+ */
+export interface ImpliedEntryView {
+    readonly lineId: string;
+    readonly date: string;
+    readonly description: string;
+    readonly amount: AmountView;
+    readonly outcome: Proposal["outcome"];
+    readonly account: string | null;
+    readonly accountName: string | null;
+    readonly rule: string | null;
+    readonly narration: string;
+    readonly reason: string;
+}
+export interface SeriesPoint {
+    readonly date: string;
+    readonly minor: number;
+}
+export interface DashboardData {
+    readonly generatedFor: string;
+    readonly account: string;
+    readonly accountName: string;
+    readonly currency: string;
+    readonly currencySymbol: string;
+    readonly exponent: number;
+    readonly period: {
+        readonly from: string;
+        readonly to: string;
+    };
+    readonly matched: readonly MatchView[];
+    readonly suggested: readonly MatchView[];
+    readonly unmatchedBook: readonly LineView[];
+    readonly unmatchedStatement: readonly LineView[];
+    /** Closing balances the bridge starts from, in minor units. */
+    readonly bankClosingMinor: number;
+    readonly bookClosingMinor: number;
+    readonly accounts: readonly AccountView[];
+    readonly postings: readonly PostingView[];
+    readonly cashPosition: readonly SeriesPoint[];
+    readonly confidence: readonly {
+        readonly label: string;
+        readonly count: number;
+    }[];
+    readonly trialBalanceBalanced: boolean;
+    readonly statementFormat: string;
+    /** What each statement line would imply if nothing in the books explained it. */
+    readonly implied: readonly ImpliedEntryView[];
+}
+export interface DashboardInput {
+    readonly ledger: Ledger;
+    readonly account: string;
+    readonly books: readonly BookLine[];
+    readonly statement: readonly StatementLine[];
+    readonly result: ReconciliationResult;
+    readonly bankClosingBalance: Money;
+    readonly bookClosingBalance: Money;
+    readonly statementFormat: string;
+    readonly generatedFor?: string;
+    /** One proposal per statement line, in any order. */
+    readonly implied?: readonly Proposal[];
+}
+export declare function dashboardData(input: DashboardInput): DashboardData;

package/dist/dashboard/model.js

@@ -0,0 +1,190 @@
+/**
+ * What the page needs to know.
+ *
+ * The dashboard is a single HTML file with its data baked in, so this module
+ * flattens a ledger, a statement and a reconciliation into something that
+ * survives `JSON.stringify` — plain strings and numbers, no `Money`, no
+ * `bigint`, no class instances.
+ *
+ * Amounts cross that boundary twice: once as a decimal string for display, and
+ * once as a count of minor units for arithmetic in the browser. Keeping both is
+ * deliberate. The browser has to re-add the bridge every time a match is
+ * accepted, and doing that on formatted strings — or on floats parsed from them
+ * — is how a reconciliation ends up out by a penny in the one place a penny
+ * matters.
+ */
+import { Money } from "../money/money.js";
+import { debitSign } from "../accounts/types.js";
+import { significantReasons } from "../reconcile/matcher.js";
+import { decisionPayloads } from "../reconcile/decisions.js";
+import { trialBalance } from "../ledger/trialBalance.js";
+function amountOf(money) {
+    return { text: money.toDecimalString(), minor: Number(money.minorUnits) };
+}
+function bookLineView(line) {
+    return {
+        id: line.id,
+        date: line.date,
+        description: line.description,
+        amount: amountOf(line.amount),
+        side: "book",
+        reference: line.reference,
+    };
+}
+function statementLineView(line) {
+    return {
+        id: line.id,
+        date: line.date,
+        description: line.description,
+        amount: amountOf(line.amount),
+        side: "bank",
+        reference: line.reference,
+    };
+}
+function matchView(match, index, bucket) {
+    const minor = match.statement.reduce((sum, line) => sum + Number(line.amount.minorUnits), 0);
+    const currency = match.statement[0]?.amount.currency ?? match.book[0]?.amount.currency;
+    const exponent = currency?.exponent ?? 2;
+    const amount = { text: formatMinor(minor, exponent), minor };
+    return {
+        id: `${bucket}-${index}`,
+        kind: match.kind,
+        confidence: match.scored.confidence,
+        score: Number(match.scored.score.toFixed(4)),
+        book: match.book.map(bookLineView),
+        statement: match.statement.map(statementLineView),
+        reasons: significantReasons(match),
+        amount,
+        decision: decisionPayloads({
+            statementDescriptions: match.statement.map((line) => line.description),
+            bookDescriptions: match.book.map((line) => line.description),
+            context: {
+                amount: amount.text,
+                date: match.statement[0]?.date ?? match.book[0]?.date ?? "",
+                kind: match.kind,
+                confidence: match.scored.confidence,
+            },
+        }),
+    };
+}
+function formatMinor(minor, exponent) {
+    const negative = minor < 0;
+    const digits = Math.abs(minor).toString().padStart(exponent + 1, "0");
+    const whole = digits.slice(0, digits.length - exponent);
+    const fraction = exponent === 0 ? "" : `.${digits.slice(digits.length - exponent)}`;
+    return `${negative ? "-" : ""}${whole}${fraction}`;
+}
+/** Running balance of the bank account, one point per day it moved. */
+function cashPosition(lines) {
+    const byDate = new Map();
+    for (const line of lines) {
+        byDate.set(line.date, (byDate.get(line.date) ?? 0) + Number(line.amount.minorUnits));
+    }
+    const dates = [...byDate.keys()].sort();
+    const points = [];
+    let running = 0;
+    for (const date of dates) {
+        running += byDate.get(date) ?? 0;
+        points.push({ date, minor: running });
+    }
+    return points;
+}
+const CONFIDENCE_ORDER = ["exact", "high", "medium", "low"];
+/** A grouping account's balance is the sum of its subtree, on its normal side. */
+function rolledUpNatural(ledger, chart, code, type) {
+    const total = chart
+        .subtree(code)
+        .reduce((sum, node) => sum + ledger.balanceOf(node.code).minorUnits, 0n);
+    const signed = debitSign(type) === 1 ? total : -total;
+    return Money.ofMinor(signed, ledger.balanceOf(code).currency);
+}
+export function dashboardData(input) {
+    const currency = input.bankClosingBalance.currency;
+    const dates = [
+        ...input.books.map((line) => line.date),
+        ...input.statement.map((line) => line.date),
+    ].sort();
+    const from = (dates[0] ?? "");
+    const to = (dates[dates.length - 1] ?? "");
+    const counts = new Map();
+    for (const match of [...input.result.matched, ...input.result.suggested]) {
+        counts.set(match.scored.confidence, (counts.get(match.scored.confidence) ?? 0) + 1);
+    }
+    // An account nothing has ever touched is noise in a report about what
+    // happened. A grouping account earns its row only when something below it
+    // did, and then it shows the rolled-up total rather than its own zero.
+    const chart = input.ledger.chart;
+    const accounts = [];
+    for (const account of chart?.list() ?? []) {
+        const detail = input.ledger.accountBalance(account.code);
+        const isLeaf = account.children.length === 0;
+        const subtreePostings = isLeaf
+            ? detail.postingCount
+            : chart
+                .subtree(account.code)
+                .reduce((sum, node) => sum + input.ledger.accountBalance(node.code).postingCount, 0);
+        if (subtreePostings === 0)
+            continue;
+        const balance = isLeaf
+            ? detail.natural
+            : rolledUpNatural(input.ledger, chart, account.code, account.type);
+        accounts.push({
+            code: account.code,
+            name: account.name,
+            type: account.type,
+            depth: account.depth,
+            balance: amountOf(balance),
+            postings: subtreePostings,
+        });
+    }
+    const postings = [];
+    for (const entry of input.ledger.chronological()) {
+        for (const posting of entry.postings) {
+            postings.push({
+                entryId: entry.id,
+                date: entry.date,
+                narration: entry.narration,
+                account: posting.account,
+                amount: amountOf(posting.amount),
+                contra: [
+                    ...new Set(entry.postings.filter((p) => p.account !== posting.account).map((p) => p.account)),
+                ].sort(),
+            });
+        }
+    }
+    return {
+        generatedFor: input.generatedFor ?? "tallyd",
+        account: input.account,
+        accountName: input.ledger.chart?.find(input.account)?.name ?? input.account,
+        currency: currency.code,
+        currencySymbol: currency.symbol,
+        exponent: currency.exponent,
+        period: { from: from === "" ? "—" : from, to: to === "" ? "—" : to },
+        matched: input.result.matched.map((match, index) => matchView(match, index, "m")),
+        suggested: input.result.suggested.map((match, index) => matchView(match, index, "s")),
+        unmatchedBook: input.result.unmatchedBook.map(bookLineView),
+        unmatchedStatement: input.result.unmatchedStatement.map(statementLineView),
+        bankClosingMinor: Number(input.bankClosingBalance.minorUnits),
+        bookClosingMinor: Number(input.bookClosingBalance.minorUnits),
+        accounts,
+        postings,
+        cashPosition: cashPosition(input.books),
+        confidence: CONFIDENCE_ORDER.map((label) => ({ label, count: counts.get(label) ?? 0 })),
+        trialBalanceBalanced: trialBalance(input.ledger).balanced,
+        statementFormat: input.statementFormat,
+        implied: (input.implied ?? []).map((proposal) => ({
+            lineId: proposal.line.id,
+            date: proposal.line.date,
+            description: proposal.line.description,
+            amount: amountOf(proposal.line.amount),
+            outcome: proposal.outcome,
+            account: proposal.account,
+            accountName: proposal.account === null
+                ? null
+                : (input.ledger.chart?.find(proposal.account)?.name ?? proposal.account),
+            rule: proposal.rule?.id ?? null,
+            narration: proposal.entry?.narration ?? proposal.line.description,
+            reason: proposal.reason,
+        })),
+    };
+}

package/dist/dashboard/render.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Assembling the page.
+ *
+ * One file, no network. Styles and script are inlined, the data is embedded as
+ * JSON, and nothing is fetched — because the person who most needs to look at a
+ * reconciliation is often the one who cannot install anything, and a dashboard
+ * that needs a CDN is a dashboard that fails on a train.
+ *
+ * Escaping is done here rather than trusted anywhere: bank descriptors are
+ * attacker-adjacent text in the sense that matters, which is that they contain
+ * whatever the payer typed into a reference field.
+ */
+import type { DashboardData } from "./model.js";
+export declare function escapeHtml(value: string): string;
+/**
+ * JSON safe to sit inside a `<script>` element.
+ *
+ * `</script>` anywhere in the data would close the block early — a narration
+ * reading "see </script> for details" is unlikely but the failure is total, and
+ * the fix is three replacements.
+ */
+export declare function embedJson(value: unknown): string;
+export declare function renderDashboard(data: DashboardData): string;