@inflexa-ai/harness 0.48.3 → 0.48.5

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

@@ -13,9 +13,9 @@
  * holds the streamed hash and the parsed rows against a stat signature. Two tool calls of one analysis
  * share one cache.
  *
- * The realization calls the shared assert functions in `assert-rules.ts`, and it mirrors the locator walk
- * and the reason choices of `fixture-resolver.ts`. Thus one semantics exists, and the fixture stays the
- * executable specification of the value tier. The two realizations are substitutable behind the seam.
+ * The realization calls the shared assert functions in `assert-rules.ts` and the shared reference reads in
+ * `reference-read.ts`, as the fixture realization does. Thus one semantics exists, and the fixture stays
+ * the executable specification of the value tier. The two realizations are substitutable behind the seam.
  */
 import { err, ok } from "neverthrow";
 import { readFile, stat } from "node:fs/promises";
@@ -26,8 +26,9 @@ import { allWithConcurrency } from "../lib/async-utils.js";
 import { computeSha256File } from "../lib/fs-helpers.js";
 import { parseJsonAs } from "../lib/parse-json.js";
 import { resolveWorkspacePath } from "../workspace/paths.js";
-import { asFiniteNumber, cellMatchesFilterValue, checkCitationAssertion, checkValueAssertion } from "./assert-rules.js";
-import { applyRowBound, columnsHeldByNoRow, fileTypeHoldsNoCell, snapshotEntry, } from "./reference-resolver.js";
+import { checkValueAssertion } from "./assert-rules.js";
+import { fail, readArtifactTable, resolveCitation, resolveDerivation, selectRow } from "./reference-read.js";
+import { fileTypeHoldsNoCell, snapshotEntry } from "./reference-resolver.js";
 /**
  * The default cap on the file size that the host fast path reads. A larger file takes the fall-through.
  * The cap gates the cell extraction only. The identity compare streams the hash at every size.
@@ -95,15 +96,6 @@ export function createArtifactReadStore() {
 function fallThroughCells(path, hostDetail) {
     return { kind: "unavailable", detail: `the host read of the file at ${path} stopped because ${hostDetail}, and no other reader exists` };
 }
-/** 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 };
-    return err(failure);
-}
-/** A short account of a derivation input, for a detail that names which input broke the arithmetic. */
-function describeReference(reference) {
-    return `artifact value at ${reference.path} column ${reference.locator.column}`;
-}
 /**
  * Map a file extension to the format that the host arm reads. An unknown extension gives back `undefined`.
  *
@@ -538,36 +530,15 @@ export function createProductionResolver(deps) {
     /** Walk the locator over the rows, and match the resolved cell against the authored belief. */
     function selectCell(reference, rows) {
         const locator = reference.locator;
-        let selectedRow;
-        if (locator.row !== undefined) {
-            const row = rows[locator.row];
-            if (row === undefined) {
-                return fail(reference, "locator-out-of-range", `row ${locator.row} is outside the ${rows.length} rows`);
-            }
-            selectedRow = row;
-        }
-        else if (locator.rowFilter !== undefined) {
-            const filter = locator.rowFilter;
-            const matches = rows.filter((row) => cellMatchesFilterValue(row[filter.column], filter.value));
-            const match = matches[0];
-            if (match === undefined) {
-                return fail(reference, "locator-out-of-range", `no row where ${filter.column} equals ${String(filter.value)}`);
-            }
-            if (matches.length > 1) {
-                return fail(reference, "ambiguous-match", `${matches.length} rows where ${filter.column} equals ${String(filter.value)}`);
-            }
-            selectedRow = match;
-        }
-        else {
-            // The locator schema forbids a locator with neither selector. The resolver cannot depend on a
-            // prior parse, thus it treats a row that no selector addresses as out of range.
-            return fail(reference, "locator-out-of-range", "the locator selects no row");
+        const selection = selectRow(rows, locator);
+        if (selection.isErr()) {
+            return fail(reference, selection.error.reason, selection.error.detail);
         }
         // A real table holds an empty cell, and a parse gives it back as an absent key. An absent key is
         // not a value that a scalar reference can bind. An empty string is a value, thus it stays valid.
         // A cell that parsed as `null` never lands in a row: `coerceCell` drops it, so `null` is not
         // an absence the resolver can meet here.
-        const cell = selectedRow[locator.column];
+        const cell = selection.value[locator.column];
         if (cell === undefined) {
             return fail(reference, "locator-out-of-range", `column ${locator.column} holds no value in the selected row`);
         }
@@ -583,41 +554,7 @@ export function createProductionResolver(deps) {
         if (gated.isErr()) {
             return err(gated.error);
         }
-        // The bound ranks the rows as the artifact holds them, thus a bound over a column that the subset
-        // below leaves out still ranks them. An unknown bound column addresses nothing, exactly as an
-        // unknown subset column does.
-        const bound = reference.rowBound;
-        const allRows = gated.value;
-        if (bound !== undefined && columnsHeldByNoRow(allRows, [bound.column]).length > 0) {
-            return fail(reference, "locator-out-of-range", `the row bound names column ${bound.column}, which the table at ${reference.path} does not hold`);
-        }
-        const rows = bound === undefined ? allRows : applyRowBound(allRows, bound);
-        // The page states the shown count against the count of the artifact. This read is the one place that
-        // holds both, thus a bounded table carries the pre-bound total out with its rows.
-        const total = bound === undefined ? {} : { total: allRows.length };
-        const columns = reference.columns;
-        if (columns === undefined) {
-            return ok({ type: "table", rows, ...total });
-        }
-        // A name that no row holds addresses nothing. Without this check a projection onto an invented
-        // column gives an empty cell for each row and still resolves, which grounding exists to reject.
-        const absent = columnsHeldByNoRow(rows, columns);
-        if (absent.length > 0) {
-            return fail(reference, "locator-out-of-range", `the table at ${reference.path} holds no column ${absent.join(", ")}`);
-        }
-        // Project each row onto the requested columns. A table tolerates a ragged row, thus a column that
-        // a given row lacks is left out of that row and is not a failure.
-        const projectedRows = rows.map((row) => {
-            const projected = {};
-            for (const column of columns) {
-                const cell = row[column];
-                if (cell !== undefined) {
-                    projected[column] = cell;
-                }
-            }
-            return projected;
-        });
-        return ok({ type: "table", rows: projectedRows, columns, ...total });
+        return readArtifactTable(reference, gated.value);
     }
     async function resolveArtifactFile(reference, snapshot) {
         const identity = await getIdentity(reference.path, snapshot);
@@ -632,58 +569,6 @@ export function createProductionResolver(deps) {
         }
         return ok({ type: "file", path: reference.path, hash: identity.onDiskHash });
     }
-    async function resolveDerivation(reference, snapshot) {
-        const numbers = [];
-        for (const input of reference.inputs) {
-            const inputResult = await resolveArtifactValue(input, snapshot);
-            if (inputResult.isErr()) {
-                // Keep the inner reason so a reviewer sees the real cause, for example a missing artifact
-                // under the derivation. The derivation itself did not fail on its own terms.
-                return fail(reference, inputResult.error.reason, inputResult.error.detail);
-            }
-            const resolved = inputResult.value;
-            const numeric = resolved.type === "scalar" ? asFiniteNumber(resolved.value) : undefined;
-            if (numeric === undefined) {
-                // The arithmetic needs a finite number. A cell that holds text does not address a usable
-                // scalar, thus the closest reason is that the coordinate is out of range.
-                return fail(reference, "locator-out-of-range", `input ${describeReference(input)} did not resolve to a finite number`);
-            }
-            numbers.push(numeric);
-        }
-        const a = numbers[0];
-        const b = numbers[1];
-        if (a === undefined || b === undefined) {
-            return fail(reference, "locator-out-of-range", `operation ${reference.op} needs two inputs, and the derivation holds ${numbers.length}`);
-        }
-        let result;
-        switch (reference.op) {
-            case "ratio":
-                result = a / b;
-                break;
-            case "delta":
-                result = a - b;
-                break;
-            case "pctChange":
-                // A fraction, not a percent. A change of one half gives 0.5, thus an author asserts 0.5 and
-                // a `unit` of `%` only tells a renderer how to show it.
-                result = (a - b) / b;
-                break;
-        }
-        if (!Number.isFinite(result)) {
-            return fail(reference, "locator-out-of-range", `operation ${reference.op} does not yield a finite value, because the divisor is zero`);
-        }
-        const valueFailure = checkValueAssertion(reference, reference.assert?.value, reference.assert?.tolerance, result);
-        return valueFailure !== undefined ? err(valueFailure) : ok({ type: "scalar", value: result });
-    }
-    function resolveCitation(reference, snapshot) {
-        const key = `${reference.idKind}:${reference.id}`;
-        if (snapshot.citations === undefined || !snapshot.citations.includes(key)) {
-            return fail(reference, "artifact-missing", `the citation ${key} is not in the pinned evidence`);
-        }
-        const value = { type: "citation", id: key };
-        const citationFailure = checkCitationAssertion(reference, reference.assert?.value, key);
-        return citationFailure !== undefined ? err(citationFailure) : ok(value);
-    }
     async function resolve(reference, snapshot) {
         switch (reference.kind) {
             case "artifact-value":
@@ -693,7 +578,7 @@ export function createProductionResolver(deps) {
             case "artifact-file":
                 return resolveArtifactFile(reference, snapshot);
             case "derivation":
-                return resolveDerivation(reference, snapshot);
+                return resolveDerivation(reference, snapshot, resolveArtifactValue);
             case "citation":
                 return resolveCitation(reference, snapshot);
         }

package/dist/report-model/reference-read.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The reads of a report reference that the two resolver realizations share.
+ *
+ * The fixture resolver reads the rows of a snapshot, and the production resolver reads the rows of the
+ * pinned artifact on disk. What both do with those rows — the locator walk, the table read, and the
+ * derivation arithmetic — lives here, so one semantics exists for both realizations.
+ */
+import { type Result } from "neverthrow";
+import type { ArtifactTableReference, ArtifactValueReference, CitationReference, DerivationInputReference, DerivationReference, Reference, UnresolvedReason, UnresolvedReference } from "../contracts/report-reference.js";
+import { type ReportSnapshot, type ResolvedValue } 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. */
+export declare function fail(reference: Reference, reason: UnresolvedReason, detail?: string): Result<ResolvedValue, UnresolvedReference>;
+/** The failure of a row selection: the reason that an `UnresolvedReference` carries, and its detail. */
+export type RowSelectionFailure = {
+    reason: "locator-out-of-range" | "ambiguous-match";
+    detail: string;
+};
+/**
+ * Walk a locator over the rows, and give back the one row that it selects, or the failure.
+ *
+ * A row index selects the row at that position. A row filter selects the one row that matches; no match
+ * selects nothing, and two or more matches are ambiguous.
+ */
+export declare function selectRow(rows: Array<Record<string, string | number>>, locator: ArtifactValueReference["locator"]): Result<Record<string, string | number>, RowSelectionFailure>;
+/**
+ * Read the table that a table reference addresses out of rows that the caller read from the artifact:
+ * cut the rows on the row bound, refuse a column that no row holds, and project the requested columns.
+ */
+export declare function readArtifactTable(reference: ArtifactTableReference, allRows: Array<Record<string, string | number>>): Result<ResolvedValue, UnresolvedReference>;
+/**
+ * Resolve a derivation: read each input with `resolveInput`, then run the arithmetic of the operation.
+ *
+ * The read of an input stays with the realization: the fixture resolver reads its snapshot, and the
+ * production resolver reads the pinned artifact on disk.
+ */
+export declare function resolveDerivation(reference: DerivationReference, snapshot: ReportSnapshot, resolveInput: (input: DerivationInputReference, snapshot: ReportSnapshot) => Promise<Result<ResolvedValue, UnresolvedReference>>): Promise<Result<ResolvedValue, UnresolvedReference>>;
+/** Resolve a citation: confirm that the id is in the pinned evidence, and echo the key back. */
+export declare function resolveCitation(reference: CitationReference, snapshot: ReportSnapshot): Result<ResolvedValue, UnresolvedReference>;

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

@@ -0,0 +1,149 @@
+/**
+ * The reads of a report reference that the two resolver realizations share.
+ *
+ * The fixture resolver reads the rows of a snapshot, and the production resolver reads the rows of the
+ * pinned artifact on disk. What both do with those rows — the locator walk, the table read, and the
+ * derivation arithmetic — lives here, so one semantics exists for both realizations.
+ */
+import { err, ok } from "neverthrow";
+import { asFiniteNumber, cellMatchesFilterValue, checkCitationAssertion, checkValueAssertion } from "./assert-rules.js";
+import { applyRowBound, columnsHeldByNoRow, defineOwn } 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. */
+export function fail(reference, reason, detail) {
+    const failure = detail !== undefined ? { reference, reason, detail } : { reference, reason };
+    return err(failure);
+}
+/** A short account of a derivation input, for a detail that names which input broke the arithmetic. */
+function describeReference(reference) {
+    return `artifact value at ${reference.path} column ${reference.locator.column}`;
+}
+/**
+ * Walk a locator over the rows, and give back the one row that it selects, or the failure.
+ *
+ * A row index selects the row at that position. A row filter selects the one row that matches; no match
+ * selects nothing, and two or more matches are ambiguous.
+ */
+export function selectRow(rows, locator) {
+    if (locator.row !== undefined) {
+        const row = rows[locator.row];
+        if (row === undefined) {
+            return err({ reason: "locator-out-of-range", detail: `row ${locator.row} is outside the ${rows.length} rows` });
+        }
+        return ok(row);
+    }
+    if (locator.rowFilter !== undefined) {
+        const filter = locator.rowFilter;
+        const matches = rows.filter((row) => cellMatchesFilterValue(row[filter.column], filter.value));
+        const match = matches[0];
+        if (match === undefined) {
+            return err({ reason: "locator-out-of-range", detail: `no row where ${filter.column} equals ${String(filter.value)}` });
+        }
+        if (matches.length > 1) {
+            return err({ reason: "ambiguous-match", detail: `${matches.length} rows where ${filter.column} equals ${String(filter.value)}` });
+        }
+        return ok(match);
+    }
+    // The locator schema forbids a locator with neither selector. The resolver cannot depend on a
+    // prior parse, thus it treats a row that no selector addresses as out of range.
+    return err({ reason: "locator-out-of-range", detail: "the locator selects no row" });
+}
+/**
+ * Read the table that a table reference addresses out of rows that the caller read from the artifact:
+ * cut the rows on the row bound, refuse a column that no row holds, and project the requested columns.
+ */
+export function readArtifactTable(reference, allRows) {
+    // The bound ranks the rows as the artifact holds them, thus a bound over a column that the subset
+    // below leaves out still ranks them. An unknown bound column addresses nothing, exactly as an
+    // unknown subset column does.
+    const bound = reference.rowBound;
+    if (bound !== undefined && columnsHeldByNoRow(allRows, [bound.column]).length > 0) {
+        return fail(reference, "locator-out-of-range", `the row bound names column ${bound.column}, which the table at ${reference.path} does not hold`);
+    }
+    const rows = bound === undefined ? allRows : applyRowBound(allRows, bound);
+    // The page states the shown count against the count of the artifact. This read is the one place that
+    // holds both, thus a bounded table carries the pre-bound total out with its rows.
+    const total = bound === undefined ? {} : { total: allRows.length };
+    const columns = reference.columns;
+    if (columns === undefined) {
+        return ok({ type: "table", rows, ...total });
+    }
+    // A name that no row holds addresses nothing. Without this check a projection onto an invented column
+    // gives an empty cell for each row and still resolves, which is the fabrication that grounding exists
+    // to reject.
+    const absent = columnsHeldByNoRow(rows, columns);
+    if (absent.length > 0) {
+        return fail(reference, "locator-out-of-range", `the table at ${reference.path} holds no column ${absent.join(", ")}`);
+    }
+    // Project each row onto the requested columns. A table tolerates a ragged row, thus a column that a
+    // given row lacks is left out of that row and is not a failure.
+    const projectedRows = rows.map((row) => {
+        const projected = {};
+        for (const column of columns) {
+            const cell = row[column];
+            if (cell !== undefined) {
+                defineOwn(projected, column, cell);
+            }
+        }
+        return projected;
+    });
+    return ok({ type: "table", rows: projectedRows, columns, ...total });
+}
+/**
+ * Resolve a derivation: read each input with `resolveInput`, then run the arithmetic of the operation.
+ *
+ * The read of an input stays with the realization: the fixture resolver reads its snapshot, and the
+ * production resolver reads the pinned artifact on disk.
+ */
+export async function resolveDerivation(reference, snapshot, resolveInput) {
+    const numbers = [];
+    for (const input of reference.inputs) {
+        const inputResult = await resolveInput(input, snapshot);
+        if (inputResult.isErr()) {
+            // Keep the inner reason so a reviewer sees the real cause, for example a missing artifact under
+            // the derivation. The derivation itself did not fail on its own terms.
+            return fail(reference, inputResult.error.reason, inputResult.error.detail);
+        }
+        const resolved = inputResult.value;
+        const numeric = resolved.type === "scalar" ? asFiniteNumber(resolved.value) : undefined;
+        if (numeric === undefined) {
+            // The arithmetic needs a finite number. A cell that holds text does not address a usable
+            // scalar, thus the closest reason is that the coordinate is out of range.
+            return fail(reference, "locator-out-of-range", `input ${describeReference(input)} did not resolve to a finite number`);
+        }
+        numbers.push(numeric);
+    }
+    const a = numbers[0];
+    const b = numbers[1];
+    if (a === undefined || b === undefined) {
+        return fail(reference, "locator-out-of-range", `operation ${reference.op} needs two inputs, and the derivation holds ${numbers.length}`);
+    }
+    let result;
+    switch (reference.op) {
+        case "ratio":
+            result = a / b;
+            break;
+        case "delta":
+            result = a - b;
+            break;
+        case "pctChange":
+            // A fraction, not a percent. A change of one half gives 0.5, thus an author asserts 0.5 and a
+            // `unit` of `%` only tells a renderer how to show it.
+            result = (a - b) / b;
+            break;
+    }
+    if (!Number.isFinite(result)) {
+        return fail(reference, "locator-out-of-range", `operation ${reference.op} does not yield a finite value, because the divisor is zero`);
+    }
+    const valueFailure = checkValueAssertion(reference, reference.assert?.value, reference.assert?.tolerance, result);
+    return valueFailure !== undefined ? err(valueFailure) : ok({ type: "scalar", value: result });
+}
+/** Resolve a citation: confirm that the id is in the pinned evidence, and echo the key back. */
+export function resolveCitation(reference, snapshot) {
+    const key = `${reference.idKind}:${reference.id}`;
+    if (snapshot.citations === undefined || !snapshot.citations.includes(key)) {
+        return fail(reference, "artifact-missing", `the citation ${key} is not in the pinned evidence`);
+    }
+    const value = { type: "citation", id: key };
+    const citationFailure = checkCitationAssertion(reference, reference.assert?.value, key);
+    return citationFailure !== undefined ? err(citationFailure) : ok(value);
+}

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

@@ -34,6 +34,13 @@ export type ArtifactSnapshot = {
     fileType?: string | null;
     rows?: Array<Record<string, string | number | null | undefined>>;
 };
+/**
+ * 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.
+ */
+export declare function defineOwn(target: Record<string, string | number>, key: string, value: string | number): void;
 /**
  * Give back the present cells of a snapshot entry's rows, or an empty array for an entry with no rows.
  *

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

@@ -16,7 +16,7 @@ const CellSchema = z.union([z.string(), z.number()]).nullish();
  * 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) {
+export function defineOwn(target, key, value) {
     Object.defineProperty(target, key, { value, enumerable: true, writable: true, configurable: true });
 }
 /**

package/dist/report-render/chart.js

@@ -888,18 +888,10 @@ function deriveTransformedRows(rows, derived) {
  * parts of a category.
  */
 function deriveBar(block, rows, columns, mode) {
-    const xResult = requireColumn(block, rows, columns, "x");
-    if (xResult.isErr())
-        return err(xResult.error);
-    const yResult = requireColumn(block, rows, columns, "y");
-    if (yResult.isErr())
-        return err(yResult.error);
-    const x = xResult.value;
-    const y = yResult.value;
-    const ordered = orderQuickCategories(block.id, rows, x, block.orders.x);
-    if (ordered.isErr())
-        return err(ordered.error);
-    const categories = ordered.value;
+    const axes = axesOf(block, rows, columns);
+    if (axes.isErr())
+        return err(axes.error);
+    const { x, y, categories } = axes.value;
     const horizontal = block.orientation === "horizontal";
     let series;
     if (mode === "bar") {
@@ -1188,23 +1180,14 @@ function deriveHistogram(block, rows, columns) {
  * point inside the slot of its group.
  */
 function deriveBox(block, rows, columns) {
-    const xResult = requireColumn(block, rows, columns, "x");
-    if (xResult.isErr())
-        return err(xResult.error);
-    const yResult = requireColumn(block, rows, columns, "y");
-    if (yResult.isErr())
-        return err(yResult.error);
-    const x = xResult.value;
-    const y = yResult.value;
-    const ordered = orderQuickCategories(block.id, rows, x, block.orders.x);
-    if (ordered.isErr())
-        return err(ordered.error);
-    const categories = ordered.value;
-    const groupColumn = block.encoding.group;
-    const groups = groupColumn === undefined ? [{ name: undefined }] : firstAppearance(rows.map((row) => row[groupColumn])).map((name) => ({ name }));
-    const bound = slotFault(block.id, categories.length, groups.length);
-    if (bound !== undefined)
-        return err(bound);
+    const axes = axesOf(block, rows, columns);
+    if (axes.isErr())
+        return err(axes.error);
+    const { x, y, categories } = axes.value;
+    const slots = slotGroupsOf(block, rows, categories);
+    if (slots.isErr())
+        return err(slots.error);
+    const { groupColumn, groups } = slots.value;
     const focused = focusSet(block.id, block.focus, rows.length, groups.flatMap((group) => (group.name === undefined ? [] : [group.name])));
     if (focused.isErr())
         return err(focused.error);
@@ -1446,23 +1429,14 @@ function derivePie(block, rows, columns) {
  * violin draws its points on the hidden slot axis, each point inside the slot of its group.
  */
 function deriveViolin(block, rows, columns) {
-    const xResult = requireColumn(block, rows, columns, "x");
-    if (xResult.isErr())
-        return err(xResult.error);
-    const yResult = requireColumn(block, rows, columns, "y");
-    if (yResult.isErr())
-        return err(yResult.error);
-    const x = xResult.value;
-    const y = yResult.value;
-    const ordered = orderQuickCategories(block.id, rows, x, block.orders.x);
-    if (ordered.isErr())
-        return err(ordered.error);
-    const categories = ordered.value;
-    const groupColumn = block.encoding.group;
-    const groups = groupColumn === undefined ? [{ name: undefined }] : firstAppearance(rows.map((row) => row[groupColumn])).map((name) => ({ name }));
-    const bound = slotFault(block.id, categories.length, groups.length);
-    if (bound !== undefined)
-        return err(bound);
+    const axes = axesOf(block, rows, columns);
+    if (axes.isErr())
+        return err(axes.error);
+    const { x, y, categories } = axes.value;
+    const slots = slotGroupsOf(block, rows, categories);
+    if (slots.isErr())
+        return err(slots.error);
+    const { groupColumn, groups } = slots.value;
     const named = groups.flatMap((group) => (group.name === undefined ? [] : [group.name]));
     const focused = focusSet(block.id, block.focus, rows.length, named);
     if (focused.isErr())
@@ -1651,6 +1625,34 @@ function slotFault(blockId, categories, groups) {
         return undefined;
     return problem(blockId, `The chart holds ${categories} categories and ${groups} groups, thus ${slots} slots. A chart holds ${CHART_SLOT_LIMIT} slots at most, thus a table of fewer categories or fewer groups serves the reader.`);
 }
+/**
+ * The x and y columns and the category order that the category derivations share: each one demands both
+ * channels and reads its categories through the quick-path order.
+ */
+function axesOf(block, rows, columns) {
+    const xResult = requireColumn(block, rows, columns, "x");
+    if (xResult.isErr())
+        return err(xResult.error);
+    const yResult = requireColumn(block, rows, columns, "y");
+    if (yResult.isErr())
+        return err(yResult.error);
+    const ordered = orderQuickCategories(block.id, rows, xResult.value, block.orders.x);
+    if (ordered.isErr())
+        return err(ordered.error);
+    return ok({ x: xResult.value, y: yResult.value, categories: ordered.value });
+}
+/**
+ * The slot layout that the box and the violin share: a chart with no group channel holds one unnamed group,
+ * and a layout past the slot limit refuses before any series is built.
+ */
+function slotGroupsOf(block, rows, categories) {
+    const groupColumn = block.encoding.group;
+    const groups = groupColumn === undefined ? [{ name: undefined }] : firstAppearance(rows.map((row) => row[groupColumn])).map((name) => ({ name }));
+    const bound = slotFault(block.id, categories.length, groups.length);
+    if (bound !== undefined)
+        return err(bound);
+    return ok({ groupColumn, groups });
+}
 /** The radius of a radar. The legend and the indicator names sit outside it. */
 const RADAR_RADIUS = "62%";
 /** The tier of one row count. The two counts are constants of the design source. */

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

@@ -22,6 +22,40 @@ import { type ChannelOrder, type ChartEncoding, type ChartTransform } from "../.
 import { type ArtifactTableReference, type ColumnMeaning } from "../../contracts/report-reference.js";
 import type { Cell, ChartRow, EchartOption } from "../chart.js";
 import type { RenderProblem } from "../types.js";
+/** The size of one chart box and its text: the page, or one export. */
+export type ChartBox = {
+    readonly widthPx: number;
+    readonly heightPx: number;
+    readonly textPx: number;
+};
+/** The page box, and the export sizes that take a rule of their own: the two journal columns and the slide. */
+export declare const PAGE_BOX: ChartBox;
+export declare const EXPORT_SIZES: readonly [{
+    readonly theme: "inflexa-print";
+    readonly textPx: 9.33;
+    readonly widthPx: 336;
+    readonly heightPx: 253;
+    readonly widthMm: 89;
+    readonly heightMm: 67;
+    readonly pixelRatio: number;
+    readonly label: "89 mm";
+}, {
+    readonly theme: "inflexa-print";
+    readonly textPx: 9.33;
+    readonly widthPx: 692;
+    readonly heightPx: 348;
+    readonly widthMm: 183;
+    readonly heightMm: 92;
+    readonly pixelRatio: number;
+    readonly label: "183 mm";
+}, {
+    readonly theme: "inflexa-slide";
+    readonly textPx: 24;
+    readonly widthPx: 1920;
+    readonly heightPx: 1080;
+    readonly pixelRatio: 1;
+    readonly label: "16:9";
+}];
 /** The display labels that a bound table declares, keyed by the raw column name. */
 export type ColumnLabels = ArtifactTableReference["columnLabels"];
 /** The column meanings that a bound table declares, keyed by the raw column name. */

package/dist/report-render/figures/common.js

@@ -23,9 +23,12 @@ import { channelColumn, channelOrder, channelTransform } from "../../contracts/r
 import { declaredForColumn } from "../../contracts/report-reference.js";
 import { isUnknownArray } from "../../lib/unknown-array.js";
 import { parseUnknownRecord } from "../../lib/unknown-containers.js";
-import { CHART_BODY_MAX_PX, CHART_FONT_STACK, CHART_INK, CHART_PAGE_TEXT_PX, CHART_PALETTE, CHART_WIDE_PALETTE, DIVERGING_RAMP, GUIDE_LINE_COLOR, GUIDE_LINE_WIDTH_PX, MUTED_CHART_COLOR, SEQUENTIAL_RAMP, SIZE_CHANNEL_RANGE_PX, } from "../design.js";
+import { CHART_BODY_MAX_PX, CHART_BODY_PX, CHART_EXPORT_SIZES, CHART_FONT_STACK, CHART_INK, CHART_PAGE_TEXT_PX, CHART_PAGE_WIDTH_PX, CHART_PALETTE, CHART_WIDE_PALETTE, DIVERGING_RAMP, GUIDE_LINE_COLOR, GUIDE_LINE_WIDTH_PX, MUTED_CHART_COLOR, SEQUENTIAL_RAMP, SIZE_CHANNEL_RANGE_PX, } from "../design.js";
 import { formatNumberCell, selectNumberKind, typographicExponent } from "../number-format.js";
 import { STEM_RENDERER } from "../chart-renderers.js";
+/** The page box, and the export sizes that take a rule of their own: the two journal columns and the slide. */
+export const PAGE_BOX = { widthPx: CHART_PAGE_WIDTH_PX, heightPx: CHART_BODY_PX, textPx: CHART_PAGE_TEXT_PX };
+export const EXPORT_SIZES = [CHART_EXPORT_SIZES.single, CHART_EXPORT_SIZES.double, CHART_EXPORT_SIZES.slide];
 // ── The cells ───────────────────────────────────────────────────────────────
 /** A typed `invalid-chart-input` problem that names the block and the cause. */
 export function chartProblem(blockId, detail) {

package/dist/report-render/figures/equal-units.js

@@ -22,8 +22,8 @@
  * largest container, thus no other container meets it.
  */
 import { TOOLBOX_BAND_PX } from "../chart-toolbox.js";
-import { CHART_EXPORT_SIZES, CHART_PAGE_TEXT_PX, FACET_COLUMNS } from "../design.js";
-import { legendLineCount, legendLinePx } from "./common.js";
+import { CHART_PAGE_TEXT_PX, FACET_COLUMNS } from "../design.js";
+import { EXPORT_SIZES, legendLineCount, legendLinePx } from "./common.js";
 /** The smallest square side, in pixels. A container smaller than its rule still draws this square. */
 const SQUARE_MIN_PX = 120;
 /** The largest square side, in pixels. The slide export is the largest container. */
@@ -83,8 +83,6 @@ export function squareLayout(fields) {
         media,
     };
 }
-/** The export sizes that take a rule of their own: the two journal columns and the slide. */
-const EXPORT_SIZES = [CHART_EXPORT_SIZES.single, CHART_EXPORT_SIZES.double, CHART_EXPORT_SIZES.slide];
 /** The scale of the margins of a page square: one up to the page square, and larger with a larger square. */
 function marginScale(side) {
     return Math.min(MARGIN_SCALE_MAX, Math.max(1, side / MARGIN_SCALE_FROM_PX));

package/dist/report-render/figures/sankey.js

@@ -25,7 +25,7 @@
 import { err, ok } from "neverthrow";
 import { declaredForColumn } from "../../contracts/report-reference.js";
 import { CHART_BODY_PX, CHART_EXPORT_SIZES, CHART_INK, CHART_PAGE_TEXT_PX, CHART_PAGE_WIDTH_PX, MUTED_CHART_COLOR } from "../design.js";
-import { AREA_LEGEND_ICON, categoricalPalette, chartProblem, demandedColumn, firstAppearance, legendLineCount, legendLinePx, plainColumn, toNumber, } from "./common.js";
+import { AREA_LEGEND_ICON, categoricalPalette, chartProblem, demandedColumn, EXPORT_SIZES, firstAppearance, legendLineCount, legendLinePx, PAGE_BOX, plainColumn, toNumber, } from "./common.js";
 import { largest } from "./dense.js";
 /** The opacity of a flow. A flow reads as the path of its source, and a label reads over it. */
 export const SANKEY_LINK_OPACITY = 0.35;
@@ -182,8 +182,6 @@ function readFlows(rows, source, target, value, group) {
     }
     return ok(flows);
 }
-const PAGE_BOX = { widthPx: CHART_PAGE_WIDTH_PX, heightPx: CHART_BODY_PX, textPx: CHART_PAGE_TEXT_PX };
-const EXPORT_SIZES = [CHART_EXPORT_SIZES.single, CHART_EXPORT_SIZES.double, CHART_EXPORT_SIZES.slide];
 /**
  * The text and the node size of one box: the label text size, the room of a label between two stages, the node
  * width, and the node gap. A figure of one stage gives its label the half of the width.

package/dist/report-render/figures/upset.js

@@ -25,8 +25,8 @@
  * each export size states the dot size and the turn of the count text there.
  */
 import { err, ok } from "neverthrow";
-import { CHART_BODY_PX, CHART_EXPORT_SIZES, CHART_INK, CHART_PAGE_TEXT_PX, CHART_PAGE_WIDTH_PX } from "../design.js";
-import { axisNameFields, chartProblem, demandedColumn, valueAxis } from "./common.js";
+import { CHART_EXPORT_SIZES, CHART_INK } from "../design.js";
+import { axisNameFields, chartProblem, demandedColumn, EXPORT_SIZES, PAGE_BOX, valueAxis } from "./common.js";
 /**
  * The most sets that one figure draws. Each set takes one row of the matrix, and the rows of twelve sets hold
  * one line of the column-export text each.
@@ -125,9 +125,6 @@ function compareMembers(a, b) {
     }
     return a.length - b.length;
 }
-/** The page box and the box of each export size. */
-const PAGE_BOX = { widthPx: CHART_PAGE_WIDTH_PX, heightPx: CHART_BODY_PX, textPx: CHART_PAGE_TEXT_PX };
-const EXPORT_SIZES = [CHART_EXPORT_SIZES.single, CHART_EXPORT_SIZES.double, CHART_EXPORT_SIZES.slide];
 /**
  * The places of the grids for some sets, and set names of some length.
  *