@marinoscar/kvox-eval 0.0.0-bootstrap → 0.1.0-next.0

package/dist/kg/prediction-schema.d.ts

@@ -0,0 +1,245 @@
+import { z } from 'zod';
+/**
+ * One citation of a predicted row: a segment (`segmentId`) or the note, and the quote.
+ *
+ * @stability experimental
+ */
+export declare const predictedEvidenceSchema: z.ZodObject<{
+    source: z.ZodEnum<{
+        note: "note";
+        segment: "segment";
+    }>;
+    segmentId: z.ZodNullable<z.ZodString>;
+    quote: z.ZodString;
+}, z.core.$strip>;
+/**
+ * A parsed {@link predictedEvidenceSchema}.
+ *
+ * @stability experimental
+ */
+export type PredictedEvidence = z.infer<typeof predictedEvidenceSchema>;
+/**
+ * What resolution decided for a predicted entity: linked (to `entityId`, with its score
+ * and whether the pre-check accepted it), new, or uncertain.
+ *
+ * @stability experimental
+ */
+export declare const predictedResolutionSchema: z.ZodObject<{
+    outcome: z.ZodEnum<{
+        linked: "linked";
+        new: "new";
+        uncertain: "uncertain";
+    }>;
+    entityId: z.ZodNullable<z.ZodString>;
+    score: z.ZodNullable<z.ZodNumber>;
+    prechecked: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * A predicted entity: its `ref` (what relations and items point at), type, label,
+ * aliases, resolution and evidence.
+ *
+ * @stability experimental
+ */
+export declare const predictedEntitySchema: z.ZodObject<{
+    ref: z.ZodString;
+    type: z.ZodString;
+    label: z.ZodString;
+    aliases: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    resolution: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        outcome: z.ZodEnum<{
+            linked: "linked";
+            new: "new";
+            uncertain: "uncertain";
+        }>;
+        entityId: z.ZodNullable<z.ZodString>;
+        score: z.ZodNullable<z.ZodNumber>;
+        prechecked: z.ZodBoolean;
+    }, z.core.$strip>>>;
+    evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        source: z.ZodEnum<{
+            note: "note";
+            segment: "segment";
+        }>;
+        segmentId: z.ZodNullable<z.ZodString>;
+        quote: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/**
+ * A parsed {@link predictedEntitySchema}.
+ *
+ * @stability experimental
+ */
+export type PredictedEntity = z.infer<typeof predictedEntitySchema>;
+/**
+ * A predicted edge between two refs or known ids, with its temporal bounds and precision.
+ *
+ * @stability experimental
+ */
+export declare const predictedRelationSchema: z.ZodObject<{
+    type: z.ZodString;
+    from: z.ZodString;
+    to: z.ZodString;
+    validFrom: z.ZodNullable<z.ZodString>;
+    validTo: z.ZodNullable<z.ZodString>;
+    precision: z.ZodEnum<{
+        unknown: "unknown";
+        day: "day";
+        month: "month";
+        year: "year";
+    }>;
+    evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        source: z.ZodEnum<{
+            note: "note";
+            segment: "segment";
+        }>;
+        segmentId: z.ZodNullable<z.ZodString>;
+        quote: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/**
+ * A parsed {@link predictedRelationSchema}.
+ *
+ * @stability experimental
+ */
+export type PredictedRelation = z.infer<typeof predictedRelationSchema>;
+/**
+ * A predicted commitment, decision, claim or person fact.
+ *
+ * @stability experimental
+ */
+export declare const predictedItemSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        commitment: "commitment";
+        decision: "decision";
+        claim: "claim";
+        person_fact: "person_fact";
+    }>;
+    subject: z.ZodString;
+    owner: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    counterparty: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    title: z.ZodString;
+    statement: z.ZodString;
+    occurredAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    dueAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    sensitivity: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+        business: "business";
+        personal: "personal";
+        sensitive: "sensitive";
+    }>>>;
+    evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        source: z.ZodEnum<{
+            note: "note";
+            segment: "segment";
+        }>;
+        segmentId: z.ZodNullable<z.ZodString>;
+        quote: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/**
+ * A parsed {@link predictedItemSchema}.
+ *
+ * @stability experimental
+ */
+export type PredictedItem = z.infer<typeof predictedItemSchema>;
+/**
+ * What a runner writes for one fixture, `<outDir>/<fixtureId>.json`: the entities,
+ * relations and items a run proposed, the model id (never a key) and the dropped counts.
+ *
+ * @stability experimental
+ */
+export declare const kgEvalPredictionSchema: z.ZodObject<{
+    fixtureId: z.ZodString;
+    model: z.ZodNullable<z.ZodString>;
+    entities: z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        type: z.ZodString;
+        label: z.ZodString;
+        aliases: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        resolution: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            outcome: z.ZodEnum<{
+                linked: "linked";
+                new: "new";
+                uncertain: "uncertain";
+            }>;
+            entityId: z.ZodNullable<z.ZodString>;
+            score: z.ZodNullable<z.ZodNumber>;
+            prechecked: z.ZodBoolean;
+        }, z.core.$strip>>>;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            source: z.ZodEnum<{
+                note: "note";
+                segment: "segment";
+            }>;
+            segmentId: z.ZodNullable<z.ZodString>;
+            quote: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    relations: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        from: z.ZodString;
+        to: z.ZodString;
+        validFrom: z.ZodNullable<z.ZodString>;
+        validTo: z.ZodNullable<z.ZodString>;
+        precision: z.ZodEnum<{
+            unknown: "unknown";
+            day: "day";
+            month: "month";
+            year: "year";
+        }>;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            source: z.ZodEnum<{
+                note: "note";
+                segment: "segment";
+            }>;
+            segmentId: z.ZodNullable<z.ZodString>;
+            quote: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    items: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            commitment: "commitment";
+            decision: "decision";
+            claim: "claim";
+            person_fact: "person_fact";
+        }>;
+        subject: z.ZodString;
+        owner: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        counterparty: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        title: z.ZodString;
+        statement: z.ZodString;
+        occurredAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        dueAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        sensitivity: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+            business: "business";
+            personal: "personal";
+            sensitive: "sensitive";
+        }>>>;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            source: z.ZodEnum<{
+                note: "note";
+                segment: "segment";
+            }>;
+            segmentId: z.ZodNullable<z.ZodString>;
+            quote: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    stats: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+}, z.core.$strip>;
+/**
+ * A parsed {@link kgEvalPredictionSchema}.
+ *
+ * @stability experimental
+ */
+export type KgEvalPrediction = z.infer<typeof kgEvalPredictionSchema>;
+/**
+ * A prediction as written on disk (before defaults).
+ *
+ * @stability experimental
+ */
+export type KgEvalPredictionInput = z.input<typeof kgEvalPredictionSchema>;
+/**
+ * A prediction with nothing in it: what a missing prediction file scores as.
+ *
+ * @stability experimental
+ */
+export declare function emptyPrediction(fixtureId: string, model?: string | null): KgEvalPrediction;

package/dist/kg/prediction-schema.js

@@ -0,0 +1,102 @@
+"use strict";
+// =============================================================================
+// What a kg:eval runner writes, one file per fixture: `<outDir>/<fixtureId>.json`
+// (issue #362). `from`/`to`/`subject`/`owner`/`counterparty` name either a
+// prediction entity `ref` or a `knownEntities` id from the fixture.
+// =============================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kgEvalPredictionSchema = exports.predictedItemSchema = exports.predictedRelationSchema = exports.predictedEntitySchema = exports.predictedResolutionSchema = exports.predictedEvidenceSchema = void 0;
+exports.emptyPrediction = emptyPrediction;
+const zod_1 = require("zod");
+const index_js_1 = require("../fixtures/index.js");
+/**
+ * One citation of a predicted row: a segment (`segmentId`) or the note, and the quote.
+ *
+ * @stability experimental
+ */
+exports.predictedEvidenceSchema = zod_1.z.object({
+    source: zod_1.z.enum(['segment', 'note']),
+    segmentId: zod_1.z.string().nullable(),
+    quote: zod_1.z.string(),
+});
+/**
+ * What resolution decided for a predicted entity: linked (to `entityId`, with its score
+ * and whether the pre-check accepted it), new, or uncertain.
+ *
+ * @stability experimental
+ */
+exports.predictedResolutionSchema = zod_1.z.object({
+    outcome: zod_1.z.enum(['linked', 'new', 'uncertain']),
+    entityId: zod_1.z.string().nullable(),
+    score: zod_1.z.number().nullable(),
+    prechecked: zod_1.z.boolean(),
+});
+/**
+ * A predicted entity: its `ref` (what relations and items point at), type, label,
+ * aliases, resolution and evidence.
+ *
+ * @stability experimental
+ */
+exports.predictedEntitySchema = zod_1.z.object({
+    ref: zod_1.z.string(),
+    type: zod_1.z.string(),
+    label: zod_1.z.string(),
+    aliases: zod_1.z.array(zod_1.z.string()).default([]),
+    resolution: exports.predictedResolutionSchema.nullable().default(null),
+    evidence: zod_1.z.array(exports.predictedEvidenceSchema).default([]),
+});
+/**
+ * A predicted edge between two refs or known ids, with its temporal bounds and precision.
+ *
+ * @stability experimental
+ */
+exports.predictedRelationSchema = zod_1.z.object({
+    type: zod_1.z.string(),
+    from: zod_1.z.string(),
+    to: zod_1.z.string(),
+    validFrom: zod_1.z.string().nullable(),
+    validTo: zod_1.z.string().nullable(),
+    precision: index_js_1.validPrecisionSchema,
+    evidence: zod_1.z.array(exports.predictedEvidenceSchema).default([]),
+});
+/**
+ * A predicted commitment, decision, claim or person fact.
+ *
+ * @stability experimental
+ */
+exports.predictedItemSchema = zod_1.z.object({
+    kind: zod_1.z.enum(index_js_1.ITEM_LABEL_KINDS),
+    subject: zod_1.z.string(),
+    owner: zod_1.z.string().nullable().default(null),
+    counterparty: zod_1.z.string().nullable().default(null),
+    title: zod_1.z.string(),
+    statement: zod_1.z.string(),
+    occurredAt: zod_1.z.string().nullable().default(null),
+    dueAt: zod_1.z.string().nullable().default(null),
+    sensitivity: zod_1.z.enum(['business', 'personal', 'sensitive']).nullable().default(null),
+    evidence: zod_1.z.array(exports.predictedEvidenceSchema).default([]),
+});
+/**
+ * What a runner writes for one fixture, `<outDir>/<fixtureId>.json`: the entities,
+ * relations and items a run proposed, the model id (never a key) and the dropped counts.
+ *
+ * @stability experimental
+ */
+exports.kgEvalPredictionSchema = zod_1.z.object({
+    fixtureId: zod_1.z.string(),
+    /** The model id only — never a key, never a provider credential. */
+    model: zod_1.z.string().nullable(),
+    entities: zod_1.z.array(exports.predictedEntitySchema),
+    relations: zod_1.z.array(exports.predictedRelationSchema),
+    items: zod_1.z.array(exports.predictedItemSchema),
+    /** Passthrough from the proposal (`uncited`, `invalid`, … dropped counts). */
+    stats: zod_1.z.record(zod_1.z.string(), zod_1.z.number()).default({}),
+});
+/**
+ * A prediction with nothing in it: what a missing prediction file scores as.
+ *
+ * @stability experimental
+ */
+function emptyPrediction(fixtureId, model = null) {
+    return { fixtureId, model, entities: [], relations: [], items: [], stats: {} };
+}

package/dist/kg/predictions.d.ts

@@ -0,0 +1,11 @@
+import { type KgEvalPrediction } from './prediction-schema.js';
+/**
+ * One prediction file, or `null` when absent.
+ *
+ * @param dir - the predictions directory.
+ * @param fixtureId - the fixture the file is named after.
+ * @returns the prediction, or `null`.
+ * @throws `KgEvalLoadError` when the file is not JSON, does not match the schema or names another fixture.
+ * @stability experimental
+ */
+export declare function loadPredictionFile(dir: string, fixtureId: string): KgEvalPrediction | null;

package/dist/kg/predictions.js

@@ -0,0 +1,49 @@
+"use strict";
+// Loading a predictions directory (issue #362): `<dir>/<fixtureId>.json`, one
+// file per fixture, parsed through `kgEvalPredictionSchema`. A missing file is
+// `null` (the caller scores it as empty and says so); a malformed one throws
+// with its name.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadPredictionFile = loadPredictionFile;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const index_js_1 = require("../fixtures/index.js");
+const prediction_schema_js_1 = require("./prediction-schema.js");
+/**
+ * One prediction file, or `null` when absent.
+ *
+ * @param dir - the predictions directory.
+ * @param fixtureId - the fixture the file is named after.
+ * @returns the prediction, or `null`.
+ * @throws `KgEvalLoadError` when the file is not JSON, does not match the schema or names another fixture.
+ * @stability experimental
+ */
+function loadPredictionFile(dir, fixtureId) {
+    const file = (0, path_1.join)(dir, `${fixtureId}.json`);
+    let text;
+    try {
+        text = (0, fs_1.readFileSync)(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    let raw;
+    try {
+        raw = JSON.parse(text);
+    }
+    catch (err) {
+        throw new index_js_1.KgEvalLoadError(`${file}: not valid JSON (${err.message})`);
+    }
+    const parsed = prediction_schema_js_1.kgEvalPredictionSchema.safeParse(raw);
+    if (!parsed.success) {
+        const issues = parsed.error.issues
+            .slice(0, 5)
+            .map((i) => `${i.path.join('.')}: ${i.message}`)
+            .join('; ');
+        throw new index_js_1.KgEvalLoadError(`${file}: does not match kgEvalPredictionSchema — ${issues}`);
+    }
+    if (parsed.data.fixtureId !== fixtureId) {
+        throw new index_js_1.KgEvalLoadError(`${file}: fixtureId is ${parsed.data.fixtureId}, expected ${fixtureId}`);
+    }
+    return parsed.data;
+}

package/dist/kg/report.d.ts

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+import { type RunScore } from './scorer.js';
+/**
+ * The kg evaluation report, the JSON `--json` writes: per-type counts and ratios, the §6
+ * target metrics, evidence validity, temporal accuracy, the dropped counts and the
+ * per-fixture sums. A tuning script may rely on its shape.
+ *
+ * @stability experimental
+ */
+export declare const kgEvalReportSchema: z.ZodObject<{
+    fixtures: z.ZodNumber;
+    fixtureIds: z.ZodArray<z.ZodString>;
+    runner: z.ZodString;
+    model: z.ZodNullable<z.ZodString>;
+    types: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        tp: z.ZodNumber;
+        fp: z.ZodNumber;
+        fn: z.ZodNumber;
+        precision: z.ZodNullable<z.ZodNumber>;
+        recall: z.ZodNullable<z.ZodNumber>;
+        f1: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+    metrics: z.ZodObject<{
+        entityCoverage: z.ZodObject<{
+            value: z.ZodNullable<z.ZodNumber>;
+            target: z.ZodNumber;
+            pass: z.ZodNullable<z.ZodBoolean>;
+        }, z.core.$strip>;
+        commitmentRecall: z.ZodObject<{
+            value: z.ZodNullable<z.ZodNumber>;
+            target: z.ZodNumber;
+            pass: z.ZodNullable<z.ZodBoolean>;
+        }, z.core.$strip>;
+        autoLinkPrecision: z.ZodObject<{
+            value: z.ZodNullable<z.ZodNumber>;
+            target: z.ZodNumber;
+            pass: z.ZodNullable<z.ZodBoolean>;
+        }, z.core.$strip>;
+        evidenceValidity: z.ZodObject<{
+            value: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>;
+        temporalAccuracy: z.ZodObject<{
+            value: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    dropped: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    perFixture: z.ZodArray<z.ZodObject<{
+        fixtureId: z.ZodString;
+        tp: z.ZodNumber;
+        fp: z.ZodNumber;
+        fn: z.ZodNumber;
+    }, z.core.$strip>>;
+    targetsMet: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * A parsed {@link kgEvalReportSchema}.
+ *
+ * @stability experimental
+ */
+export type KgEvalReport = z.infer<typeof kgEvalReportSchema>;
+/**
+ * Turns a run's score into the report.
+ *
+ * @param run - the run's score (`scoreRun`).
+ * @param meta - the runner label, the model and the fixture ids.
+ * @returns the report (`targetsMet` is `true` when no target with a value fails).
+ *
+ * @stability experimental
+ */
+export declare function buildReport(run: RunScore, meta: {
+    runner: string;
+    model: string | null;
+    fixtureIds: string[];
+}): KgEvalReport;
+/**
+ * The report as the fixed-column table the command prints.
+ *
+ * @param r - the report.
+ * @returns the table.
+ *
+ * @stability experimental
+ */
+export declare function formatReport(r: KgEvalReport): string;

package/dist/kg/report.js

@@ -0,0 +1,125 @@
+"use strict";
+// kg:eval report (issue #362): one object, printed as a fixed-column table and
+// optionally written as JSON (`--json`). `kgEvalReportSchema` is the JSON's
+// contract — a tuning script that reads it can rely on its shape.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kgEvalReportSchema = void 0;
+exports.buildReport = buildReport;
+exports.formatReport = formatReport;
+const zod_1 = require("zod");
+const scorer_js_1 = require("./scorer.js");
+const targets_js_1 = require("./targets.js");
+const nullableRatio = zod_1.z.number().min(0).max(1).nullable();
+const targetMetric = zod_1.z.object({ value: nullableRatio, target: zod_1.z.number(), pass: zod_1.z.boolean().nullable() });
+/**
+ * The kg evaluation report, the JSON `--json` writes: per-type counts and ratios, the §6
+ * target metrics, evidence validity, temporal accuracy, the dropped counts and the
+ * per-fixture sums. A tuning script may rely on its shape.
+ *
+ * @stability experimental
+ */
+exports.kgEvalReportSchema = zod_1.z.object({
+    fixtures: zod_1.z.number().int(),
+    fixtureIds: zod_1.z.array(zod_1.z.string()),
+    runner: zod_1.z.string(),
+    model: zod_1.z.string().nullable(),
+    types: zod_1.z.array(zod_1.z.object({
+        type: zod_1.z.string(),
+        tp: zod_1.z.number().int(),
+        fp: zod_1.z.number().int(),
+        fn: zod_1.z.number().int(),
+        precision: nullableRatio,
+        recall: nullableRatio,
+        f1: nullableRatio,
+    })),
+    metrics: zod_1.z.object({
+        entityCoverage: targetMetric,
+        commitmentRecall: targetMetric,
+        autoLinkPrecision: targetMetric,
+        evidenceValidity: zod_1.z.object({ value: nullableRatio }),
+        temporalAccuracy: zod_1.z.object({ value: nullableRatio }),
+    }),
+    dropped: zod_1.z.record(zod_1.z.string(), zod_1.z.number()),
+    perFixture: zod_1.z.array(zod_1.z.object({ fixtureId: zod_1.z.string(), tp: zod_1.z.number().int(), fp: zod_1.z.number().int(), fn: zod_1.z.number().int() })),
+    /** true when every target with a value meets it (an `n/a` target never fails). */
+    targetsMet: zod_1.z.boolean(),
+});
+function target(value, t) {
+    return { value, target: t, pass: value === null ? null : value >= t };
+}
+/**
+ * Turns a run's score into the report.
+ *
+ * @param run - the run's score (`scoreRun`).
+ * @param meta - the runner label, the model and the fixture ids.
+ * @returns the report (`targetsMet` is `true` when no target with a value fails).
+ *
+ * @stability experimental
+ */
+function buildReport(run, meta) {
+    const relationTypes = Object.keys(run.types)
+        .filter((t) => t.startsWith('relation:'))
+        .sort();
+    const types = [...scorer_js_1.BASE_REPORT_TYPES, ...relationTypes].map((type) => {
+        const c = run.types[type] ?? { tp: 0, fp: 0, fn: 0 };
+        return { type, ...c, precision: (0, scorer_js_1.precisionOf)(c), recall: (0, scorer_js_1.recallOf)(c), f1: (0, scorer_js_1.f1Of)(c) };
+    });
+    const metrics = {
+        entityCoverage: target((0, scorer_js_1.entityCoverage)(run), targets_js_1.KG_EVAL_TARGETS.entityCoverage),
+        commitmentRecall: target((0, scorer_js_1.commitmentRecall)(run), targets_js_1.KG_EVAL_TARGETS.commitmentRecall),
+        autoLinkPrecision: target((0, scorer_js_1.autoLinkPrecision)(run), targets_js_1.KG_EVAL_TARGETS.autoLinkPrecision),
+        evidenceValidity: { value: (0, scorer_js_1.ratio)(run.evidence.valid, run.evidence.total) },
+        temporalAccuracy: { value: (0, scorer_js_1.ratio)(run.temporal.accurate, run.temporal.total) },
+    };
+    const dropped = { uncited: 0, invalid: 0, ...run.stats };
+    const perFixture = run.perFixture.map((f) => {
+        const sum = { tp: 0, fp: 0, fn: 0 };
+        for (const c of Object.values(f.types)) {
+            sum.tp += c.tp;
+            sum.fp += c.fp;
+            sum.fn += c.fn;
+        }
+        return { fixtureId: f.fixtureId, ...sum };
+    });
+    const targetsMet = [metrics.entityCoverage, metrics.commitmentRecall, metrics.autoLinkPrecision].every((m) => m.pass !== false);
+    return {
+        fixtures: run.fixtures,
+        fixtureIds: meta.fixtureIds,
+        runner: meta.runner,
+        model: meta.model,
+        types,
+        metrics,
+        dropped,
+        perFixture,
+        targetsMet,
+    };
+}
+const fmt = (v) => (v === null ? 'n/a' : v.toFixed(3));
+const pad = (s, n) => String(s).padEnd(n);
+/**
+ * The report as the fixed-column table the command prints.
+ *
+ * @param r - the report.
+ * @returns the table.
+ *
+ * @stability experimental
+ */
+function formatReport(r) {
+    const lines = [];
+    lines.push(`kg:eval  fixtures=${r.fixtures}  runner=${r.runner}  model=${r.model ?? '-'}`);
+    lines.push(`${pad('TYPE', 26)}${pad('TP', 6)}${pad('FP', 6)}${pad('FN', 6)}${pad('P', 7)}${pad('R', 7)}F1`);
+    for (const t of r.types) {
+        lines.push(`${pad(t.type, 26)}${pad(t.tp, 6)}${pad(t.fp, 6)}${pad(t.fn, 6)}${pad(fmt(t.precision), 7)}${pad(fmt(t.recall), 7)}${fmt(t.f1)}`);
+    }
+    const verdict = (m) => (m.pass === null ? '' : m.pass ? 'PASS' : 'FAIL');
+    const m = r.metrics;
+    lines.push(`${pad('ENTITY COVERAGE', 21)}${pad(fmt(m.entityCoverage.value), 8)}target ≥ ${m.entityCoverage.target.toFixed(2)}   ${verdict(m.entityCoverage)}`);
+    lines.push(`${pad('COMMITMENT RECALL', 21)}${pad(fmt(m.commitmentRecall.value), 8)}target ≥ ${m.commitmentRecall.target.toFixed(2)}   ${verdict(m.commitmentRecall)}`);
+    lines.push(`${pad('AUTO-LINK PRECISION', 21)}${pad(fmt(m.autoLinkPrecision.value), 8)}target ≥ ${m.autoLinkPrecision.target.toFixed(2)}   ${m.autoLinkPrecision.value === null ? '(no resolution in predictions)' : verdict(m.autoLinkPrecision)}`);
+    lines.push(`${pad('EVIDENCE VALIDITY', 21)}${pad(fmt(m.evidenceValidity.value), 8)}(cites that resolve to a fixture segment/note and whose quote is located)`);
+    lines.push(`${pad('TEMPORAL ACCURACY', 21)}${pad(fmt(m.temporalAccuracy.value), 8)}(matched temporal relations/items with equal precision and dates at that precision)`);
+    lines.push(`${pad('DROPPED (stats)', 21)}${Object.entries(r.dropped)
+        .map(([k, v]) => `${k}=${v}`)
+        .join(' ')}`);
+    return lines.join('\n');
+}