@inflexa-ai/harness 0.19.1 → 0.20.0

package/dist/agents/report-session-agent.d.ts

@@ -30,6 +30,7 @@ import type { ThreadStore } from "../memory/thread-store.js";
 import type { ReferenceResolver } from "../report-model/reference-resolver.js";
 import type { ReportVersionStore } from "../state/report-versions.js";
 import type { ReportSessionStateGateway } from "../tools/report-authoring/authoring-tools.js";
+import { type ResolvePageAsset } from "../tools/report-session/index.js";
 /** Canonical agent id -- distinct from the id of the old templating agent. */
 export declare const REPORT_SESSION_AGENT_ID: "report-session";
 /**
@@ -65,6 +66,12 @@ export interface ReportSessionAgentDeps {
         analysisId: string;
         auth: AuthContext;
     }) => ReferenceResolver;
+    /**
+     * Page-asset lookup -- the preview tool maps the module specifier of a manifest
+     * entry onto a file on disk. Omitted falls back to the module resolution of the
+     * installation of the harness.
+     */
+    readonly resolvePageAsset?: ResolvePageAsset;
     /** Operational logging seam; omitted falls back to no-op. */
     readonly logger?: Logger;
 }

package/dist/agents/report-session-agent.js

@@ -33,7 +33,7 @@ export const REPORT_SESSION_AGENT_ID = "report-session";
 const REPORT_SESSION_MAX_ITERATIONS = 50;
 /** Build the report `AgentDefinition` with every tool bound to its deps. */
 export function createReportSessionAgent(deps) {
-    const { model, pool, embedding, workspaceFs, gateway, resolveWorkspaceRoot, store, threads, chrome, makeResolver, logger } = deps;
+    const { model, pool, embedding, workspaceFs, gateway, resolveWorkspaceRoot, store, threads, chrome, makeResolver, resolvePageAsset, logger } = deps;
     const authoring = createReportAuthoringTools(gateway);
     const tools = [
         // The read surface toward the analysis. It roams the tree read-only.
@@ -59,6 +59,7 @@ export function createReportSessionAgent(deps) {
             gateway,
             resolveWorkspaceRoot,
             ...(makeResolver ? { makeResolver } : {}),
+            ...(resolvePageAsset ? { resolvePageAsset } : {}),
             ...(logger ? { logger } : {}),
         }),
         // The eyes tool. It opens the rendered page in headless Chrome.

package/dist/auth/local-run-authorizer.d.ts

@@ -2,8 +2,9 @@
  * LocalRunAuthorizer — the OSS realization of the `RunAuthorizer` seam.
  *
  * Issues a durable `RunSession` straight from the async-edge input: no remote
- * authorization, no credential read. It owns nothing revocable, so `revoke` is
- * a no-op. The opaque caller `auth` is forwarded untouched — local code never
+ * authorization, no credential read. It owns nothing revocable (it mints no
+ * jti), so `revoke` and `revokeByJti` are no-ops. The opaque caller `auth` is
+ * forwarded untouched — local code never
  * inspects it (no `getAuth`).
  */
 import type { RunAuthorizer } from "../execution/run-authorizer.js";

package/dist/auth/local-run-authorizer.js

@@ -2,8 +2,9 @@
  * LocalRunAuthorizer — the OSS realization of the `RunAuthorizer` seam.
  *
  * Issues a durable `RunSession` straight from the async-edge input: no remote
- * authorization, no credential read. It owns nothing revocable, so `revoke` is
- * a no-op. The opaque caller `auth` is forwarded untouched — local code never
+ * authorization, no credential read. It owns nothing revocable (it mints no
+ * jti), so `revoke` and `revokeByJti` are no-ops. The opaque caller `auth` is
+ * forwarded untouched — local code never
  * inspects it (no `getAuth`).
  */
 export function createLocalRunAuthorizer() {
@@ -19,5 +20,6 @@ export function createLocalRunAuthorizer() {
             return { runSession, ownsMandate: false }; // oss-core-managed-ok
         },
         async revoke() { },
+        async revokeByJti() { },
     };
 }

package/dist/execution/run-authorizer.d.ts

@@ -15,6 +15,16 @@
  * realization injected at the composition root.
  */
 import type { AuthContext, Provenance, RunFrame, RunSession, Scope } from "../auth/types.js";
+/**
+ * Locates a run credential when no `RunAuthorization` exists: the persisted
+ * jti from `cortex_runs` plus the revoking caller's opaque `auth` — the sole
+ * carrier of credential/org behind a session, downcast only by managed
+ * realizations.
+ */
+export interface RevokeByJtiRef {
+    readonly jti: string;
+    readonly auth: AuthContext;
+}
 /** What an async edge knows when it authorizes a run: the opaque caller auth,
  * the scope + provenance to stamp on the run, and the run frame to mint for. */
 export interface AuthorizeRunInput {
@@ -40,4 +50,12 @@ export interface RunAuthorization {
 export interface RunAuthorizer {
     authorize(input: AuthorizeRunInput): Promise<RunAuthorization>;
     revoke(authorization: RunAuthorization, reason: string): Promise<void>;
+    /**
+     * Out-of-band revocation for paths holding no `RunAuthorization`. Normal
+     * terminal paths use `revoke(authorization, reason)` under the run
+     * credential; `revokeByJti` covers external cancellation, where the run
+     * credential's JWT was never persisted and only its jti survives on
+     * `cortex_runs`. Local/OSS authorizers no-op — they mint no jti.
+     */
+    revokeByJti(ref: RevokeByJtiRef, reason: string): Promise<void>;
 }

package/dist/execution/run-canceler.d.ts

@@ -0,0 +1,67 @@
+/**
+ * RunCanceler — the encapsulated external-cancel path for an `executeAnalysis` run.
+ *
+ * A cancelled DBOS workflow can never execute another step, so the body's own
+ * terminal block (`collectAndComplete`) is unreachable on external cancel and
+ * nothing converges: the run row stays `running` (blocking same-plan relaunch
+ * through `queryActiveRun`'s active-status dedup), pending step rows never
+ * sweep, the running charge never closes, and the run mandate is never
+ * revoked. This module is the host-side counterpart: cancel the engine's
+ * parent + children, then converge each ledger the workflow would have.
+ *
+ * The engine capability stays internal — the production default is the
+ * purger's `DBOSClient`-backed child-cascading cancel, which needs no launched
+ * engine (see `dbos-workflow-purger.ts` for why the static `DBOS` facade is
+ * the wrong tool here). `cancelWorkflows` is an optional test seam over it.
+ *
+ * No stream writes: `DBOS.writeStream` is body-only, so hosts synthesize the
+ * terminal frame read-side.
+ */
+import type { Pool } from "pg";
+import type { AgentSession } from "../auth/types.js";
+import type { RunCharge } from "../billing/run-charge.js";
+import type { Logger } from "../lib/logger.js";
+import type { RunStatus } from "../state/schema.js";
+import type { RunAuthorizer } from "./run-authorizer.js";
+export declare class UnknownRunError extends Error {
+    readonly runId: string;
+    constructor(runId: string);
+}
+export interface CancelRunResult {
+    readonly runId: string;
+    /** The DBOS parent workflow id — equal to `runId` by the launch contract
+     * (`execute_analysis` launches with `workflowId: runId`). */
+    readonly workflowId: string;
+    readonly outcome: "canceled" | "already_terminal";
+    /**
+     * The run row's status after the cancel. `canceled` when this cancel won
+     * the row; the run's own terminal status when it completed concurrently
+     * (the conditional write refuses to clobber it).
+     */
+    readonly finalStatus: RunStatus;
+    /** What actually converged. `mandate` is vacuously true for a row with no
+     * persisted jti — nothing to revoke, so hosts alert on any false flag. */
+    readonly converged: {
+        readonly steps: boolean;
+        readonly charge: boolean;
+        readonly mandate: boolean;
+    };
+}
+export interface RunCancelerDeps {
+    readonly pool: Pool;
+    readonly runCharge: RunCharge;
+    readonly runAuthorizer: RunAuthorizer;
+    readonly logger?: Logger;
+    /** Test seam over the engine cancel. Production default: the workflow
+     * purger's `DBOSClient`-backed cancel, child-cascading and launch-free. */
+    readonly cancelWorkflows?: (workflowIds: readonly string[]) => Promise<void>;
+}
+export interface RunCanceler {
+    /**
+     * Cancel the run's workflows and converge its ledgers. Rejects when the
+     * engine cancel itself fails (retry-safe: nothing converged) or the run is
+     * unknown; convergence-phase failures resolve with their flag false.
+     */
+    cancel(runId: string, session: AgentSession): Promise<CancelRunResult>;
+}
+export declare function createRunCanceler(deps: RunCancelerDeps): RunCanceler;

package/dist/execution/run-canceler.js

@@ -0,0 +1,130 @@
+/**
+ * RunCanceler — the encapsulated external-cancel path for an `executeAnalysis` run.
+ *
+ * A cancelled DBOS workflow can never execute another step, so the body's own
+ * terminal block (`collectAndComplete`) is unreachable on external cancel and
+ * nothing converges: the run row stays `running` (blocking same-plan relaunch
+ * through `queryActiveRun`'s active-status dedup), pending step rows never
+ * sweep, the running charge never closes, and the run mandate is never
+ * revoked. This module is the host-side counterpart: cancel the engine's
+ * parent + children, then converge each ledger the workflow would have.
+ *
+ * The engine capability stays internal — the production default is the
+ * purger's `DBOSClient`-backed child-cascading cancel, which needs no launched
+ * engine (see `dbos-workflow-purger.ts` for why the static `DBOS` facade is
+ * the wrong tool here). `cancelWorkflows` is an optional test seam over it.
+ *
+ * No stream writes: `DBOS.writeStream` is body-only, so hosts synthesize the
+ * terminal frame read-side.
+ */
+import { createNoopLogger } from "../lib/console-logger.js";
+import { unwrapOrThrow } from "../lib/result.js";
+import { markRunCanceledIfActive, queryRun } from "../state/runs.js";
+import { queryStepsByRun, sweepPendingStepExecutions } from "../state/step-executions.js";
+import { createDbosWorkflowPurger } from "./dbos-workflow-purger.js";
+/** The reason stamped on the run row and the revoke — the same literal
+ * `collectAndComplete` records for a cancel it observes from inside. */
+const EXTERNAL_CANCEL_REASON = "external_cancel";
+export class UnknownRunError extends Error {
+    runId;
+    constructor(runId) {
+        super(`no run exists for id ${runId}`);
+        this.runId = runId;
+        this.name = "UnknownRunError";
+    }
+}
+const TERMINAL = new Set(["completed", "partial", "failed", "canceled"]);
+export function createRunCanceler(deps) {
+    const { pool, runCharge, runAuthorizer } = deps;
+    const logger = (deps.logger ?? createNoopLogger()).named("run-canceler");
+    // Lazy so a canceler built for a host that never cancels constructs no client;
+    // one purger per factory (its client registers pool handlers — see its comment).
+    let engineCancel = deps.cancelWorkflows;
+    const cancelWorkflows = async (workflowIds) => {
+        engineCancel ??= (() => {
+            const purger = createDbosWorkflowPurger({ pool, logger });
+            return async (ids) => {
+                unwrapOrThrow(await purger.cancel([...ids]));
+            };
+        })();
+        await engineCancel(workflowIds);
+    };
+    /** Persisted child workflow ids of steps not yet completed. */
+    const incompleteChildIds = async (runId) => unwrapOrThrow(await queryStepsByRun(pool, runId)).flatMap((step) => step.childWorkflowId !== null && step.completedAt === null ? [step.childWorkflowId] : []);
+    return {
+        async cancel(runId, session) {
+            const row = unwrapOrThrow(await queryRun(pool, runId));
+            if (row === null)
+                throw new UnknownRunError(runId);
+            const workflowId = runId;
+            if (TERMINAL.has(row.status)) {
+                return {
+                    runId,
+                    workflowId,
+                    outcome: "already_terminal",
+                    finalStatus: row.status,
+                    converged: { steps: false, charge: false, mandate: false },
+                };
+            }
+            // The child-cascading cancel walks the engine's own parent ledger, which
+            // has a row the moment a child starts — that covers a child whose
+            // mark-running step has not yet committed its child_workflow_id. The
+            // persisted ids and the post-cancel re-query are belt-and-braces over
+            // both ledgers' lag.
+            const knownChildren = await incompleteChildIds(runId);
+            await cancelWorkflows([workflowId, ...knownChildren]);
+            try {
+                const late = (await incompleteChildIds(runId)).filter((id) => !knownChildren.includes(id));
+                if (late.length > 0)
+                    await cancelWorkflows(late);
+            }
+            catch (err) {
+                logger.error("late-child cancel sweep failed", { runId, ...logger.errorFields(err) });
+            }
+            // Convergence — each phase isolated so one failure skips nothing after it.
+            let transitioned = false;
+            try {
+                transitioned = unwrapOrThrow(await markRunCanceledIfActive(pool, runId, EXTERNAL_CANCEL_REASON));
+            }
+            catch (err) {
+                logger.error("markRunCanceledIfActive failed", { runId, ...logger.errorFields(err) });
+            }
+            let steps = false;
+            try {
+                unwrapOrThrow(await sweepPendingStepExecutions(pool, runId));
+                steps = true;
+            }
+            catch (err) {
+                logger.error("pending-step sweep failed", { runId, ...logger.errorFields(err) });
+            }
+            // Best-effort: the billing authority self-heals (defensive open + stale
+            // reaper), so a failed close loses attribution only.
+            let charge = false;
+            try {
+                await runCharge.close({ analysisId: row.analysisId, runId, reason: "canceled", session });
+                charge = true;
+            }
+            catch (err) {
+                logger.error("running-charge close failed", { runId, ...logger.errorFields(err) });
+            }
+            let mandate = row.mandateJti === null;
+            if (row.mandateJti !== null) {
+                try {
+                    await runAuthorizer.revokeByJti({ jti: row.mandateJti, auth: session.auth }, EXTERNAL_CANCEL_REASON);
+                    mandate = true;
+                }
+                catch (err) {
+                    logger.error("mandate revoke failed", { runId, jti: row.mandateJti, ...logger.errorFields(err) });
+                }
+            }
+            // No transition means the run reached a terminal state on its own (or the
+            // write failed) — report the row as it stands rather than claiming `canceled`.
+            let finalStatus = "canceled";
+            if (!transitioned) {
+                const reread = unwrapOrThrow(await queryRun(pool, runId));
+                finalStatus = reread?.status ?? "canceled";
+            }
+            return { runId, workflowId, outcome: "canceled", finalStatus, converged: { steps, charge, mandate } };
+        },
+    };
+}

package/dist/index.d.ts

@@ -7,13 +7,14 @@
 export { assembleCoreRuntime } from "./runtime/assemble.js";
 export type { CoreRuntime, CoreRuntimeDeps, CoreWorkflowDeps, RegisteredWorkflows, ConversationAssemblyDeps, SandboxStepCallable, MakeReportReferenceResolver, ReportResolverScope, } from "./runtime/assemble.js";
 export type { ReferenceResolver, ReportSnapshot, ResolvedValue } from "./report-model/reference-resolver.js";
+export type { ResolvePageAsset } from "./tools/report-session/index.js";
 export type { ThreadAgentResolver, UnregisteredThreadType } from "./runtime/assemble.js";
 export { bootHarness } from "./runtime/boot.js";
 export type { BootHarnessDeps, BootedHarness } from "./runtime/boot.js";
 export { createConversationAgent } from "./agents/conversation-agent.js";
 export type { ConversationAgentDeps } from "./agents/conversation-agent.js";
 export { createLocalRunAuthorizer } from "./auth/local-run-authorizer.js";
-export type { RunAuthorizer, AuthorizeRunInput, RunAuthorization } from "./execution/run-authorizer.js";
+export type { RunAuthorizer, AuthorizeRunInput, RunAuthorization, RevokeByJtiRef } from "./execution/run-authorizer.js";
 export { createNoopBillingResolver } from "./billing/noop-resolver.js";
 export type { ResolveBilling, ResolvableSession, BillingMap, BillingHeaders, BillingFetchResult } from "./billing/resolver.js";
 export { createNoopRunCharge } from "./billing/noop-run-charge.js";
@@ -31,6 +32,8 @@ export type { RunLauncher, LaunchOptions } from "./execution/run-launcher.js";
 export { createDbosWorkflowPurger } from "./execution/dbos-workflow-purger.js";
 export type { DbosWorkflowPurgerDeps } from "./execution/dbos-workflow-purger.js";
 export type { WorkflowPurger } from "./execution/workflow-purger.js";
+export { createRunCanceler, UnknownRunError } from "./execution/run-canceler.js";
+export type { RunCanceler, RunCancelerDeps, CancelRunResult } from "./execution/run-canceler.js";
 export { defineTool, isToolError } from "./tools/define-tool.js";
 export type { Tool, ToolDefinition, ToolContext, ToolError } from "./tools/define-tool.js";
 export { normalizeDetail, DETAIL_MAX_LENGTH } from "./loop/tool-detail.js";
@@ -137,7 +140,7 @@ export type { ValidatePlanOptions } from "./schemas/validate-plan.js";
 export type { ValidationResult } from "./schemas/validate-plan.js";
 export { upsertPlan, loadPlan } from "./state/plans.js";
 export type { UpsertPlanInput } from "./state/plans.js";
-export { insertRun, reserveRunById, queryActiveRun, queryActiveRunsByAnalysis, updateRunStatus, queryRun, queryRunsByAnalysis, RunDedupCollisionError, RunIdentityCollisionError, } from "./state/runs.js";
+export { insertRun, reserveRunById, queryActiveRun, queryActiveRunsByAnalysis, updateRunStatus, markRunCanceledIfActive, queryRun, queryRunsByAnalysis, RunDedupCollisionError, RunIdentityCollisionError, } from "./state/runs.js";
 export type { InsertRunInput, RunReservation } from "./state/runs.js";
 export { queryStepsByRun } from "./state/step-executions.js";
 export type { CortexRunRow, StepExecutionRow, RunStatus } from "./state/schema.js";

package/dist/index.js

@@ -31,6 +31,11 @@ export { createDbosRunLauncher } from "./execution/dbos-run-launcher.js";
 // Seam: workflow-ledger reclamation — cancels and deletes an analysis's rows in
 // the durability engine's own ledger, so no caller names an engine type.
 export { createDbosWorkflowPurger } from "./execution/dbos-workflow-purger.js";
+// Run cancellation — the encapsulated external-cancel path: engine cancel
+// (parent + children) plus convergence of the run row, pending step rows,
+// running charge, and run mandate. Hosts call this from their cancel route
+// instead of hand-rolling `DBOS.cancelWorkflow` + partial cleanup.
+export { createRunCanceler, UnknownRunError } from "./execution/run-canceler.js";
 // Tool primitive.
 export { defineTool, isToolError } from "./tools/define-tool.js";
 // Tool-call-detail authoring aids for an embedder that contributes a host tool.
@@ -224,7 +229,7 @@ export { validatePlan } from "./schemas/validate-plan.js";
 // caller-derived id and inserts-if-absent (the deterministic-id intake path);
 // the run-state calls mirror the chat trigger's reserve → dedup → status flow.
 export { upsertPlan, loadPlan } from "./state/plans.js";
-export { insertRun, reserveRunById, queryActiveRun, queryActiveRunsByAnalysis, updateRunStatus, queryRun, queryRunsByAnalysis, RunDedupCollisionError, RunIdentityCollisionError, } from "./state/runs.js";
+export { insertRun, reserveRunById, queryActiveRun, queryActiveRunsByAnalysis, updateRunStatus, markRunCanceledIfActive, queryRun, queryRunsByAnalysis, RunDedupCollisionError, RunIdentityCollisionError, } from "./state/runs.js";
 export { queryStepsByRun } from "./state/step-executions.js";
 // Host-neutral reference-data catalog and shared installation receipts. Each
 // artifact names the third-party upstream it is fetched from; embedders own all

package/dist/literature/sources/pubmed.js

@@ -11,7 +11,8 @@ const IdConvResponseSchema = z.object({
 });
 export function ncbiUrl(apiKey, base, params) {
     const url = new URL(base);
-    if (apiKey !== undefined)
+    // The URL must not include an empty key. NCBI rejects `api_key=` with HTTP 400.
+    if (apiKey)
         url.searchParams.set("api_key", apiKey);
     for (const [key, value] of Object.entries(params))
         if (value !== undefined)

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

@@ -0,0 +1,42 @@
+/**
+ * The asset manifest of the page.
+ *
+ * The page loads its chart runtime and its fonts from the sibling `assets/` directory. Thus each entry
+ * names the staged file and the module specifier of its source. The caller resolves each specifier against
+ * its own installation, and it copies the bytes beside the page.
+ *
+ * The module holds data alone. The renderer reads no file, thus the page stays a pure function of its
+ * inputs.
+ */
+/** The directory of the staged assets, relative to the page. */
+export declare const ASSETS_DIR = "assets";
+/**
+ * One staged asset. `file` is the basename under the assets directory, and `specifier` is the module
+ * specifier of the source file inside the installed package.
+ */
+export interface 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 chart runtime. The page-side bootstrap reads the `echarts` global that this file declares. */
+export declare const ECHARTS_ASSET: PageAsset;
+/** The sans font. The file is the latin subset of the variable font, thus one file carries each weight. */
+export declare const SANS_FONT_ASSET: PageAsset;
+/**
+ * The mono font at weight 400, for the body of a data cell.
+ *
+ * Fontsource publishes no variable IBM Plex Mono, thus each weight is a separate file and a separate entry.
+ * The identity uses four weights: 400 for a data cell, 500 for a tag, 600 for a table header and a badge,
+ * and 700 for a metric value.
+ */
+export declare const MONO_FONT_400_ASSET: PageAsset;
+/** The mono font at weight 500, for a tag and a stat-card label. */
+export declare const MONO_FONT_500_ASSET: PageAsset;
+/** The mono font at weight 600, for a table header, a section label, and the panel badge. */
+export declare const MONO_FONT_600_ASSET: PageAsset;
+/** The mono font at weight 700, for a metric value. */
+export declare const MONO_FONT_700_ASSET: PageAsset;
+/** Each asset that the caller stages beside the page. */
+export declare const PAGE_ASSETS: readonly PageAsset[];

package/dist/report-render/assets.js

@@ -0,0 +1,61 @@
+/**
+ * The asset manifest of the page.
+ *
+ * The page loads its chart runtime and its fonts from the sibling `assets/` directory. Thus each entry
+ * names the staged file and the module specifier of its source. The caller resolves each specifier against
+ * its own installation, and it copies the bytes beside the page.
+ *
+ * The module holds data alone. The renderer reads no file, thus the page stays a pure function of its
+ * inputs.
+ */
+/** The directory of the staged assets, relative to the page. */
+export const ASSETS_DIR = "assets";
+/** The relative source of a staged asset. The page directory is self-contained, thus the source is `assets/<file>`. */
+export function assetSource(asset) {
+    return `${ASSETS_DIR}/${asset.file}`;
+}
+/** The chart runtime. The page-side bootstrap reads the `echarts` global that this file declares. */
+export const ECHARTS_ASSET = {
+    file: "echarts.min.js",
+    specifier: "echarts/dist/echarts.min.js",
+};
+/** The sans font. The file is the latin subset of the variable font, thus one file carries each weight. */
+export const SANS_FONT_ASSET = {
+    file: "space-grotesk-latin-wght-normal.woff2",
+    specifier: "@fontsource-variable/space-grotesk/files/space-grotesk-latin-wght-normal.woff2",
+};
+/**
+ * The mono font at weight 400, for the body of a data cell.
+ *
+ * Fontsource publishes no variable IBM Plex Mono, thus each weight is a separate file and a separate entry.
+ * The identity uses four weights: 400 for a data cell, 500 for a tag, 600 for a table header and a badge,
+ * and 700 for a metric value.
+ */
+export const MONO_FONT_400_ASSET = {
+    file: "ibm-plex-mono-latin-400-normal.woff2",
+    specifier: "@fontsource/ibm-plex-mono/files/ibm-plex-mono-latin-400-normal.woff2",
+};
+/** The mono font at weight 500, for a tag and a stat-card label. */
+export const MONO_FONT_500_ASSET = {
+    file: "ibm-plex-mono-latin-500-normal.woff2",
+    specifier: "@fontsource/ibm-plex-mono/files/ibm-plex-mono-latin-500-normal.woff2",
+};
+/** The mono font at weight 600, for a table header, a section label, and the panel badge. */
+export const MONO_FONT_600_ASSET = {
+    file: "ibm-plex-mono-latin-600-normal.woff2",
+    specifier: "@fontsource/ibm-plex-mono/files/ibm-plex-mono-latin-600-normal.woff2",
+};
+/** The mono font at weight 700, for a metric value. */
+export const MONO_FONT_700_ASSET = {
+    file: "ibm-plex-mono-latin-700-normal.woff2",
+    specifier: "@fontsource/ibm-plex-mono/files/ibm-plex-mono-latin-700-normal.woff2",
+};
+/** Each asset that the caller stages beside the page. */
+export const PAGE_ASSETS = [
+    ECHARTS_ASSET,
+    SANS_FONT_ASSET,
+    MONO_FONT_400_ASSET,
+    MONO_FONT_500_ASSET,
+    MONO_FONT_600_ASSET,
+    MONO_FONT_700_ASSET,
+];

package/dist/report-render/chart.js

@@ -20,6 +20,23 @@ import { normalizeEchartSpec } from "../tools/display/normalize-echart-spec.js";
  * scale maps the low value to `#440154` and the high value to `#fde725`.
  */
 const VIRIDIS = ["#440154", "#482777", "#3e4989", "#31688e", "#26828e", "#1f9e89", "#35b779", "#6ece58", "#b5de2b", "#fde725"];
+/**
+ * The distance in pixels between the x axis line and its name.
+ *
+ * The name sits under the middle of the axis, thus the gap must clear the axis labels below the line. The
+ * value is a fixed constant, thus the derivation stays deterministic.
+ */
+const X_AXIS_NAME_GAP = 34;
+/**
+ * The name fields of an x axis.
+ *
+ * `normalizeEchartSpec` holds the grid to a right margin of 5 percent. The ECharts default `nameLocation`
+ * of `"end"` puts the name at the right end of the axis, thus the name runs past that margin and the panel
+ * clips it. A centered name sits under the middle of the axis, and no margin can cut it.
+ */
+function xAxisName(column) {
+    return { name: column, nameLocation: "middle", nameGap: X_AXIS_NAME_GAP };
+}
 /**
  * Derive the ECharts option for a chart block, then pass it through `normalizeEchartSpec`.
  *
@@ -68,7 +85,7 @@ function deriveBar(block, rows, columns) {
         data: groupRows.map((row) => [row[x], row[y]]),
     }));
     return ok({
-        xAxis: { type: "category", data: categories, name: x },
+        xAxis: { type: "category", data: categories, ...xAxisName(x) },
         yAxis: { type: "value", name: y },
         series,
     });
@@ -90,8 +107,8 @@ function deriveLine(block, rows, columns) {
         data: sortByX(groupRows.map((row) => [row[x], row[y]])),
     }));
     return ok({
-        xAxis: inferAxis(rows, x),
-        yAxis: inferAxis(rows, y),
+        xAxis: inferAxis(rows, x, "x"),
+        yAxis: inferAxis(rows, y, "y"),
         series,
     });
 }
@@ -113,8 +130,8 @@ function deriveScatter(block, rows, columns) {
         data: groupRows.map((row) => [row[x], row[y]]),
     }));
     return ok({
-        xAxis: inferAxis(rows, x),
-        yAxis: inferAxis(rows, y),
+        xAxis: inferAxis(rows, x, "x"),
+        yAxis: inferAxis(rows, y, "y"),
         series,
     });
 }
@@ -199,7 +216,7 @@ function deriveBox(block, rows, columns) {
         }
     }
     return ok({
-        xAxis: { type: "category", data: categories, name: x },
+        xAxis: { type: "category", data: categories, ...xAxisName(x) },
         yAxis: { type: "value", name: y },
         series,
     });
@@ -242,7 +259,7 @@ function deriveHeatmap(block, rows, columns) {
     const min = finite.length > 0 ? Math.min(...finite) : 0;
     const max = finite.length > 0 ? Math.max(...finite) : 1;
     return ok({
-        xAxis: { type: "category", data: xCategories.map(String), name: x, splitArea: { show: true } },
+        xAxis: { type: "category", data: xCategories.map(String), ...xAxisName(x), splitArea: { show: true } },
         yAxis: { type: "category", data: yCategories.map(String), name: y, splitArea: { show: true } },
         visualMap: {
             type: "continuous",
@@ -355,12 +372,16 @@ function numericColumn(rows, column) {
 /**
  * The axis for a line or a scatter column. A column with any non-numeric string cell is a category axis
  * with its distinct values as strings. Any other column is a value axis with `scale: true`.
+ *
+ * The `axis` argument names the channel that the column feeds. An x column takes the centered name, and a
+ * y column keeps the default name placement.
  */
-function inferAxis(rows, column) {
+function inferAxis(rows, column, axis) {
+    const nameFields = axis === "x" ? xAxisName(column) : { name: column };
     if (rows.some((row) => isNonNumericString(row[column]))) {
-        return { type: "category", data: firstAppearance(rows.map((row) => row[column])).map(String), name: column };
+        return { type: "category", data: firstAppearance(rows.map((row) => row[column])).map(String), ...nameFields };
     }
-    return { type: "value", scale: true, name: column };
+    return { type: "value", scale: true, ...nameFields };
 }
 /**
  * Build one series per group, in first-appearance order of the group values. A chart with no group