@inflexa-ai/harness 0.45.0 → 0.46.0

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

@@ -29,12 +29,12 @@ import type { RenderedPage, RenderProblem, RenderValues } from "./types.js";
  * three optional inputs made a caller of the last one pad the two before it, thus the inputs ride one bag.
  * An absent `chart` member derives each chart with the registered figure modules.
  */
-export interface RenderOptions {
+export type RenderOptions = {
     readonly records?: CitationRecords;
     readonly derivations?: readonly DerivationChain[];
     readonly provenance?: ProvenanceExport;
     readonly chart?: ChartOpts;
-}
+};
 /**
  * Render a report document, its value map, and the pinned citation records to one page and its data assets.
  *

package/dist/report-render/render.js

@@ -174,9 +174,9 @@ function renderBlock(block, values, ledger, records, data, depth, problems) {
             // the descriptors address the registered payload whichever block encoded it.
             const columns = tableColumns(entry);
             const derived = deriveChartRender(block, entry.rows, entry.columns, { key: block.id, columns }, {
-                ...(entry.statistics !== undefined ? { statistics: entry.statistics } : {}),
-                ...(entry.track !== undefined ? { track: entry.track } : {}),
-                ...(entry.trees !== undefined ? { trees: entry.trees } : {}),
+                statistics: entry.statistics,
+                track: entry.track,
+                trees: entry.trees,
             }, data.chart);
             if (derived.isErr()) {
                 problems.push(derived.error);
@@ -196,8 +196,8 @@ function renderBlock(block, values, ledger, records, data, depth, problems) {
             }
             return renderChart(block, ledger, derived.value.option, data.view, {
                 bodyPx: derived.value.bodyPx,
-                ...(derived.value.widthPx !== undefined ? { widthPx: derived.value.widthPx } : {}),
-                ...(svgs.value !== undefined ? { svg: { single: svgs.value.single.name, double: svgs.value.double.name } } : {}),
+                widthPx: derived.value.widthPx,
+                svg: svgs.value === undefined ? undefined : { single: svgs.value.single.name, double: svgs.value.double.name },
             });
         }
         case "section":
@@ -224,19 +224,18 @@ function renderChildren(blocks, values, ledger, records, data, depth, problems)
     let index = 0;
     while (index < blocks.length) {
         const run = metricRunLength(blocks, index);
-        const rendered = [];
-        for (let offset = 0; offset < Math.max(run, 1); offset += 1) {
-            rendered.push(renderBlock(blocks[index + offset], values, ledger, records, data, depth, problems));
-        }
+        const runLength = Math.max(run, 1);
+        const runBlocks = blocks.slice(index, index + runLength);
+        const rendered = runBlocks.map((block) => renderBlock(block, values, ledger, records, data, depth, problems));
         parts.push(run > 1 ? renderMetricGrid(rendered.join("")) : rendered.join(""));
-        index += Math.max(run, 1);
+        index += runLength;
     }
     return parts.join("");
 }
 /** The count of the metric blocks that start at `start`. A block of a different kind gives zero. */
 function metricRunLength(blocks, start) {
     let length = 0;
-    while (start + length < blocks.length && blocks[start + length].kind === "metric") {
+    while (start + length < blocks.length && blocks[start + length]?.kind === "metric") {
         length += 1;
     }
     return length;

package/dist/report-render/script-json.js

@@ -11,5 +11,5 @@
  */
 /** Serialize a value to JSON that is safe inside a `<script>` element. */
 export function scriptJson(value) {
-    return JSON.stringify(value).replace(/</g, "\\u003c");
+    return JSON.stringify(value).replaceAll("<", "\\u003c");
 }

package/dist/report-render/table-data.d.ts

@@ -34,12 +34,12 @@ export type ColumnFilter = "number" | "text";
  * The server resolves each of the four, and the page reads them. Thus the declaration, the token guess, and
  * the read of a whole column stay on the server, and the page formats and filters alone.
  */
-export interface ColumnDisplay {
+export type ColumnDisplay = {
     label: string;
     kind: NumberKind;
     filter: ColumnFilter;
     bound?: number;
-}
+};
 /**
  * One encoded table.
  *
@@ -53,18 +53,18 @@ export interface ColumnDisplay {
  * `total` is the row count of the artifact before a row bound cut it. The page states the shown count
  * against it, thus a reader of a cut table never reads the cut as the whole artifact.
  */
-export interface TablePayload {
+export type TablePayload = {
     columns: string[];
     rows: EncodedCell[][];
     dict: Record<string, string[]>;
     display: ColumnDisplay[];
     total: number;
-}
+};
 /** One data asset that the caller writes beside the page: the staged file name, and the source text of it. */
-export interface DataAsset {
+export type DataAsset = {
     name: string;
     bytes: string;
-}
+};
 /**
  * Encode a resolved table into its payload.
  *

package/dist/report-render/test/options.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The typed reads that a report-render test makes over a produced ECharts option.
+ *
+ * An accessor fails the test when a present value carries the wrong shape. It never filters a malformed
+ * entry away and never invents a default, so an assertion reads the option that the renderer built.
+ */
+import { type EchartOption } from "../chart.js";
+/** The option object that a value holds, or a failed test. */
+export declare function optionOf(value: unknown): EchartOption;
+/** The series of an option, each entry an option object. */
+export declare function seriesOf(option: EchartOption): EchartOption[];
+/** The array of option objects that the named member holds, each entry an option object. */
+export declare function optionArray(option: EchartOption, key: string): EchartOption[];
+/** The option object that the named member holds, or a failed test. */
+export declare function optionAt(option: EchartOption, key: string): EchartOption;
+/** The number that a value holds, or a failed test. */
+export declare function optionNumber(value: unknown): number;
+/** The array of numbers that a value holds, or a failed test. */
+export declare function optionNumbers(value: unknown): number[];
+/** The array of number arrays that a value holds, or a failed test. */
+export declare function optionNumberRows(value: unknown): number[][];
+/** The grid of an option at an index, or a failed test. */
+export declare function gridAt(option: EchartOption, index: number): EchartOption;
+/** The option object that a list holds at an index, or a failed test. */
+export declare function optionEntry(options: EchartOption[], index: number, what: string): EchartOption;
+/** The data of the mark line of an option: empty when the option holds no mark line. The entries stay as
+ * the renderer built them, because one mark line mixes guide objects with pairs of line ends. */
+export declare function markLineData(option: EchartOption): unknown[];
+/** The array that a value holds, or a failed test. */
+export declare function optionList(value: unknown): unknown[];
+/** The option object that the named member holds when the member is present, or `undefined`. */
+export declare function optionMaybe(option: EchartOption, key: string): EchartOption | undefined;
+/** The array of strings that a value holds, or a failed test. */
+export declare function optionStrings(value: unknown): string[];
+/** The rows of option pairs that a mark line holds, or a failed test. */
+export declare function optionPairRows(value: unknown): Array<[EchartOption, EchartOption]>;
+/** The array of option objects that a value holds, or a failed test. */
+export declare function optionsOf(value: unknown): EchartOption[];
+/** The pair of numbers that a value holds, or a failed test. */
+export declare function optionPair(value: unknown): [number, number];
+/** The function that the page source builds under the given name, called with unknown arguments. Each
+ * call runs the page source again, so a call sees new page globals. */
+export declare function pageCall(source: string, name: string): (...args: unknown[]) => unknown;
+/** The data source of one dense chart: the payload name, the rule, and one option object per series. */
+export declare function chartSourceOf(option: EchartOption): {
+    payload: string;
+    rule: unknown;
+    series: EchartOption[];
+};

package/dist/report-render/test/options.js

@@ -0,0 +1,143 @@
+/**
+ * The typed reads that a report-render test makes over a produced ECharts option.
+ *
+ * An accessor fails the test when a present value carries the wrong shape. It never filters a malformed
+ * entry away and never invents a default, so an assertion reads the option that the renderer built.
+ */
+import { isUnknownArray } from "../../lib/unknown-array.js";
+import { parseUnknownRecord } from "../../lib/unknown-containers.js";
+import { textOf } from "../../lib/unknown-text.js";
+import { CHART_SOURCE_MEMBER } from "../chart.js";
+import { pageExports } from "./page-function.js";
+/** The JSON text of a value, or `undefined` when the value holds no JSON form. The lib signature types
+ * the result `string`, but it gives back `undefined` for a value it cannot hold. */
+function stringifyJson(value) {
+    return JSON.stringify(value);
+}
+function fail(what, value) {
+    const shown = stringifyJson(value)?.slice(0, 80) ?? textOf(value);
+    throw new Error(`the produced option holds ${what} in another shape: ${shown}`);
+}
+/** The option object that a value holds, or a failed test. */
+export function optionOf(value) {
+    const option = parseUnknownRecord(value);
+    if (option === undefined)
+        fail("an option object", value);
+    return option;
+}
+/** The series of an option, each entry an option object. */
+export function seriesOf(option) {
+    if (!isUnknownArray(option.series))
+        fail("a series array", option.series);
+    return option.series.map((entry) => optionOf(entry));
+}
+/** The array of option objects that the named member holds, each entry an option object. */
+export function optionArray(option, key) {
+    if (!isUnknownArray(option[key]))
+        fail(`a ${key} array`, option[key]);
+    return option[key].map((entry) => optionOf(entry));
+}
+/** The option object that the named member holds, or a failed test. */
+export function optionAt(option, key) {
+    return optionOf(option[key]);
+}
+/** The number that a value holds, or a failed test. */
+export function optionNumber(value) {
+    if (typeof value !== "number")
+        fail("a number", value);
+    return value;
+}
+/** The array of numbers that a value holds, or a failed test. */
+export function optionNumbers(value) {
+    if (!isUnknownArray(value))
+        fail("a number array", value);
+    return value.map((entry) => optionNumber(entry));
+}
+/** The array of number arrays that a value holds, or a failed test. */
+export function optionNumberRows(value) {
+    if (!isUnknownArray(value))
+        fail("a number matrix", value);
+    return value.map((entry) => optionNumbers(entry));
+}
+/** The grid of an option at an index, or a failed test. */
+export function gridAt(option, index) {
+    return optionEntry(optionArray(option, "grid"), index, "grid");
+}
+/** The option object that a list holds at an index, or a failed test. */
+export function optionEntry(options, index, what) {
+    const entry = options[index];
+    if (entry === undefined)
+        fail(`a ${what} at index ${index}`, entry);
+    return entry;
+}
+/** The data of the mark line of an option: empty when the option holds no mark line. The entries stay as
+ * the renderer built them, because one mark line mixes guide objects with pairs of line ends. */
+export function markLineData(option) {
+    const line = optionMaybe(option, "markLine");
+    return line === undefined ? [] : optionList(line.data);
+}
+/** The array that a value holds, or a failed test. */
+export function optionList(value) {
+    if (!isUnknownArray(value))
+        fail("an array", value);
+    return value;
+}
+/** The option object that the named member holds when the member is present, or `undefined`. */
+export function optionMaybe(option, key) {
+    return option[key] === undefined ? undefined : optionAt(option, key);
+}
+/** The array of strings that a value holds, or a failed test. */
+export function optionStrings(value) {
+    if (!isUnknownArray(value))
+        fail("a string array", value);
+    return value.map((entry) => {
+        if (typeof entry !== "string")
+            fail("a string", entry);
+        return entry;
+    });
+}
+/** The rows of option pairs that a mark line holds, or a failed test. */
+export function optionPairRows(value) {
+    if (!isUnknownArray(value))
+        fail("a pair-row array", value);
+    return value.map((row) => {
+        const entries = optionList(row).map((entry) => optionOf(entry));
+        const [from, to] = entries;
+        if (from === undefined || to === undefined)
+            fail("a pair of options", row);
+        return [from, to];
+    });
+}
+/** The array of option objects that a value holds, or a failed test. */
+export function optionsOf(value) {
+    if (!isUnknownArray(value))
+        fail("an option array", value);
+    return value.map((entry) => optionOf(entry));
+}
+/** The pair of numbers that a value holds, or a failed test. */
+export function optionPair(value) {
+    const [first, second] = optionNumbers(value);
+    if (first === undefined || second === undefined)
+        fail("a pair of numbers", value);
+    return [first, second];
+}
+/** The function that the page source builds under the given name, called with unknown arguments. Each
+ * call runs the page source again, so a call sees new page globals. */
+export function pageCall(source, name) {
+    return (...args) => {
+        const made = pageExports([], [], source, [[name, name]])[name];
+        if (typeof made !== "function")
+            throw new Error(`the page source holds no ${name}`);
+        const given = Reflect.apply(made, undefined, args);
+        return given;
+    };
+}
+/** The data source of one dense chart: the payload name, the rule, and one option object per series. */
+export function chartSourceOf(option) {
+    const source = optionOf(option[CHART_SOURCE_MEMBER]);
+    if (typeof source.payload !== "string")
+        fail("a payload name", source.payload);
+    if (!isUnknownArray(source.series))
+        fail("a series array", source.series);
+    return { payload: source.payload, rule: source.rule, series: source.series.map((entry) => optionOf(entry)) };
+}

package/dist/report-render/test/page-function.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The one `Function` construction of the report-render tests, and its runners.
+ *
+ * The body is compiled page source — the string that `render.ts`, `page.ts`,
+ * or `views/*.tsx` ships — run against fake browser globals. That run is the
+ * point of these tests, not an eval of untrusted input.
+ */
+/**
+ * Run compiled page source against the fake browser globals that the params
+ * name and the args give.
+ */
+export declare function runPageScript(params: string[], args: unknown[], script: string): void;
+/**
+ * Evaluate compiled page source that ends by naming its exports, and give the
+ * record back. Each entry pairs the record key with the name that the page
+ * source binds. The record is an own-property copy: the page returns plain
+ * object literals, so no prototype member is lost.
+ */
+export declare function pageExports(params: string[], args: unknown[], source: string, exports: Array<[string, string]>): Record<string, unknown>;

package/dist/report-render/test/page-function.js

@@ -0,0 +1,33 @@
+/**
+ * The one `Function` construction of the report-render tests, and its runners.
+ *
+ * The body is compiled page source — the string that `render.ts`, `page.ts`,
+ * or `views/*.tsx` ships — run against fake browser globals. That run is the
+ * point of these tests, not an eval of untrusted input.
+ */
+import { parseUnknownRecord } from "../../lib/unknown-containers.js";
+function runPageSource(params, args, body) {
+    // oxlint-disable-next-line typescript/no-implied-eval -- compiled page source run against fake browser globals; the point of the test, not an eval of untrusted input
+    return Reflect.apply(new Function(...params, body), undefined, args);
+}
+/**
+ * Run compiled page source against the fake browser globals that the params
+ * name and the args give.
+ */
+export function runPageScript(params, args, script) {
+    runPageSource(params, args, script);
+}
+/**
+ * Evaluate compiled page source that ends by naming its exports, and give the
+ * record back. Each entry pairs the record key with the name that the page
+ * source binds. The record is an own-property copy: the page returns plain
+ * object literals, so no prototype member is lost.
+ */
+export function pageExports(params, args, source, exports) {
+    const tail = exports.map(([key, name]) => `${JSON.stringify(key)}: ${name}`).join(", ");
+    const made = runPageSource(params, args, `${source}\nreturn { ${tail} };`);
+    const record = parseUnknownRecord(made);
+    if (record === undefined)
+        throw new Error("the page source returned no record");
+    return record;
+}

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

@@ -9,20 +9,20 @@
  */
 import type { DataAsset } from "./table-data.js";
 /** One statistic of a chart: the label of the block, and the value of the cell that the statistic binds. */
-export interface RenderStatistic {
+export type RenderStatistic = {
     label: string;
     value: string | number;
-}
+};
 /** The second table of a chart: the rows of the track binding, and the optional column order. */
-export interface RenderTrack {
+export type RenderTrack = {
     rows: Array<Record<string, string | number>>;
     columns?: string[];
-}
+};
 /** The trees of the category axes of a chart: the rows of the tree binding of each axis, with its optional column order. */
-export interface RenderTrees {
+export type RenderTrees = {
     x?: RenderTrack;
     y?: RenderTrack;
-}
+};
 /**
  * The value that one block resolves to, as a closed union. A `scalar` gives one number or one string. A
  * `table` gives the rows and the optional column order. A `figure` gives a ready source string. A
@@ -56,11 +56,11 @@ export type RenderValue = {
  * One typed fault of a render. `blockId` names the block. `kind` names the class of the fault. `detail`
  * names what the block expected. The render collects every problem, and it returns them at once.
  */
-export interface RenderProblem {
+export type RenderProblem = {
     blockId: string;
     kind: "missing-value" | "wrong-shape" | "invalid-chart-input";
     detail: string;
-}
+};
 /** The value map that the renderer takes, keyed by block id. */
 export type RenderValues = Record<string, RenderValue>;
 /**
@@ -72,7 +72,7 @@ export type RenderValues = Record<string, RenderValue>;
  * The list holds the provenance assets of the render beside the table payloads and the SVG files of each
  * chart, thus one stage writes each file that the page loads or links, and the caller sorts nothing.
  */
-export interface RenderedPage {
+export type RenderedPage = {
     html: string;
     dataAssets: DataAsset[];
-}
+};

package/dist/report-render/value-bridge.d.ts

@@ -28,10 +28,10 @@ export type ResolvedFile = Extract<ResolvedValue, {
 /** The policy that turns a resolved file echo into a figure `src` string. The caller owns the policy. */
 export type FigureSourcePolicy = (file: ResolvedFile) => string;
 /** One resolved statistic of a chart: the label of the block, and the resolved value of its cell. */
-export interface StatisticResolution {
+export type StatisticResolution = {
     label: string;
     resolved: ResolvedValue;
-}
+};
 /**
  * The resolution result of one block: the block id, the block kind, and the resolved value of its binding.
  *
@@ -63,13 +63,13 @@ export type BlockResolution = {
  * needs, and `actual` names the resolved type that arrived. `slot` names the track or the statistic of a
  * chart whose value has the wrong type.
  */
-export interface BridgeMismatch {
+export type BridgeMismatch = {
     blockId: string;
     blockKind: ValueBearingKind;
     slot?: ChartSlot;
     expected: ResolvedValue["type"];
     actual: ResolvedValue["type"];
-}
+};
 /**
  * Map the resolved values of the blocks onto a `RenderValues` map.
  *

package/dist/report-render/value-bridge.js

@@ -126,16 +126,24 @@ export function collectResolutions(blocks, resolvedByBlock, resolvedBySlot) {
                     const value = slots?.get(statisticSlot(index));
                     return value === undefined ? [] : [{ label: statistic.label, resolved: value }];
                 });
-                resolutions.push({
+                const resolution = {
                     blockId: block.id,
                     kind: "chart",
                     resolved,
-                    ...(track !== undefined ? { track } : {}),
-                    ...(treeX !== undefined || treeY !== undefined
-                        ? { trees: { ...(treeX !== undefined ? { x: treeX } : {}), ...(treeY !== undefined ? { y: treeY } : {}) } }
-                        : {}),
-                    ...(statistics.length > 0 ? { statistics } : {}),
-                });
+                };
+                if (track !== undefined)
+                    resolution.track = track;
+                if (treeX !== undefined || treeY !== undefined) {
+                    const trees = {};
+                    if (treeX !== undefined)
+                        trees.x = treeX;
+                    if (treeY !== undefined)
+                        trees.y = treeY;
+                    resolution.trees = trees;
+                }
+                if (statistics.length > 0)
+                    resolution.statistics = statistics;
+                resolutions.push(resolution);
                 return;
             }
         }
@@ -183,12 +191,14 @@ function chartValue(resolution) {
     if (mismatches.length > 0 || binding.type !== "table") {
         return err(mismatches);
     }
-    return ok({
-        ...tableValue(binding),
-        ...(statistics.length > 0 ? { statistics } : {}),
-        ...(track !== undefined && track.type === "table" ? { track: secondTable(track) } : {}),
-        ...(trees.x !== undefined || trees.y !== undefined ? { trees } : {}),
-    });
+    const value = { ...tableValue(binding) };
+    if (statistics.length > 0)
+        value.statistics = statistics;
+    if (track !== undefined && track.type === "table")
+        value.track = secondTable(track);
+    if (Object.keys(trees).length > 0)
+        value.trees = trees;
+    return ok(value);
 }
 /** The rows of a second table of a chart, a track or a tree, with its column order where the resolution gives one. */
 function secondTable(value) {
@@ -213,5 +223,8 @@ function tableValue(value) {
  * arrived. A mismatch of a chart track, tree, or statistic names its slot.
  */
 function mismatch(blockId, blockKind, expected, actual, slot) {
-    return { blockId, blockKind, ...(slot !== undefined ? { slot } : {}), expected, actual };
+    const fault = { blockId, blockKind, expected, actual };
+    if (slot !== undefined)
+        fault.slot = slot;
+    return fault;
 }

package/dist/report-render/views/chart-view.d.ts

@@ -29,14 +29,14 @@ import { type ViewOptions } from "./lineage.js";
  * `bodyPx` is the height of the body, and `widthPx` is the width of a figure that draws a block of a fixed
  * size.
  */
-export interface ChartCard {
+export type ChartCard = {
     readonly svg?: {
         readonly single: string;
         readonly double: string;
     };
     readonly bodyPx: number;
     readonly widthPx?: number;
-}
+};
 /**
  * The note of a chart past the export bound that holds no point layer. The page draws its PNG, and no SVG
  * serves it.

package/dist/report-render/views/chart-view.js

@@ -82,9 +82,9 @@ export function renderChart(block, ledger, option, view = DEFAULT_VIEW_OPTIONS,
     ].join("; ");
     const stem = kebabFilename(block.title ?? block.id);
     const hybrid = card.svg === undefined && holdsPointLayer(option);
-    return String(_jsxs("div", { class: "report-chart", ...blockMark(block.id), ...lineageStamp(view.lineage, block.id, references), children: [_jsxs("div", { class: "report-chart-title", children: [block.title, markers, _jsx("button", { type: "button", id: chartMenuControlId(containerId), class: "report-chart-download", "aria-haspopup": "menu", "aria-expanded": "false", "aria-controls": chartMenuId(containerId), [MENU_CONTROL_ATTRIBUTE]: containerId, children: DOWNLOAD_CONTROL_LABEL })] }), _jsxs("div", { class: "report-chart-card corner-accents", children: [_jsx("div", { id: containerId, "data-echarts-id": block.id, class: "chart-container", ...(bodyStyle !== "" ? { style: bodyStyle } : {}) }), _jsx("script", { type: "application/json", children: raw(json) }), _jsxs("div", { id: chartMenuId(containerId), class: "report-chart-menu", role: "menu", "aria-label": MENU_LABEL, children: [SVG_EXPORTS.map((kind) => {
+    return String(_jsxs("div", { class: "report-chart", ...blockMark(block.id), ...lineageStamp(view.lineage, block.id, references), children: [_jsxs("div", { class: "report-chart-title", children: [block.title, markers, _jsx("button", { type: "button", id: chartMenuControlId(containerId), class: "report-chart-download", "aria-haspopup": "menu", "aria-expanded": "false", "aria-controls": chartMenuId(containerId), [MENU_CONTROL_ATTRIBUTE]: containerId, children: DOWNLOAD_CONTROL_LABEL })] }), _jsxs("div", { class: "report-chart-card corner-accents", children: [_jsx("div", { id: containerId, "data-echarts-id": block.id, class: "chart-container", style: bodyStyle === "" ? undefined : bodyStyle }), _jsx("script", { type: "application/json", children: raw(json) }), _jsxs("div", { id: chartMenuId(containerId), class: "report-chart-menu", role: "menu", "aria-label": MENU_LABEL, children: [SVG_EXPORTS.map((kind) => {
                                 const size = exportSizeFor(CHART_EXPORT_SIZES[kind], card.bodyPx);
-                                const file = `${stem}-${size.widthMm}mm.svg`;
+                                const file = `${stem}-${String(size.widthMm)}mm.svg`;
                                 const label = `SVG · ${size.label}`;
                                 if (card.svg !== undefined) {
                                     return (_jsx("a", { class: "report-chart-menu-item", role: "menuitem", tabindex: -1, href: stagedSource(card.svg[kind]), download: file, children: label }));

package/dist/report-render/views/lineage.d.ts

@@ -30,9 +30,9 @@ import type { Reference } from "../../contracts/report-reference.js";
  * `lineage` states that the page carries a provenance document. Each grounded block then stamps its keys
  * and shows its control, and a page with no document carries neither.
  */
-export interface ViewOptions {
+export type ViewOptions = {
     readonly lineage: boolean;
-}
+};
 /**
  * The options that a view takes when the caller gives none. Each truth is off, thus the view renders its
  * plain form.
@@ -47,15 +47,15 @@ export declare const LINEAGE_KEY_ATTRIBUTE = "data-lineage-key";
 /** The class of the control that opens the chain of one reference. */
 export declare const LINEAGE_CONTROL_CLASS = "report-lineage";
 /** The pin of one artifact: the analysis-relative path, and the content hash of the bytes. */
-export interface LineagePin {
+export type LineagePin = {
     readonly path: string;
     readonly hash: string;
-}
+};
 /** The identity of one external record: the identifier space, and the identifier inside it. */
-export interface LineageRecord {
+export type LineageRecord = {
     readonly idKind: string;
     readonly id: string;
-}
+};
 /** One key of a stamp. A reference that pins no single file gives `null` in place of a key. */
 export type LineageKey = LineagePin | LineageRecord;
 /**

package/dist/report-render/views/lineage.js

@@ -27,6 +27,7 @@ const LINEAGE_GLYPH_CLASS = "report-lineage-glyph";
  * both reach the drawing and the sheet holds one color for the two states. The glyph is decoration, thus
  * it hides from a reader who hears the page and the label of the button answers instead.
  */
+// oxlint-disable-next-line typescript/explicit-function-return-type -- hono's JSX ElementType contract demands FunctionComponentResult, which its own jsxDEV factory return (JSXNode) does not satisfy; no writable type names what the body returns, so the inferred JSXNode return stays.
 function LineageGlyph() {
     return (_jsxs("svg", { class: LINEAGE_GLYPH_CLASS, width: "13", height: "13", viewBox: "0 0 16 16", fill: "none", stroke: "currentColor", "stroke-width": "1.5", "aria-hidden": "true", children: [_jsx("circle", { cx: "4", cy: "4", r: "2" }), _jsx("circle", { cx: "4", cy: "12", r: "2" }), _jsx("circle", { cx: "12", cy: "12", r: "2" }), _jsx("path", { d: "M4 6v4" }), _jsx("path", { d: "M6 12h4" }), _jsx("path", { d: "M12 10V8a4 4 0 0 0-4-4H6" })] }));
 }
@@ -81,6 +82,7 @@ export function lineagePlace(on, reference, index = 0) {
  * The control names its place and never its key. The stamp of the block holds the keys, thus one page
  * carries one copy of each key and a claim of several bindings repeats none of them.
  */
+// oxlint-disable-next-line typescript/explicit-function-return-type -- hono's JSX ElementType contract demands FunctionComponentResult, which its own jsxDEV factory return (JSXNode) does not satisfy; no writable type names what the body returns, so the inferred JSXNode return stays.
 export function LineageControl({ place }) {
     return (_jsx("button", { type: "button", class: LINEAGE_CONTROL_CLASS, "aria-label": LINEAGE_CONTROL_LABEL, "aria-expanded": "false", [LINEAGE_KEY_ATTRIBUTE]: String(place), children: _jsx(LineageGlyph, {}) }));
 }

package/dist/report-render/views/page-view.d.ts

@@ -44,11 +44,11 @@ export declare function renderReferenceSection(ledger: ReferenceLedger, index: n
  * of one type takes no fault at the build when a caller swaps the two. Thus the group rides one bag, and
  * each member of it carries its own name.
  */
-export interface PageAssets {
+export type PageAssets = {
     readonly dataAssets: readonly DataAsset[];
     readonly grids: boolean;
     readonly provenanceAssets: readonly DataAsset[];
-}
+};
 /**
  * Assemble the page from the title, the navigation, the main content, the reference frame, and the data
  * assets. The title passes through the runtime as text, and the runtime escapes it. The reference frame is

package/dist/report-render/views/page-view.js

@@ -69,6 +69,7 @@ export function renderReferenceSection(ledger, index, records, chains) {
     if (references === "") {
         return "";
     }
+    // oxlint-disable-next-line typescript/no-base-to-string -- hono JSXNode.toString() renders these sync element trees to HTML; the rule sees only its declared `string | Promise<string>` return.
     const heading = String(_jsx("h2", { class: "report-heading report-heading-3 report-ref-title", children: REFERENCES_TITLE }));
     return renderBand(index, heading + references);
 }