@inflexa-ai/harness 0.42.2 → 0.43.0

package/dist/report-model/block-walk.js

@@ -13,8 +13,16 @@
  * The walk resolves nothing and it opens no file. It reports what the tree holds, and a caller decides
  * which part it needs.
  */
-import { channelColumn } from "../contracts/report-blocks.js";
+import { channelColumn, channelOrder } from "../contracts/report-blocks.js";
 import { holdsADriftedExponent } from "../report-render/number-format.js";
+/** The slot of the tree of one axis. */
+export function treeSlot(axis) {
+    return `tree:${axis}`;
+}
+/** The slot of the statistic at one index of a chart block. */
+export function statisticSlot(index) {
+    return `statistic:${index}`;
+}
 /**
  * A free-standing token that looks like a number, with an optional decimal part and an optional percent
  * sign.
@@ -69,9 +77,10 @@ function proseWarnings(blockId, prose) {
 /**
  * Each column that the grammar of one chart names.
  *
- * The quick path names its four channels and its label. A composition names the channels of each series,
- * the lower bound of a band, the label of each series, and the column of each rank rule. A transform rides
- * beside its column, thus a transformed channel names the same column as a plain one.
+ * The quick path names its channels and its label. A composition names the channels of each series, the
+ * lower bound of a band, the label of each series, the column of each rank rule, and its facet. A transform
+ * rides beside its column, thus a transformed channel names the same column as a plain one. A channel that
+ * sorts its categories names its sort column right after its own column.
  *
  * A name comes back one time, in the order that the grammar states it. Thus a refusal names each absent
  * column one time.
@@ -83,8 +92,10 @@ function chartColumns(block) {
             columns.push(column);
     };
     const addChannel = (channel) => {
-        if (channel !== undefined)
-            add(channelColumn(channel));
+        if (channel === undefined)
+            return;
+        add(channelColumn(channel));
+        add(channelOrder(channel)?.by);
     };
     const encoding = block.encoding;
     if (encoding !== undefined) {
@@ -93,6 +104,19 @@ function chartColumns(block) {
         addChannel(encoding.group);
         addChannel(encoding.value);
         add(encoding.label);
+        addChannel(encoding.color);
+        addChannel(encoding.size);
+        addChannel(encoding.low);
+        addChannel(encoding.high);
+        addChannel(encoding.facet);
+        addChannel(encoding.shape);
+        addChannel(encoding.p);
+        addChannel(encoding.censor);
+        addChannel(encoding.risk);
+        addChannel(encoding.hit);
+        addChannel(encoding.metric);
+        for (const column of encoding.tracks ?? [])
+            add(column);
     }
     const composition = block.composition;
     if (composition !== undefined) {
@@ -102,14 +126,47 @@ function chartColumns(block) {
             addChannel(series.encoding.y0);
             addChannel(series.encoding.group);
             add(series.encoding.label);
+            addChannel(series.encoding.color);
+            addChannel(series.encoding.size);
+            addChannel(series.encoding.low);
+            addChannel(series.encoding.high);
         }
         for (const annotation of composition.annotations ?? []) {
             if (annotation.kind === "point-labels")
                 add(annotation.column);
         }
+        addChannel(composition.facet);
     }
     return columns;
 }
+/** Each column of its own table that the track of a chart names: the start, the end, the label, and the length. */
+function trackColumns(track) {
+    return [track.start, track.end, track.label, ...(track.length !== undefined ? [track.length] : [])];
+}
+/** Each column of its own table that the tree of one axis names: the parent, the child, and the height. */
+function treeColumns(tree) {
+    return [tree.parent, tree.child, tree.height];
+}
+/**
+ * The references of one chart block, in the order of the block: the binding, the track, the tree of `x`, the
+ * tree of `y`, and each statistic. Each one carries its slot.
+ */
+function chartReferences(block) {
+    const references = [{ blockId: block.id, reference: block.binding, slot: "binding", encodingColumns: chartColumns(block) }];
+    if (block.track !== undefined) {
+        references.push({ blockId: block.id, reference: block.track.binding, slot: "track", encodingColumns: trackColumns(block.track) });
+    }
+    for (const axis of ["x", "y"]) {
+        const tree = block.trees?.[axis];
+        if (tree !== undefined) {
+            references.push({ blockId: block.id, reference: tree.binding, slot: treeSlot(axis), encodingColumns: treeColumns(tree) });
+        }
+    }
+    for (const [index, statistic] of (block.statistics ?? []).entries()) {
+        references.push({ blockId: block.id, reference: statistic.value, slot: statisticSlot(index) });
+    }
+    return references;
+}
 /**
  * Walk a block tree, and report each reference, each repeated id, and each free numeral.
  *
@@ -152,7 +209,7 @@ export function walkBlocks(blocks) {
                 references.push({ blockId: block.id, reference: block.value });
                 return;
             case "chart":
-                references.push({ blockId: block.id, reference: block.binding, encodingColumns: chartColumns(block) });
+                references.push(...chartReferences(block));
                 return;
             case "table":
             case "figure":

package/dist/report-model/draft-finish.d.ts

@@ -27,7 +27,7 @@
  */
 import { type ReportDocument } from "../contracts/report-blocks.js";
 import type { UnresolvedReference } from "../contracts/report-reference.js";
-import { type ReportWarning } from "./block-walk.js";
+import { type ChartSlot, type ReportWarning } from "./block-walk.js";
 import type { DraftDocument } from "./draft.js";
 import type { ReportSnapshot } from "./reference-resolver.js";
 /** A schema conformance gap, reduced to a path and a message. */
@@ -41,10 +41,14 @@ export interface DuplicateIdGap {
     kind: "duplicate-id";
     id: string;
 }
-/** An unresolved reference gap. It ties the block that carries the reference to the reason it did not resolve. */
+/**
+ * An unresolved reference gap. It ties the block that carries the reference to the reason it did not resolve.
+ * `slot` names the place of the reference inside a chart block: the binding, the track, a tree, or one statistic.
+ */
 export interface UnresolvedReferenceGap {
     kind: "unresolved-reference";
     blockId: string;
+    slot?: ChartSlot;
     failure: UnresolvedReference;
 }
 /** One completeness gap of a draft. The kind set is closed. */

package/dist/report-model/draft-finish.js

@@ -76,7 +76,12 @@ export function finishDraft(draft, snapshot, derivations = []) {
     for (const entry of references) {
         const result = validateReferenceStructure(entry.reference, snapshot, entry.encodingColumns);
         if (result.isErr()) {
-            gaps.push({ kind: "unresolved-reference", blockId: entry.blockId, failure: result.error });
+            gaps.push({
+                kind: "unresolved-reference",
+                blockId: entry.blockId,
+                ...(entry.slot !== undefined ? { slot: entry.slot } : {}),
+                failure: result.error,
+            });
         }
     }
     // A schema failure always pushes a gap. Thus an empty gap list means the parse passed. The

package/dist/report-model/production-resolver.d.ts

@@ -20,6 +20,8 @@
 import { type Result } from "neverthrow";
 import type { Suspension } from "../workflows/suspension.js";
 import { type ReferenceResolver } from "./reference-resolver.js";
+/** One artifact row, as plain cells. A text-backed format holds a numeric column as a string. */
+type Row = Record<string, string | number>;
 /**
  * One artifact that the host fast path could not read, addressed for the extraction arm. The `hash` pins
  * the exact bytes, thus the arm reads the same artifact that the identity layer verified.
@@ -116,6 +118,11 @@ export type TabularFormat = "csv" | "tsv" | "json" | "parquet";
  * drops the same value to `None`, thus the host arm and the sandbox arm read the same bytes the same way.
  */
 export declare function coerceCell(value: unknown): string | number | undefined;
+/**
+ * Parse a delimited file into rows. The first record is the header. A ragged record and a repeated header
+ * name are structural doubt, thus each gives back `undefined` and the file falls through.
+ */
+export declare function parseDelimited(text: string, delimiter: string): Row[] | undefined;
 /**
  * Make the production resolver over the workspace root and the optional extraction arm.
  *
@@ -125,3 +132,4 @@ export declare function coerceCell(value: unknown): string | number | undefined;
  * artifact on both paths, and never one read for each reference.
  */
 export declare function createProductionResolver(deps: ProductionResolverDeps): ReferenceResolver;
+export {};

package/dist/report-model/production-resolver.js

@@ -236,7 +236,7 @@ function parseRecords(text, delimiter) {
  * Parse a delimited file into rows. The first record is the header. A ragged record and a repeated header
  * name are structural doubt, thus each gives back `undefined` and the file falls through.
  */
-function parseDelimited(text, delimiter) {
+export function parseDelimited(text, delimiter) {
     const records = parseRecords(text, delimiter);
     if (records === undefined) {
         return undefined;

package/dist/report-model/validate.d.ts

@@ -8,7 +8,7 @@
  * each reference against the pinned evidence, and it warns about the prose of each block.
  */
 import type { UnresolvedReference } from "../contracts/report-reference.js";
-import { type AnyBlock, type CollectedReference, type ReportWarning } from "./block-walk.js";
+import { type AnyBlock, type ChartSlot, type CollectedReference, type ReportWarning } from "./block-walk.js";
 import { type ReferenceResolver, type ReportSnapshot, type ResolvedValue } from "./reference-resolver.js";
 export type { ReportWarning };
 /**
@@ -23,9 +23,13 @@ export interface SchemaIssue {
     path: string;
     message: string;
 }
-/** One reference that did not resolve, tied to the block that carries it. */
+/**
+ * One reference that did not resolve, tied to the block that carries it. `slot` names the place of the
+ * reference inside a chart block, thus a reviewer tells a failed track or statistic from a failed binding.
+ */
 export interface ResolutionFailure {
     blockId: string;
+    slot?: ChartSlot;
     failure: UnresolvedReference;
 }
 /**
@@ -44,17 +48,22 @@ export type ReportValidation = {
     warnings: ReportWarning[];
 };
 /**
- * Match each column that a chart encoding names against the table that its binding resolved to.
+ * Match each column that a chart names against the table that its binding, its track, or a tree resolved to.
  *
- * The binding schema admits a table reference only, thus a resolved value of another type means that the
- * bound resolver broke its own contract. That is reported and never ignored, because a chart with no
+ * The binding, the track, and the tree schema admit a table reference only, thus a resolved value of another type means
+ * that the bound resolver broke its own contract. That is reported and never ignored, because a chart with no
  * table behind it renders nothing and a silent skip would pass it as grounded.
  */
 export declare function checkChartEncoding(entry: CollectedReference, value: ResolvedValue): UnresolvedReference | undefined;
 /** The resolved values and the failures of one resolution pass over the references of a block tree. */
 export interface ReferenceResolution {
-    /** The resolved value of each block whose reference resolved, keyed by its block id. */
+    /** The resolved value of the binding of each block whose binding resolved, keyed by its block id. */
     resolvedByBlock: Map<string, ResolvedValue>;
+    /**
+     * The resolved value of each other slot of a chart, keyed by the block id and then by the slot: the track,
+     * each tree, and each statistic. A chart that binds none of them holds no entry.
+     */
+    resolvedBySlot: Map<string, Map<ChartSlot, ResolvedValue>>;
     /** Each reference that did not resolve, or whose chart encoding named an absent column. */
     failures: ResolutionFailure[];
 }
@@ -62,10 +71,11 @@ export interface ReferenceResolution {
  * Resolve each reference of a block tree under the concurrency bound, and run the chart-encoding match.
  *
  * The walk collects each reference one time, `allWithConcurrency` bounds the fan-out, and
- * `checkChartEncoding` catches a chart that plots a column which the bound table does not hold. The record
- * gate and the preview share this one pass, thus the two refuse the same references. A value-bearing block
- * whose reference resolved carries its value in the map. A claim or a citation reference reads no value
- * from the map. The walk collects every failure, thus a reviewer sees each block that broke.
+ * `checkChartEncoding` catches a chart that plots a column which the bound table or the track does not hold.
+ * The record gate and the preview share this one pass, thus the two refuse the same references. A
+ * value-bearing block whose binding resolved carries its value in the map, and the track and each statistic
+ * of a chart carry their values under their slots. A claim or a citation reference reads no value from the
+ * map. The walk collects every failure, thus a reviewer sees each block and each slot that broke.
  */
 export declare function resolveDocumentReferences(sections: readonly AnyBlock[], snapshot: ReportSnapshot, resolver: ReferenceResolver): Promise<ReferenceResolution>;
 /** Resolve each reference, collect the schema conformance and the resolution outcomes, and warn on prose. */

package/dist/report-model/validate.js

@@ -18,11 +18,17 @@ import { columnsHeldByNoRow } from "./reference-resolver.js";
  * unbounded fan-out would open one read for each reference at the same moment.
  */
 export const RESOLUTION_CONCURRENCY = 8;
+/** The role of one chart slot whose columns name a table: the binding, the track, or a tree. */
+function tableRole(slot) {
+    if (slot === "track")
+        return "track";
+    return slot === "tree:x" || slot === "tree:y" ? "tree" : "binding";
+}
 /**
- * Match each column that a chart encoding names against the table that its binding resolved to.
+ * Match each column that a chart names against the table that its binding, its track, or a tree resolved to.
  *
- * The binding schema admits a table reference only, thus a resolved value of another type means that the
- * bound resolver broke its own contract. That is reported and never ignored, because a chart with no
+ * The binding, the track, and the tree schema admit a table reference only, thus a resolved value of another type means
+ * that the bound resolver broke its own contract. That is reported and never ignored, because a chart with no
  * table behind it renders nothing and a silent skip would pass it as grounded.
  */
 export function checkChartEncoding(entry, value) {
@@ -30,8 +36,9 @@ export function checkChartEncoding(entry, value) {
     if (encodingColumns === undefined || encodingColumns.length === 0) {
         return undefined;
     }
+    const role = tableRole(entry.slot);
     if (value.type !== "table") {
-        return { reference: entry.reference, reason: "locator-out-of-range", detail: `the chart binding resolved to a ${value.type} and not to a table` };
+        return { reference: entry.reference, reason: "locator-out-of-range", detail: `the chart ${role} resolved to a ${value.type} and not to a table` };
     }
     const absent = columnsHeldByNoRow(value.rows, encodingColumns);
     if (absent.length === 0) {
@@ -40,17 +47,18 @@ export function checkChartEncoding(entry, value) {
     return {
         reference: entry.reference,
         reason: "locator-out-of-range",
-        detail: `the encoding names column ${absent.join(", ")}, which the bound table does not hold`,
+        detail: `the ${role === "binding" ? "encoding" : role} names column ${absent.join(", ")}, which the ${role === "binding" ? "bound" : role} table does not hold`,
     };
 }
 /**
  * Resolve each reference of a block tree under the concurrency bound, and run the chart-encoding match.
  *
  * The walk collects each reference one time, `allWithConcurrency` bounds the fan-out, and
- * `checkChartEncoding` catches a chart that plots a column which the bound table does not hold. The record
- * gate and the preview share this one pass, thus the two refuse the same references. A value-bearing block
- * whose reference resolved carries its value in the map. A claim or a citation reference reads no value
- * from the map. The walk collects every failure, thus a reviewer sees each block that broke.
+ * `checkChartEncoding` catches a chart that plots a column which the bound table or the track does not hold.
+ * The record gate and the preview share this one pass, thus the two refuse the same references. A
+ * value-bearing block whose binding resolved carries its value in the map, and the track and each statistic
+ * of a chart carry their values under their slots. A claim or a citation reference reads no value from the
+ * map. The walk collects every failure, thus a reviewer sees each block and each slot that broke.
  */
 export async function resolveDocumentReferences(sections, snapshot, resolver) {
     const { references } = walkBlocks(sections);
@@ -62,19 +70,27 @@ export async function resolveDocumentReferences(sections, snapshot, resolver) {
     const resolved = await allWithConcurrency(references.map((entry) => () => resolver.resolve(entry.reference, snapshot).then((result) => ({ entry, result }))), RESOLUTION_CONCURRENCY);
     const failures = [];
     const resolvedByBlock = new Map();
+    const resolvedBySlot = new Map();
     for (const { entry, result } of resolved) {
+        const slot = entry.slot !== undefined ? { slot: entry.slot } : {};
         if (result.isErr()) {
-            failures.push({ blockId: entry.blockId, failure: result.error });
+            failures.push({ blockId: entry.blockId, ...slot, failure: result.error });
             continue;
         }
         const encodingFailure = checkChartEncoding(entry, result.value);
         if (encodingFailure !== undefined) {
-            failures.push({ blockId: entry.blockId, failure: encodingFailure });
+            failures.push({ blockId: entry.blockId, ...slot, failure: encodingFailure });
+            continue;
+        }
+        if (entry.slot === undefined || entry.slot === "binding") {
+            resolvedByBlock.set(entry.blockId, result.value);
             continue;
         }
-        resolvedByBlock.set(entry.blockId, result.value);
+        const slots = resolvedBySlot.get(entry.blockId) ?? new Map();
+        slots.set(entry.slot, result.value);
+        resolvedBySlot.set(entry.blockId, slots);
     }
-    return { resolvedByBlock, failures };
+    return { resolvedByBlock, resolvedBySlot, failures };
 }
 /** Resolve each reference, collect the schema conformance and the resolution outcomes, and warn on prose. */
 export async function validateReport(document, snapshot, resolver) {

package/dist/report-render/chart-export.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The SVG export of one chart: the server-side render of the chart runtime at a journal column width.
+ *
+ * The export renders the option of the page with every row inline, in the print theme, through the same
+ * named renderers as the page. Thus the chart that a reader sees is the chart that the paper gets.
+ *
+ * The bytes are a pure function of the option. The chart runtime numbers its instances and its style
+ * classes with counters of the whole process, thus two renders of one option differ in those tokens alone.
+ * The export renumbers each token in order of first appearance, and two renders give one byte sequence.
+ */
+import type * as Echarts from "echarts";
+import { type Result } from "neverthrow";
+import type { EchartOption } from "./chart.js";
+import { type ChartExportSize } from "./design.js";
+import type { DataAsset } from "./table-data.js";
+import type { RenderProblem } from "./types.js";
+/** The module of the chart runtime. The SVG export draws with it on the server. */
+export type ChartRuntime = typeof Echarts;
+/**
+ * Load the chart runtime.
+ *
+ * The runtime loads on the first export and not with this module. The harness entry reaches this module, thus
+ * a static import makes each process that loads the harness pay for the runtime, also a process that exports
+ * no chart. The module cache keeps the first load, thus a later call costs nothing.
+ */
+export declare function loadChartRuntime(): Promise<ChartRuntime>;
+/** The two SVG files of one chart: the single journal column and the double journal column. */
+export interface ChartSvgs {
+    readonly single: DataAsset;
+    readonly double: DataAsset;
+}
+/**
+ * Render one option to SVG text at one column size.
+ *
+ * The export registers the print theme and each named renderer before it draws, and each registration of
+ * one name gives the same theme or the same function. The chart runtime is code outside the harness, thus its
+ * throw becomes the message of an `err`. The instance is disposed in every case, thus no render leaves a timer
+ * behind.
+ */
+export declare function renderChartSvg(echarts: ChartRuntime, option: EchartOption, size: ChartExportSize): Result<string, string>;
+/**
+ * The two SVG files of one chart, or `undefined` for a chart past the export bound.
+ *
+ * The option is the chart with every row inline. A chart whose plotted point count passes the crowd row
+ * count gets no staged SVG. The page builds the hybrid SVG of such a chart, or the menu states that the PNG
+ * serves a chart that holds no point layer. An option that the chart runtime cannot
+ * draw refuses, and the refusal names the block.
+ *
+ * `bodyPx` is the height of the page chart body. A taller body draws each column at a taller height, thus a
+ * row of the figure keeps its share of the height.
+ */
+export declare function chartSvgAssets(echarts: ChartRuntime, blockId: string, option: EchartOption, bodyPx?: number): Result<ChartSvgs | undefined, RenderProblem>;

package/dist/report-render/chart-export.js

@@ -0,0 +1,192 @@
+/**
+ * The SVG export of one chart: the server-side render of the chart runtime at a journal column width.
+ *
+ * The export renders the option of the page with every row inline, in the print theme, through the same
+ * named renderers as the page. Thus the chart that a reader sees is the chart that the paper gets.
+ *
+ * The bytes are a pure function of the option. The chart runtime numbers its instances and its style
+ * classes with counters of the whole process, thus two renders of one option differ in those tokens alone.
+ * The export renumbers each token in order of first appearance, and two renders give one byte sequence.
+ */
+import { createHash } from "node:crypto";
+import { err, ok } from "neverthrow";
+import { exportOption, OUTLINE_RENDERER, registerChartRenderers } from "./chart-renderers.js";
+import { CHART_BODY_PX, CHART_EXPORT_SIZES, CHART_PRINT_THEME_NAME, CHART_PRINT_TEXT_PX, chartTheme, exportSizeFor, SCATTER_CROWD_ROWS, } from "./design.js";
+import { millimeterRoot } from "./hybrid-svg.js";
+/** One instance token of the chart runtime: a class, a clip path, or a gradient, for example `zr1-cls-2`. */
+const INSTANCE_TOKEN = /zr\d+-[a-z]+-?\d+/g;
+/**
+ * The places where the chart runtime writes an instance token: the value of an `id` or a `class` attribute,
+ * a `url(#...)` reference, and the style block. A text node is none of them, thus a category name that
+ * reads as a token keeps its text.
+ */
+const TOKEN_PLACES = /\s(?:id|class)="[^"]*"|url\(#[^)]*\)|<style[^>]*>[\s\S]*?<\/style>/g;
+/** The count of hash characters in an asset name. It matches the name of a table asset. */
+const HASH_CHARS = 12;
+/**
+ * Load the chart runtime.
+ *
+ * The runtime loads on the first export and not with this module. The harness entry reaches this module, thus
+ * a static import makes each process that loads the harness pay for the runtime, also a process that exports
+ * no chart. The module cache keeps the first load, thus a later call costs nothing.
+ */
+export function loadChartRuntime() {
+    return import("echarts");
+}
+/**
+ * Render one option to SVG text at one column size.
+ *
+ * The export registers the print theme and each named renderer before it draws, and each registration of
+ * one name gives the same theme or the same function. The chart runtime is code outside the harness, thus its
+ * throw becomes the message of an `err`. The instance is disposed in every case, thus no render leaves a timer
+ * behind.
+ */
+export function renderChartSvg(echarts, option, size) {
+    echarts.registerTheme(CHART_PRINT_THEME_NAME, chartTheme(CHART_PRINT_TEXT_PX));
+    registerChartRenderers({
+        // The runtime types each item dimension as a string or a number. Each item that the derivation writes
+        // for a named renderer holds numbers alone, thus the renderer reads a number at each dimension.
+        registerCustomSeries: (name, render) => echarts.registerCustomSeries(name, render),
+    });
+    let chart;
+    // The axis jitter of the chart runtime places a point that finds no free place with `Math.random`. The
+    // render below runs to its end in one synchronous call, thus the seeded sequence serves this render alone,
+    // and the same option gives the same points and the same bytes. The finally block puts the global back.
+    const random = Math.random;
+    Math.random = seededRandom(EXPORT_RANDOM_SEED);
+    try {
+        chart = echarts.init(null, CHART_PRINT_THEME_NAME, { renderer: "svg", ssr: true, width: size.widthPx, height: size.heightPx });
+        chart.setOption(exportOption(option, CHART_PRINT_TEXT_PX, size.widthPx, size.heightPx));
+        return ok(finishedSvg(chart.renderToSVGString(), size));
+    }
+    catch (cause) {
+        return err(cause instanceof Error ? cause.message : String(cause));
+    }
+    finally {
+        Math.random = random;
+        chart?.dispose();
+    }
+}
+/** The seed of the sequence that stands for `Math.random` during one export. Any fixed value serves. */
+const EXPORT_RANDOM_SEED = 0x2f6b1e35;
+/**
+ * A deterministic sequence of numbers in `[0, 1)` from one seed: the mulberry32 generator. Each call of the
+ * returned function gives the next number.
+ */
+function seededRandom(seed) {
+    let state = seed >>> 0;
+    return () => {
+        state = (state + 0x6d2b79f5) >>> 0;
+        let t = state;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+/**
+ * The SVG text with its root at the millimeter size, and with each instance token renumbered.
+ *
+ * The root states the width and the height of the column in millimeters, and the view box keeps the pixel
+ * space of the render. Thus a vector editor opens the file at the column width. The renumber reads the
+ * places of the tokens in document order in one pass, thus the style block, each clip path, each gradient,
+ * and each element that names one of them agree.
+ */
+function finishedSvg(svg, size) {
+    const tokens = new Map();
+    const renumber = (token) => {
+        let next = tokens.get(token);
+        if (next === undefined) {
+            const family = /^zr\d+-([a-z]+)/.exec(token)?.[1] ?? "t";
+            next = `zr0-${family}-${tokens.size}`;
+            tokens.set(token, next);
+        }
+        return next;
+    };
+    return millimeterRoot(svg.replace(TOKEN_PLACES, (place) => place.replace(INSTANCE_TOKEN, renumber)), size);
+}
+/**
+ * The count of coordinates that one option draws, summed over its series.
+ *
+ * The count bounds the export. A cloud of many thousands of points gives an SVG of many megabytes, two times,
+ * thus the page builds the SVG of such a chart on a click, with the points as one raster layer. An empty slot draws nothing, thus it counts nothing. A radar
+ * polygon draws one coordinate for each indicator, and a violin outline draws two vertices for each grid
+ * point, thus each counts every coordinate that it draws.
+ */
+function plottedPoints(option) {
+    const series = option.series;
+    if (!Array.isArray(series))
+        return 0;
+    let count = 0;
+    for (const entry of series) {
+        if (typeof entry !== "object" || entry === null)
+            continue;
+        const fields = entry;
+        if (!Array.isArray(fields.data))
+            continue;
+        for (const item of fields.data) {
+            if (fields.type === "radar")
+                count += polygonCoordinates(item);
+            else if (fields.renderItem === OUTLINE_RENDERER)
+                count += outlineVertices(item);
+            else
+                count += drawnItem(item) ? 1 : 0;
+        }
+    }
+    return count;
+}
+/** True when one item draws a coordinate: a number, or a value whose members hold no empty slot. */
+function drawnItem(item) {
+    const value = typeof item === "object" && item !== null && !Array.isArray(item) ? item.value : item;
+    if (typeof value === "number")
+        return true;
+    return Array.isArray(value) && value.every((member) => member !== null && member !== undefined && member !== "-");
+}
+/**
+ * The count of vertices that one violin outline draws. The item leads with the category, the extent, and the
+ * offset, then holds one pair for each grid point, and the outline draws each point on its right side and on
+ * its left side.
+ */
+function outlineVertices(item) {
+    return Array.isArray(item) ? Math.max(0, item.length - OUTLINE_LEAD_MEMBERS) : 0;
+}
+/** The members of an outline item before its grid pairs: the category, the two ends of the extent, and the offset. */
+const OUTLINE_LEAD_MEMBERS = 4;
+/** The count of coordinates that one radar polygon draws: each member of its value that is not empty. */
+function polygonCoordinates(item) {
+    const value = typeof item === "object" && item !== null ? item.value : undefined;
+    return Array.isArray(value) ? value.filter((member) => member !== null && member !== undefined).length : 0;
+}
+/** One SVG asset: the content-addressed name, with the column in millimeters, and the text. */
+function svgAsset(bytes, size) {
+    const hash = createHash("sha256").update(bytes).digest("hex").slice(0, HASH_CHARS);
+    return { name: `c-${hash}-${size.widthMm}mm.svg`, bytes };
+}
+/**
+ * The two SVG files of one chart, or `undefined` for a chart past the export bound.
+ *
+ * The option is the chart with every row inline. A chart whose plotted point count passes the crowd row
+ * count gets no staged SVG. The page builds the hybrid SVG of such a chart, or the menu states that the PNG
+ * serves a chart that holds no point layer. An option that the chart runtime cannot
+ * draw refuses, and the refusal names the block.
+ *
+ * `bodyPx` is the height of the page chart body. A taller body draws each column at a taller height, thus a
+ * row of the figure keeps its share of the height.
+ */
+export function chartSvgAssets(echarts, blockId, option, bodyPx = CHART_BODY_PX) {
+    if (plottedPoints(option) > SCATTER_CROWD_ROWS) {
+        return ok(undefined);
+    }
+    const singleSize = exportSizeFor(CHART_EXPORT_SIZES.single, bodyPx);
+    const doubleSize = exportSizeFor(CHART_EXPORT_SIZES.double, bodyPx);
+    const single = renderChartSvg(echarts, option, singleSize);
+    if (single.isErr())
+        return err(exportProblem(blockId, single.error));
+    const double = renderChartSvg(echarts, option, doubleSize);
+    if (double.isErr())
+        return err(exportProblem(blockId, double.error));
+    return ok({ single: svgAsset(single.value, singleSize), double: svgAsset(double.value, doubleSize) });
+}
+/** The refusal of an option that the chart runtime refused to draw. */
+function exportProblem(blockId, cause) {
+    return { blockId, kind: "invalid-chart-input", detail: `The chart runtime refused to draw the SVG export of the chart: ${cause}` };
+}