@inflexa-ai/harness 0.45.1 → 0.46.0

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

@@ -5,7 +5,59 @@
  * belief points at. The harness declares the seam here, thus a production realization can read storage,
  * and a fixture realization can read an in-memory snapshot. The two obey the same contract.
  */
+import { err, ok } from "neverthrow";
+import { z } from "zod";
 import { asFiniteNumber } from "./assert-rules.js";
+/** One cell that a row of a snapshot may hold: a string or a number, or one of the empty-cell shapes. */
+const CellSchema = z.union([z.string(), z.number()]).nullish();
+/**
+ * Put one own data property on a row.
+ *
+ * A plain assignment at the key `__proto__` reaches the prototype setter, thus the row loses a column
+ * that the payload carries. The definition makes an own data property for each key.
+ */
+function defineOwn(target, key, value) {
+    Object.defineProperty(target, key, { value, enumerable: true, writable: true, configurable: true });
+}
+/**
+ * Give back the present cells of a snapshot entry's rows, or an empty array for an entry with no rows.
+ *
+ * The structural tier and the fixture resolver both read this one parse. Thus the two tiers can never
+ * disagree about the rows of one entry.
+ *
+ * A real parser gives an empty cell back as an absent key, `undefined`, or `null`; the parse admits each
+ * and yields the present cells, so the reads below see one absence shape only. The `Err` channel carries
+ * the account of a row that the artifact forbids: an entry of the rows list that is not a record, or a
+ * cell that is neither a string nor a number. The caller refuses the reference through its own channel,
+ * so a malformed row never throws out of resolution.
+ */
+export function snapshotRows(entry) {
+    const rows = entry?.rows;
+    if (rows === undefined)
+        return ok([]);
+    if (!Array.isArray(rows))
+        return err("the rows of the artifact are not a list");
+    const list = rows;
+    const parsed = [];
+    for (const [index, row] of list.entries()) {
+        if (row === null || typeof row !== "object" || Array.isArray(row)) {
+            return err(`row ${index} of the artifact is not a record`);
+        }
+        const cells = {};
+        for (const column of Object.keys(row)) {
+            const cell = Reflect.get(row, column);
+            const read = CellSchema.safeParse(cell);
+            if (!read.success) {
+                return err(`the cell ${column} of row ${index} is neither a string, a number, nor empty`);
+            }
+            if (read.data !== undefined && read.data !== null) {
+                defineOwn(cells, column, read.data);
+            }
+        }
+        parsed.push(cells);
+    }
+    return ok(parsed);
+}
 /**
  * Give back each name in `columns` that no row holds, in the order of `columns`.
  *
@@ -47,15 +99,19 @@ function rankText(left, right) {
     return 0;
 }
 /**
- * A row that holds no rank in the column, which the bound keeps last in either direction.
+ * The row as a rankable row, or `undefined` for a row that holds no rank in the column. The bound keeps
+ * such a row last in either direction.
  *
  * A row that the column does not reach carries no value to rank. In a numeric column a cell that reads as
  * no number carries none either: a sentinel such as `NA` is the absence of a measurement, and a rank for it
  * against a real value would be invented. Thus a descending bound of the top 20 rows gives 20 measurements,
  * and never 20 sentinels.
  */
-function holdsNoRank(entry, numeric) {
-    return entry.cell === undefined || (numeric && entry.value === undefined);
+function asRankable(entry, numeric) {
+    const { cell } = entry;
+    if (cell === undefined || (numeric && entry.value === undefined))
+        return undefined;
+    return { ...entry, cell };
 }
 /**
  * The rank of two rows that both hold one. A numeric column compares the parsed numbers, and a column
@@ -92,8 +148,15 @@ export function applyRowBound(rows, bound) {
     const numeric = ranked.some((entry) => entry.value !== undefined);
     // A row with no rank stays behind every ranked row, and the direction never lifts it. The two lists
     // keep their source order, thus the tail is as stable as the head.
-    const rankable = ranked.filter((entry) => !holdsNoRank(entry, numeric));
-    const unrankable = ranked.filter((entry) => holdsNoRank(entry, numeric));
+    const rankable = [];
+    const unrankable = [];
+    for (const entry of ranked) {
+        const kept = asRankable(entry, numeric);
+        if (kept === undefined)
+            unrankable.push(entry);
+        else
+            rankable.push(kept);
+    }
     const sorted = [...rankable].sort((left, right) => {
         const rank = rankRankable(left, right, numeric);
         return rank === 0 ? left.index - right.index : descending ? -rank : rank;

package/dist/report-model/reference-stamp.js

@@ -22,17 +22,23 @@
 import { err, ok } from "neverthrow";
 import { snapshotEntry } from "./reference-resolver.js";
 /**
- * The three reference kinds that name one artifact directly, thus the three kinds that take a hash.
+ * Give the authored record of an object that takes a stamp, or `undefined` when the object takes none.
  *
- * The `satisfies` clause ties each literal to a member of the reference union. A renamed kind becomes a
- * compile error here. A new kind passes with no error, because the stamp fills a known kind and it never
- * refuses one.
+ * The test reads the shape alone, because the payload reaches the stamp before the grammar parse. A hash
+ * that the object carries decides nothing here, because the stamp writes the hash of the snapshot over it.
+ * The copy the function returns is the refusal's view of the author's object: the walk still stamps and
+ * returns the original, and the copy holds the same own enumerable fields, so the serialized refusal is
+ * unchanged.
  */
-const PINNED_KINDS = new Set(["artifact-value", "artifact-table", "artifact-file"]);
-/** Give `true` when an object carries an artifact pin. Such an object takes a stamp, and a read removes its hash. */
-function holdsPin(record) {
-    const { kind } = record;
-    return typeof kind === "string" && PINNED_KINDS.has(kind);
+function stampablePin(record) {
+    if (!("kind" in record) || !("path" in record))
+        return undefined;
+    const kind = record.kind;
+    const path = record.path;
+    const pinned = kind === "artifact-value" ? "artifact-value" : kind === "artifact-table" ? "artifact-table" : kind === "artifact-file" ? "artifact-file" : undefined;
+    if (pinned === undefined || typeof path !== "string")
+        return undefined;
+    return { path, record: { ...record, kind: pinned, path } };
 }
 /**
  * Put one own data property on a copy.
@@ -43,19 +49,6 @@ function holdsPin(record) {
 function defineOwn(target, key, value) {
     Object.defineProperty(target, key, { value, enumerable: true, writable: true, configurable: true });
 }
-/**
- * Give the artifact path of an object that takes a stamp, or `undefined` when the object takes none.
- *
- * The test reads the shape alone, because the payload reaches the stamp before the grammar parse. A hash
- * that the object carries decides nothing here, because the stamp writes the hash of the snapshot over it.
- */
-function stampablePath(record) {
-    const { path } = record;
-    if (!holdsPin(record) || typeof path !== "string") {
-        return undefined;
-    }
-    return path;
-}
 /**
  * Walk one value, and give the value with the hash of each artifact reference filled from the snapshot.
  *
@@ -78,23 +71,23 @@ function stampValue(value, snapshot, missing) {
     if (value === null || typeof value !== "object") {
         return value;
     }
-    const record = value;
     let changed = false;
     const next = {};
-    for (const key of Object.keys(record)) {
-        const stamped = stampValue(record[key], snapshot, missing);
-        if (stamped !== record[key]) {
+    for (const key of Object.keys(value)) {
+        const held = Reflect.get(value, key);
+        const stamped = stampValue(held, snapshot, missing);
+        if (stamped !== held) {
             changed = true;
         }
         defineOwn(next, key, stamped);
     }
-    const path = stampablePath(record);
-    if (path === undefined) {
+    const pin = stampablePin(value);
+    if (pin === undefined) {
         return changed ? next : value;
     }
-    const entry = snapshotEntry(snapshot, path);
+    const entry = snapshotEntry(snapshot, pin.path);
     if (entry === undefined) {
-        missing.push({ path, record });
+        missing.push({ path: pin.path, record: pin.record });
         return changed ? next : value;
     }
     return { ...next, hash: entry.hash };
@@ -116,9 +109,8 @@ export function stampReferenceHashes(payload, snapshot) {
         return ok(stamped);
     }
     const unresolved = missing.map((pin) => ({
-        // The payload reaches the stamp before the parse, thus the object holds the fields of a reference
-        // as the author wrote them. The refusal names that object, and this assertion is the one place
-        // where the pre-parse shape enters the parsed reference type.
+        // The payload reaches the stamp before the parse, thus the refusal carries the object as the
+        // author wrote it, and the `AuthoredPinRecord` arm of `UnresolvedReferenceSchema` types it.
         reference: pin.record,
         reason: "artifact-missing",
         detail: `no artifact at ${pin.path}`,
@@ -154,17 +146,17 @@ export function stripReferenceHashes(value) {
     if (value === null || typeof value !== "object") {
         return value;
     }
-    const record = value;
-    const pinned = holdsPin(record);
+    const pinned = stampablePin(value) !== undefined;
     let changed = false;
     const next = {};
-    for (const key of Object.keys(record)) {
+    for (const key of Object.keys(value)) {
         if (pinned && key === "hash") {
             changed = true;
             continue;
         }
-        const stripped = stripReferenceHashes(record[key]);
-        if (stripped !== record[key]) {
+        const held = Reflect.get(value, key);
+        const stripped = stripReferenceHashes(held);
+        if (stripped !== held) {
             changed = true;
         }
         defineOwn(next, key, stripped);

package/dist/report-model/structural-validation.js

@@ -8,7 +8,7 @@
  * value. As a result the costly read happens one time for each report version, and never for each edit.
  */
 import { err, ok } from "neverthrow";
-import { columnsHeldByNoRow, fileTypeHoldsNoCell, snapshotEntry } from "./reference-resolver.js";
+import { columnsHeldByNoRow, fileTypeHoldsNoCell, snapshotEntry, snapshotRows } from "./reference-resolver.js";
 /** Build an `Err` that carries the unresolved reference. The `detail` key is present only when there is a detail to carry. */
 function fail(reference, reason, detail) {
     const failure = detail !== undefined ? { reference, reason, detail } : { reference, reason };
@@ -29,7 +29,7 @@ function validatePin(reference, snapshot) {
     const readsACell = reference.kind === "artifact-value" || reference.kind === "artifact-table";
     const fileType = entry.fileType;
     if (readsACell && fileTypeHoldsNoCell(fileType)) {
-        return fail(reference, "unreadable-artifact", `the ${fileType} at ${reference.path} holds no cell to read`);
+        return fail(reference, "unreadable-artifact", `the ${String(fileType)} at ${reference.path} holds no cell to read`);
     }
     return ok();
 }
@@ -51,7 +51,11 @@ function validateColumns(reference, snapshot, columns) {
             return fail(reference, "locator-out-of-range", `the chart names column ${outside.join(", ")}, which the bound column subset leaves out`);
         }
     }
-    const absent = columnsHeldByNoRow(snapshotEntry(snapshot, reference.path)?.rows ?? [], columns);
+    const readRows = snapshotRows(snapshotEntry(snapshot, reference.path));
+    if (readRows.isErr()) {
+        return fail(reference, "unreadable-artifact", `the artifact at ${reference.path} holds a malformed row: ${readRows.error}`);
+    }
+    const absent = columnsHeldByNoRow(readRows.value, columns);
     if (absent.length > 0) {
         return fail(reference, "locator-out-of-range", `the chart names column ${absent.join(", ")}, which the bound table does not hold`);
     }
@@ -80,7 +84,11 @@ export function validateReferenceStructure(reference, snapshot, columns) {
             // artifact does not hold refuses here, exactly as a grammar column of a chart does.
             const bound = reference.rowBound;
             if (bound !== undefined) {
-                const absent = columnsHeldByNoRow(snapshotEntry(snapshot, reference.path)?.rows ?? [], [bound.column]);
+                const readRows = snapshotRows(snapshotEntry(snapshot, reference.path));
+                if (readRows.isErr()) {
+                    return fail(reference, "unreadable-artifact", `the artifact at ${reference.path} holds a malformed row: ${readRows.error}`);
+                }
+                const absent = columnsHeldByNoRow(readRows.value, [bound.column]);
                 if (absent.length > 0) {
                     return fail(reference, "locator-out-of-range", `the row bound names column ${bound.column}, which the bound table does not hold`);
                 }

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

@@ -10,7 +10,7 @@
 import type { UnresolvedReference } from "../contracts/report-reference.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 };
+export type { ReportWarning } from "./block-walk.js";
 /**
  * The cap on how many references resolve at the same time.
  *
@@ -19,19 +19,19 @@ export type { ReportWarning };
  */
 export declare const RESOLUTION_CONCURRENCY = 8;
 /** One schema conformance problem, reduced to a path and a message. */
-export interface SchemaIssue {
+export type SchemaIssue = {
     path: string;
     message: string;
-}
+};
 /**
  * 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 {
+export type ResolutionFailure = {
     blockId: string;
     slot?: ChartSlot;
     failure: UnresolvedReference;
-}
+};
 /**
  * The result of validation. `valid` is false when the schema failed, a block id repeats, or a reference
  * did not resolve. `duplicateIds` names each repeated id one time, in sorted order. The warnings ride
@@ -56,7 +56,7 @@ export type ReportValidation = {
  */
 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 {
+export type ReferenceResolution = {
     /** The resolved value of the binding of each block whose binding resolved, keyed by its block id. */
     resolvedByBlock: Map<string, ResolvedValue>;
     /**
@@ -66,7 +66,7 @@ export interface ReferenceResolution {
     resolvedBySlot: Map<string, Map<ChartSlot, ResolvedValue>>;
     /** Each reference that did not resolve, or whose chart encoding named an absent column. */
     failures: ResolutionFailure[];
-}
+};
 /**
  * Resolve each reference of a block tree under the concurrency bound, and run the chart-encoding match.
  *

package/dist/report-model/validate.js

@@ -105,12 +105,12 @@ export async function validateReport(document, snapshot, resolver) {
     const { repeatedIds, warnings } = walkBlocks(parsed.data.sections);
     const { failures: resolutionFailures } = await resolveDocumentReferences(parsed.data.sections, snapshot, resolver);
     if (repeatedIds.length > 0 || resolutionFailures.length > 0) {
-        return {
-            valid: false,
-            ...(repeatedIds.length > 0 ? { duplicateIds: repeatedIds } : {}),
-            ...(resolutionFailures.length > 0 ? { resolutionFailures } : {}),
-            warnings,
-        };
+        const failure = { valid: false, warnings };
+        if (repeatedIds.length > 0)
+            failure.duplicateIds = repeatedIds;
+        if (resolutionFailures.length > 0)
+            failure.resolutionFailures = resolutionFailures;
+        return failure;
     }
     return { valid: true, warnings };
 }

package/dist/report-render/assets.d.ts

@@ -26,10 +26,10 @@ export declare const DEPS_DIR = "deps";
  * One staged asset. `file` is the path under the assets directory, and `specifier` is the module
  * specifier of the source file inside the installed package.
  */
-export interface PageAsset {
+export type PageAsset = {
     readonly file: string;
     readonly specifier: string;
-}
+};
 /** The relative source of a staged asset. The page directory is self-contained, thus the source is `assets/<file>`. */
 export declare function assetSource(asset: PageAsset): string;
 /** The relative source of a staged file by its name. A page reference never spells the directory itself. */

package/dist/report-render/assets.js

@@ -43,10 +43,34 @@ const HASH_CHARS = 12;
  * The head takes the hex alone, and the basename takes each unsafe run as one dash.
  */
 export function tableSidecarName(hash, path) {
-    const hex = hash.slice(hash.lastIndexOf(":") + 1).replace(/[^a-z0-9]+/gi, "");
-    const base = path.slice(path.lastIndexOf("/") + 1).replace(/[^a-z0-9._-]+/gi, "-");
+    const hex = keepAlphanumeric(hash.slice(hash.lastIndexOf(":") + 1));
+    const base = keepFileSafe(path.slice(path.lastIndexOf("/") + 1));
     return `${hex.slice(0, HASH_CHARS)}-${base}`;
 }
+/** Each character outside the letters and digits leaves the text. */
+function keepAlphanumeric(text) {
+    return Array.from(text).filter(isNameChar).join("");
+}
+/** Each run of characters outside `[a-zA-Z0-9._-]` becomes one dash. */
+function keepFileSafe(text) {
+    let out = "";
+    let inRun = false;
+    for (const char of text) {
+        const safe = isNameChar(char) || char === "." || char === "_" || char === "-";
+        if (safe) {
+            out += char;
+            inRun = false;
+        }
+        else if (!inRun) {
+            out += "-";
+            inRun = true;
+        }
+    }
+    return out;
+}
+function isNameChar(char) {
+    return (char >= "a" && char <= "z") || (char >= "A" && char <= "Z") || (char >= "0" && char <= "9");
+}
 /**
  * The staged name of the script of one derivation: a hash head, in the content-address style of a data
  * asset.
@@ -59,7 +83,7 @@ export function tableSidecarName(hash, path) {
  * container.
  */
 export function derivationScriptName(scriptHash) {
-    const hex = scriptHash.slice(scriptHash.lastIndexOf(":") + 1).replace(/[^a-z0-9]+/gi, "");
+    const hex = keepAlphanumeric(scriptHash.slice(scriptHash.lastIndexOf(":") + 1));
     return `d-${hex.slice(0, HASH_CHARS)}.py`;
 }
 /** The chart runtime. The page-side bootstrap reads the `echarts` global that this file declares. */

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

@@ -11,6 +11,7 @@
 import type * as Echarts from "echarts";
 import { type Result } from "neverthrow";
 import type { EchartOption } from "./chart.js";
+import { type RenderApi } from "./chart-renderers.js";
 import { type ChartExportSize } from "./design.js";
 import type { DataAsset } from "./table-data.js";
 import type { RenderProblem } from "./types.js";
@@ -25,10 +26,17 @@ export type ChartRuntime = typeof Echarts;
  */
 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 {
+export type ChartSvgs = {
     readonly single: DataAsset;
     readonly double: DataAsset;
-}
+};
+/**
+ * The part of the chart runtime API that a renderer reads, taken from the API of the runtime.
+ *
+ * The runtime types each item dimension as its parsed value, and the derivation writes numbers alone,
+ * thus the number and text conversions read the same values that the raw API gives.
+ */
+export declare function rendererApi(api: Echarts.CustomSeriesRenderItemAPI): RenderApi;
 /**
  * Render one option to SVG text at one column size.
  *

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

@@ -8,18 +8,24 @@
  * 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 { errorMessageOf } from "../lib/thrown.js";
+import { textOf } from "../lib/unknown-text.js";
 import { createHash } from "node:crypto";
 import { err, ok } from "neverthrow";
 import { exportOption, OUTLINE_RENDERER, registerChartRenderers } from "./chart-renderers.js";
+import { isUnknownArray } from "../lib/unknown-array.js";
+import { parseUnknownRecord } from "../lib/unknown-containers.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`. */
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- the chart-runtime token grammar (zr<digits>-<family>-<n>); the renumbering rewrites exactly these tokens and nothing else.
 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.
  */
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- the three attribute and reference places carry the tokens; the alternation bounds the rewrite to them.
 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;
@@ -33,6 +39,26 @@ const HASH_CHARS = 12;
 export function loadChartRuntime() {
     return import("echarts");
 }
+/** One pair of pixel numbers, as the renderer API reads it from the coordinate of the chart runtime. */
+function pixelPair(values) {
+    if (typeof values === "number")
+        return [values, values];
+    return [values[0] ?? Number.NaN, values[1] ?? Number.NaN];
+}
+/**
+ * The part of the chart runtime API that a renderer reads, taken from the API of the runtime.
+ *
+ * The runtime types each item dimension as its parsed value, and the derivation writes numbers alone,
+ * thus the number and text conversions read the same values that the raw API gives.
+ */
+export function rendererApi(api) {
+    return {
+        value: (dimension) => Number(api.value(dimension)),
+        coord: (point) => pixelPair(api.coord(point)),
+        size: (delta) => pixelPair(api.size?.(delta) ?? []),
+        visual: (name) => textOf(api.visual(name)),
+    };
+}
 /**
  * Render one option to SVG text at one column size.
  *
@@ -44,9 +70,7 @@ export function loadChartRuntime() {
 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),
+        registerCustomSeries: (name, render) => echarts.registerCustomSeries(name, (params, api) => render({ itemPayload: params.itemPayload }, rendererApi(api))),
     });
     let chart;
     // The axis jitter of the chart runtime places a point that finds no free place with `Math.random`. The
@@ -60,7 +84,7 @@ export function renderChartSvg(echarts, option, size) {
         return ok(finishedSvg(chart.renderToSVGString(), size));
     }
     catch (cause) {
-        return err(cause instanceof Error ? cause.message : String(cause));
+        return err(errorMessageOf(cause) ?? textOf(cause));
     }
     finally {
         Math.random = random;
@@ -96,7 +120,9 @@ function finishedSvg(svg, size) {
     const renumber = (token) => {
         let next = tokens.get(token);
         if (next === undefined) {
-            const family = /^zr\d+-([a-z]+)/.exec(token)?.[1] ?? "t";
+            const family = 
+            // oxlint-disable-next-line eslint-js/no-restricted-syntax -- the token family (zr<digits>-<letters>) is the runtime's own naming scheme, read verbatim from the token it renumbers.
+            /^zr\d+-([a-z]+)/.exec(token)?.[1] ?? "t";
             next = `zr0-${family}-${tokens.size}`;
             tokens.set(token, next);
         }
@@ -118,10 +144,10 @@ function plottedPoints(option) {
         return 0;
     let count = 0;
     for (const entry of series) {
-        if (typeof entry !== "object" || entry === null)
+        const fields = parseUnknownRecord(entry);
+        if (fields === undefined)
             continue;
-        const fields = entry;
-        if (!Array.isArray(fields.data))
+        if (!isUnknownArray(fields.data))
             continue;
         for (const item of fields.data) {
             if (fields.type === "radar")
@@ -136,7 +162,7 @@ function plottedPoints(option) {
 }
 /** 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;
+    const value = parseUnknownRecord(item)?.value ?? item;
     if (typeof value === "number")
         return true;
     return Array.isArray(value) && value.every((member) => member !== null && member !== undefined && member !== "-");
@@ -153,13 +179,13 @@ function outlineVertices(item) {
 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;
+    const value = parseUnknownRecord(item)?.value;
     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 };
+    return { name: `c-${hash}-${String(size.widthMm)}mm.svg`, bytes };
 }
 /**
  * The two SVG files of one chart, or `undefined` for a chart past the export bound.

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

@@ -22,15 +22,15 @@ export declare const MANHATTAN_P_THRESHOLD = 5e-8;
 /** The baseline of an MA plot. A point above it rose, and a point below it fell. */
 export declare const MA_BASELINE = 0;
 /** The semantic axis titles of one preset. A preset whose axis carries no fixed quantity states none. */
-export interface PresetAxisTitles {
+export type PresetAxisTitles = {
     readonly x?: string;
     readonly y?: string;
-}
+};
 /** One category of a preset classification: the name that a legend reads, and whether it states no finding. */
-export interface PresetCategory {
+export type PresetCategory = {
     readonly name: string;
     readonly muted: boolean;
-}
+};
 /**
  * The classification rule as plain data: the kind of the split, and the two cuts that it reads.
  *
@@ -63,16 +63,16 @@ export type PresetRule = {
  * guide lines carry. The color split then lands on the drawn lines. A row that gives no pair belongs to no
  * category, and its point drops.
  */
-export interface PresetClassification {
+export type PresetClassification = {
     readonly categories: readonly PresetCategory[];
     readonly categoryOf: (x: number | null, y: number | null, index: number) => string | undefined;
     readonly rule: PresetRule;
-}
+};
 /** The expansion of the volcano: the composition of its points and its guides, and its classification. */
-export interface PresetExpansion {
+export type PresetExpansion = {
     readonly composition: ChartComposition;
     readonly classification: PresetClassification;
-}
+};
 /**
  * The composition of a volcano: the effect on x, the transformed p-value on y, three guide lines, and the
  * three-way classification.

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

@@ -124,12 +124,12 @@ function volcanoClassification(significance, effect) {
  * `axes` field, where an agent title sits and where they would outrank the label.
  */
 export function volcanoAxisTitles(x) {
-    return { ...(channelTransform(x) === undefined ? { x: LOG2_EFFECT_TITLE } : {}), y: NEG_LOG10_P_TITLE };
+    return { x: channelTransform(x) === undefined ? LOG2_EFFECT_TITLE : undefined, y: NEG_LOG10_P_TITLE };
 }
 /** The two optional channels that the volcano carries through from the quick-path encoding. */
 function optionalChannels(encoding) {
     return {
-        ...(encoding.group !== undefined ? { group: encoding.group } : {}),
-        ...(encoding.label !== undefined ? { label: encoding.label } : {}),
+        group: encoding.group,
+        label: encoding.label,
     };
 }