niceeval 0.12.1 → 0.12.2-canary.31

package/dist/report/author/model.d.ts

@@ -0,0 +1,241 @@
+import type { AnalysisSample } from "../../analysis/index.js";
+import type { ProjectedSample, ProjectionAccess } from "../../projection/model.js";
+import { type RecordProjection } from "../../projection/projector.js";
+import type { ReportCalculationResult } from "../execution/results.js";
+import type { ReportDocument } from "../semantic/document.js";
+import { type ReportComponentId, type ReportDownloadPath, type ReportId, type ReportInstanceKey, type ReportRoute } from "./identity.js";
+declare const reportDataPlanTypeId: unique symbol;
+declare const reportDataPlanCardinalityTypeId: unique symbol;
+declare const reportCalculationTypeId: unique symbol;
+declare const reportPageTypeId: unique symbol;
+declare const reportPageFamilyTypeId: unique symbol;
+declare const reportDownloadTypeId: unique symbol;
+declare const reportTypeId: unique symbol;
+type DataPlanCardinality = "empty" | "non-empty";
+type AnyRecordProjection = RecordProjection<any, any>;
+interface DataPlan<Shape extends object, Cardinality extends DataPlanCardinality> {
+    readonly [reportDataPlanTypeId]: {
+        readonly _Shape: () => Shape;
+    };
+    readonly [reportDataPlanCardinalityTypeId]: Cardinality;
+}
+/**
+ * A package-created, named projection shape. Its actual declarations live in
+ * a private WeakMap rather than in a forgeable object field.
+ */
+export type ReportDataPlan<Shape extends object = object> = DataPlan<Shape, DataPlanCardinality>;
+type EmptyReportDataPlan = DataPlan<object, "empty">;
+type NonEmptyReportDataPlan = DataPlan<object, "non-empty">;
+export type ReportDataShape<Plan extends ReportDataPlan> = Plan extends DataPlan<infer Shape, DataPlanCardinality> ? Shape : never;
+export type ReportProjectedValues<Plan extends ReportDataPlan> = {
+    readonly [Key in keyof ReportDataShape<Plan>]: ReportDataShape<Plan>[Key] extends RecordProjection<infer Access, infer Value> ? ProjectedSample<Access, Value> : never;
+};
+export type ReportCompleteness = "allow-partial" | "require-complete";
+export interface ReportDataState {
+    readonly state: "complete" | "partial";
+}
+type CalculationCompleteness<Inputs extends ReportDataPlan> = Inputs extends NonEmptyReportDataPlan ? {
+    readonly completeness: ReportCompleteness;
+} : {
+    readonly completeness?: never;
+};
+/** One static projection-derived value with no dependency on another Calculation. */
+export type ReportCalculation<Inputs extends ReportDataPlan, Value> = Readonly<{
+    readonly id: ReportComponentId;
+    readonly inputs: Inputs;
+    readonly calculate: (context: {
+        readonly sample: AnalysisSample;
+        readonly inputs: ReportProjectedValues<Inputs>;
+    }) => Value;
+    readonly [reportCalculationTypeId]: (value: Value) => Value;
+}> & CalculationCompleteness<Inputs>;
+export type AnyReportCalculation = ReportCalculation<any, any>;
+export type ReportCalculationSet = Readonly<Record<string, AnyReportCalculation>>;
+export type ReportCalculationResults<Set extends object> = {
+    readonly [Key in keyof Set]: Set[Key] extends ReportCalculation<any, infer Value> ? ReportCalculationResult<Value> : never;
+};
+export type ReportComponentContext<Inputs extends ReportDataPlan | undefined = undefined, Calculations extends object = {}> = {
+    readonly sample: AnalysisSample;
+    readonly inputs: Inputs extends ReportDataPlan ? ReportProjectedValues<Inputs> : {};
+    readonly calculations: ReportCalculationResults<Calculations>;
+};
+/** An opaque fixed Page. Its callback is retained only in package-private authority. */
+export interface ReportPage {
+    readonly id: ReportComponentId;
+    readonly route: ReportRoute;
+    readonly [reportPageTypeId]: () => void;
+}
+/** An opaque PageFamily whose instances are expanded only from already-formed values. */
+export interface ReportPageFamily {
+    readonly id: ReportComponentId;
+    readonly [reportPageFamilyTypeId]: () => void;
+}
+export interface ReportDownloadFile {
+    readonly path: ReportDownloadPath;
+    readonly mediaType: string;
+    readonly bytes: Uint8Array;
+}
+/** An opaque authored Download. */
+export interface ReportDownload {
+    readonly id: ReportComponentId;
+    readonly [reportDownloadTypeId]: () => void;
+}
+/** The sole public aggregate for a Report authoring module. */
+export interface Report {
+    readonly id: ReportId;
+    readonly calculations: ReportCalculationSet;
+    readonly pages: readonly (ReportPage | ReportPageFamily)[];
+    readonly downloads: readonly ReportDownload[];
+    readonly [reportTypeId]: () => void;
+}
+interface DataPlanContents {
+    readonly entries: readonly {
+        readonly key: string;
+        readonly projection: RecordProjection<ProjectionAccess, unknown>;
+    }[];
+    readonly cardinality: DataPlanCardinality;
+}
+type AuthorCallback = (...arguments_: never[]) => unknown;
+interface ComponentContents {
+    readonly calculations: ReportCalculationSet;
+    readonly calculationsById: readonly AnyReportCalculation[];
+    readonly inputs?: ReportDataPlan;
+    readonly completeness?: ReportCompleteness;
+}
+interface CalculationContents {
+    readonly calculations: ReportCalculationSet;
+    readonly calculationsById: readonly AnyReportCalculation[];
+    readonly inputs: ReportDataPlan;
+    readonly completeness?: ReportCompleteness;
+    readonly calculate: AuthorCallback;
+}
+interface PageContents extends ComponentContents {
+    readonly render: AuthorCallback;
+}
+interface PageFamilyContents extends ComponentContents {
+    readonly instances: AuthorCallback;
+    readonly key: AuthorCallback;
+    readonly route: AuthorCallback;
+    readonly render: AuthorCallback;
+}
+interface DownloadContents extends ComponentContents {
+    readonly build: AuthorCallback;
+}
+interface ReportContents {
+    readonly calculations: ReportCalculationSet;
+    readonly calculationsById: readonly AnyReportCalculation[];
+    readonly pages: readonly (ReportPage | ReportPageFamily)[];
+    readonly downloads: readonly ReportDownload[];
+}
+type ProjectionShapeCheck<Shape extends object> = {
+    readonly [Key in keyof Shape]: Shape[Key] extends AnyRecordProjection ? unknown : never;
+};
+type ShapeCardinality<Shape extends object> = keyof Shape extends never ? "empty" : "non-empty";
+type CalculationSetCheck<Set extends object> = {
+    readonly [Key in keyof Set]: Set[Key] extends AnyReportCalculation ? unknown : never;
+};
+/**
+ * Captures an exact named projection shape. Runtime validation rejects copied
+ * projections, accessors, symbols, and non-plain objects before any host I/O.
+ */
+export declare function reportInputs<const Shape extends object>(shape: Shape & ProjectionShapeCheck<Shape>): DataPlan<Shape, ShapeCardinality<Shape>>;
+export declare function defineCalculation<Inputs extends EmptyReportDataPlan, Value>(definition: {
+    readonly id: ReportComponentId;
+    readonly inputs: Inputs;
+    readonly completeness?: never;
+    readonly calculate: (context: {
+        readonly sample: AnalysisSample;
+        readonly inputs: ReportProjectedValues<Inputs>;
+    }) => Value;
+}): ReportCalculation<Inputs, Value>;
+export declare function defineCalculation<Inputs extends NonEmptyReportDataPlan, Value>(definition: {
+    readonly id: ReportComponentId;
+    readonly inputs: Inputs;
+    readonly completeness: ReportCompleteness;
+    readonly calculate: (context: {
+        readonly sample: AnalysisSample;
+        readonly inputs: ReportProjectedValues<Inputs>;
+    }) => Value;
+}): ReportCalculation<Inputs, Value>;
+export declare function definePage<Calculations extends object = {}>(definition: {
+    readonly id: ReportComponentId;
+    readonly route: ReportRoute;
+    readonly inputs?: never;
+    readonly completeness?: never;
+    readonly calculations?: Calculations & CalculationSetCheck<Calculations>;
+    readonly render: (context: ReportComponentContext<undefined, Calculations>) => ReportDocument;
+}): ReportPage;
+export declare function definePage<Inputs extends NonEmptyReportDataPlan, Calculations extends object = {}>(definition: {
+    readonly id: ReportComponentId;
+    readonly route: ReportRoute;
+    readonly inputs: Inputs;
+    readonly completeness: ReportCompleteness;
+    readonly calculations?: Calculations & CalculationSetCheck<Calculations>;
+    readonly render: (context: ReportComponentContext<Inputs, Calculations>) => ReportDocument;
+}): ReportPage;
+export declare function definePageFamily<Instance, Calculations extends object = {}>(definition: {
+    readonly id: ReportComponentId;
+    readonly inputs?: never;
+    readonly completeness?: never;
+    readonly calculations?: Calculations & CalculationSetCheck<Calculations>;
+    readonly instances: (context: ReportComponentContext<undefined, Calculations>) => Iterable<Instance>;
+    readonly key: (instance: Instance) => ReportInstanceKey;
+    readonly route: (instance: Instance) => ReportRoute;
+    readonly render: (context: ReportComponentContext<undefined, Calculations> & {
+        readonly instance: Instance;
+    }) => ReportDocument;
+}): ReportPageFamily;
+export declare function definePageFamily<Inputs extends NonEmptyReportDataPlan, Instance, Calculations extends object = {}>(definition: {
+    readonly id: ReportComponentId;
+    readonly inputs: Inputs;
+    readonly completeness: ReportCompleteness;
+    readonly calculations?: Calculations & CalculationSetCheck<Calculations>;
+    readonly instances: (context: ReportComponentContext<Inputs, Calculations>) => Iterable<Instance>;
+    readonly key: (instance: Instance) => ReportInstanceKey;
+    readonly route: (instance: Instance) => ReportRoute;
+    readonly render: (context: ReportComponentContext<Inputs, Calculations> & {
+        readonly instance: Instance;
+    }) => ReportDocument;
+}): ReportPageFamily;
+export declare function defineDownload<Calculations extends object = {}>(definition: {
+    readonly id: ReportComponentId;
+    readonly inputs?: never;
+    readonly completeness?: never;
+    readonly calculations?: Calculations & CalculationSetCheck<Calculations>;
+    readonly build: (context: ReportComponentContext<undefined, Calculations>) => Iterable<ReportDownloadFile>;
+}): ReportDownload;
+export declare function defineDownload<Inputs extends NonEmptyReportDataPlan, Calculations extends object = {}>(definition: {
+    readonly id: ReportComponentId;
+    readonly inputs: Inputs;
+    readonly completeness: ReportCompleteness;
+    readonly calculations?: Calculations & CalculationSetCheck<Calculations>;
+    readonly build: (context: ReportComponentContext<Inputs, Calculations>) => Iterable<ReportDownloadFile>;
+}): ReportDownload;
+export declare function defineReport<Calculations extends object = {}>(definition: {
+    readonly id: ReportId;
+    readonly calculations?: Calculations & CalculationSetCheck<Calculations>;
+    readonly pages: readonly (ReportPage | ReportPageFamily)[];
+    readonly downloads?: readonly ReportDownload[];
+}): Report;
+export declare function isReport(value: unknown): value is Report;
+/** @internal Exact-identity bridge used only by author/internal.ts. */
+export declare function authorInternalReportContents(report: Report): ReportContents;
+/** @internal Exact-identity bridge used only by author/internal.ts. */
+export declare function authorInternalDataPlanContents(plan: ReportDataPlan): DataPlanContents;
+/** @internal Exact-identity bridge used only by author/internal.ts. */
+export declare function authorInternalCalculationContents(calculation: AnyReportCalculation): CalculationContents;
+/** @internal Exact-identity bridge used only by author/internal.ts. */
+export declare function authorInternalPageContents(page: ReportPage): PageContents;
+/** @internal Exact-identity bridge used only by author/internal.ts. */
+export declare function authorInternalPageFamilyContents(family: ReportPageFamily): PageFamilyContents;
+/** @internal Exact-identity bridge used only by author/internal.ts. */
+export declare function authorInternalPageMemberContents(member: ReportPage | ReportPageFamily): {
+    readonly kind: "page";
+    readonly contents: PageContents;
+} | {
+    readonly kind: "page-family";
+    readonly contents: PageFamilyContents;
+};
+/** @internal Exact-identity bridge used only by author/internal.ts. */
+export declare function authorInternalDownloadContents(download: ReportDownload): DownloadContents;
+export {};

package/dist/report/author/model.js

@@ -0,0 +1,32 @@
+import { createRequire as __niceevalCreateRequire } from "node:module";
+const __niceevalRequire = __niceevalCreateRequire(import.meta.url);
+const __niceevalCanonical = __niceevalRequire("./model.cjs");
+const __niceevalExport0 = __niceevalCanonical["authorInternalCalculationContents"];
+export { __niceevalExport0 as authorInternalCalculationContents };
+const __niceevalExport1 = __niceevalCanonical["authorInternalDataPlanContents"];
+export { __niceevalExport1 as authorInternalDataPlanContents };
+const __niceevalExport2 = __niceevalCanonical["authorInternalDownloadContents"];
+export { __niceevalExport2 as authorInternalDownloadContents };
+const __niceevalExport3 = __niceevalCanonical["authorInternalPageContents"];
+export { __niceevalExport3 as authorInternalPageContents };
+const __niceevalExport4 = __niceevalCanonical["authorInternalPageFamilyContents"];
+export { __niceevalExport4 as authorInternalPageFamilyContents };
+const __niceevalExport5 = __niceevalCanonical["authorInternalPageMemberContents"];
+export { __niceevalExport5 as authorInternalPageMemberContents };
+const __niceevalExport6 = __niceevalCanonical["authorInternalReportContents"];
+export { __niceevalExport6 as authorInternalReportContents };
+const __niceevalExport7 = __niceevalCanonical["defineCalculation"];
+export { __niceevalExport7 as defineCalculation };
+const __niceevalExport8 = __niceevalCanonical["defineDownload"];
+export { __niceevalExport8 as defineDownload };
+const __niceevalExport9 = __niceevalCanonical["definePage"];
+export { __niceevalExport9 as definePage };
+const __niceevalExport10 = __niceevalCanonical["definePageFamily"];
+export { __niceevalExport10 as definePageFamily };
+const __niceevalExport11 = __niceevalCanonical["defineReport"];
+export { __niceevalExport11 as defineReport };
+const __niceevalExport12 = __niceevalCanonical["isReport"];
+export { __niceevalExport12 as isReport };
+const __niceevalExport13 = __niceevalCanonical["reportInputs"];
+export { __niceevalExport13 as reportInputs };
+//# sourceMappingURL=model.js.map

package/dist/report/author/model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.js","sources":[],"names":[],"mappings":""}

package/dist/report/built-in/attempt-overview.cjs

@@ -0,0 +1,395 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultAttemptOverviewReport = void 0;
+exports.attemptOverviewReport = attemptOverviewReport;
+const effect_1 = require("effect");
+const attempt_locator_ts_1 = require("../../attempt-locator.cjs");
+const index_ts_1 = require("../../projection/index.cjs");
+const family_projectors_ts_1 = require("../../o11y/record/family-projectors.cjs");
+const index_ts_2 = require("../author/index.cjs");
+const index_ts_3 = require("../semantic/index.cjs");
+const ASSERTION_ROWS_MAX = 200;
+const assertionResultStates = [
+    "matched",
+    "mismatched",
+    "unavailable",
+    "errored",
+    "not-applicable",
+];
+const attemptOverviewInputs = (0, index_ts_2.reportInputs)({
+    "evaluation-plan": (0, index_ts_1.selectedRunProjection)(index_ts_1.evaluationPlanProjector),
+    assertions: (0, index_ts_1.attemptSlotProjection)(index_ts_1.assertionsProjector),
+    verdict: (0, index_ts_1.attemptSlotProjection)(index_ts_1.verdictProjector),
+    score: (0, index_ts_1.attemptSlotProjection)(index_ts_1.scoreProjector),
+    diagnostics: (0, index_ts_1.attemptSlotProjection)(family_projectors_ts_1.attemptDiagnosticsProjector),
+});
+/**
+ * A capability-free Attempt overview built with the same public author API as
+ * user Reports. It declares every Attachment it reads and receives no Record
+ * reader, paths, or private evidence access.
+ */
+function attemptOverviewReport() {
+    const page = (0, index_ts_2.definePage)({
+        id: effect_1.Either.getOrThrow((0, index_ts_2.reportComponentId)("attempt-overview")),
+        route: effect_1.Either.getOrThrow((0, index_ts_2.reportRoute)("/")),
+        inputs: attemptOverviewInputs,
+        completeness: "allow-partial",
+        render: ({ inputs }) => attemptOverviewDocument(inputs),
+    });
+    return (0, index_ts_2.defineReport)({
+        id: effect_1.Either.getOrThrow((0, index_ts_2.reportId)("attempt-overview")),
+        pages: [page],
+    });
+}
+/** The built-in default for an exact Attempt locator. */
+exports.defaultAttemptOverviewReport = attemptOverviewReport();
+exports.default = exports.defaultAttemptOverviewReport;
+function attemptOverviewDocument(inputs) {
+    const slots = assembleAttemptOverviewSlots(inputs);
+    return (0, index_ts_3.reportDocument)({
+        title: "Attempt overview",
+        children: slots.length === 0
+            ? [(0, index_ts_3.reportStatus)({
+                    tone: "warning",
+                    label: "No selected Slot has a readable Attempt",
+                })]
+            : [
+                (0, index_ts_3.reportMetric)({ label: "Selected Attempts", value: slots.length }),
+                ...slots.map(attemptOverviewSlotBlock),
+            ],
+    });
+}
+function assembleAttemptOverviewSlots(inputs) {
+    const assertionsBySlot = entriesBySlot(inputs.assertions);
+    const scoreBySlot = entriesBySlot(inputs.score);
+    const diagnosticsBySlot = entriesBySlot(inputs.diagnostics);
+    const plansByRun = new Map();
+    for (const entry of inputs["evaluation-plan"].entries) {
+        plansByRun.set(entry.run.runId, entry);
+    }
+    const slots = [];
+    for (const entry of inputs.verdict.entries) {
+        if (entry.state !== "attachment-result")
+            continue;
+        const key = slotKey(entry.slot);
+        slots.push(Object.freeze({
+            slot: entry.slot,
+            plan: plansByRun.get(entry.slot.runId),
+            assertions: attachmentForSlot(assertionsBySlot.get(key)),
+            verdict: entry.attachment,
+            score: attachmentForSlot(scoreBySlot.get(key)),
+            diagnostics: attachmentForSlot(diagnosticsBySlot.get(key)),
+        }));
+    }
+    return Object.freeze(slots);
+}
+function entriesBySlot(projection) {
+    const entries = new Map();
+    for (const entry of projection.entries) {
+        entries.set(slotKey(entry.slot), entry);
+    }
+    return entries;
+}
+function slotKey(slot) {
+    return `${slot.runId}\u0000${slot.slotId}`;
+}
+function attachmentForSlot(entry) {
+    return entry?.state === "attachment-result" ? entry.attachment : undefined;
+}
+function attemptOverviewSlotBlock(input) {
+    const coordinate = evaluationCoordinate(input.slot, input.plan);
+    return (0, index_ts_3.reportSection)({
+        heading: `Attempt ${(0, attempt_locator_ts_1.encodeAttemptLocator)(input.slot.attempt.attemptId)}`,
+        children: [
+            (0, index_ts_3.reportSection)({
+                heading: "Identity",
+                children: identityBlocks(input.slot, input.plan, coordinate),
+            }),
+            (0, index_ts_3.reportSection)({
+                heading: coordinate?.kind === "score" ? "Score status" : "Verdict",
+                children: verdictBlocks(input.verdict, input.score, coordinate?.kind),
+            }),
+            ...executionErrorBlocks(input.diagnostics),
+            (0, index_ts_3.reportSection)({
+                heading: "Assertions",
+                children: assertionBlocks(input.assertions),
+            }),
+            (0, index_ts_3.reportSection)({
+                heading: "Score",
+                children: scoreBlocks(input.score, coordinate?.kind),
+            }),
+        ],
+    });
+}
+function executionErrorBlocks(diagnostics) {
+    if (diagnostics?.state !== "available")
+        return [];
+    const errors = diagnostics.value.diagnostics.filter((diagnostic) => diagnostic.kind === "execution-error");
+    if (errors.length === 0)
+        return [];
+    return [(0, index_ts_3.reportSection)({
+            heading: "Execution error",
+            children: [(0, index_ts_3.reportTable)({
+                    caption: "Execution errors",
+                    columns: [
+                        { key: "code", label: "Code" },
+                        { key: "phase", label: "Phase" },
+                        { key: "summary", label: "Summary" },
+                    ],
+                    rows: errors.map((error) => ({
+                        code: error.code,
+                        phase: error.phase,
+                        summary: error.summary,
+                    })),
+                })],
+        })];
+}
+function identityBlocks(slot, plan, coordinate) {
+    const rows = [
+        { field: "Attempt", value: (0, attempt_locator_ts_1.encodeAttemptLocator)(slot.attempt.attemptId) },
+        { field: "Origin Run", value: slot.attempt.originRunId },
+        { field: "Selected Run", value: slot.runId },
+        { field: "Slot", value: slot.slotId },
+        { field: "Member relation", value: slot.relation },
+    ];
+    if (coordinate !== undefined) {
+        rows.push({ field: "Experiment", value: coordinate.experimentId }, { field: "Eval", value: coordinate.evalId }, { field: "Evaluation kind", value: coordinate.kind }, { field: "Attempt ordinal", value: coordinate.attempt });
+    }
+    return [
+        (0, index_ts_3.reportTable)({
+            caption: "Attempt identity",
+            columns: [
+                { key: "field", label: "Field" },
+                { key: "value", label: "Value" },
+            ],
+            rows,
+        }),
+        ...evaluationPlanStatus(slot, plan, coordinate),
+    ];
+}
+function evaluationPlanStatus(slot, plan, coordinate) {
+    if (plan === undefined) {
+        return [projectionAlignmentStatus("Evaluation identity")];
+    }
+    if (plan.attachment.state !== "available") {
+        return [attachmentStatus("Evaluation identity", plan.attachment)];
+    }
+    if (coordinate === undefined) {
+        return [(0, index_ts_3.reportStatus)({
+                tone: "negative",
+                label: `Evaluation identity: no coordinate for Slot ${slot.slotId}`,
+            })];
+    }
+    return [(0, index_ts_3.reportStatus)({
+            tone: "positive",
+            label: "Evaluation identity: available",
+        })];
+}
+function evaluationCoordinate(slot, plan) {
+    return plan?.attachment.state === "available"
+        ? plan.attachment.value.coordinateForSlot(slot.slotId)
+        : undefined;
+}
+function verdictBlocks(verdict, score, evaluationKind) {
+    if (verdict.state !== "available")
+        return [attachmentStatus("Verdict", verdict)];
+    if (evaluationKind === "score") {
+        const status = verdict.value === "skipped"
+            ? "skipped"
+            : verdict.value === "errored" || score?.state !== "available" || score.value.state !== "complete"
+                ? "errored"
+                : "scored";
+        return [
+            (0, index_ts_3.reportStatus)({
+                tone: status === "scored" ? "positive" : status === "skipped" ? "neutral" : "negative",
+                label: `Score status: ${status}`,
+                detail: [(0, index_ts_3.reportText)("Only scored Attempts participate in score comparison.")],
+            }),
+            (0, index_ts_3.reportStatus)({
+                tone: "neutral",
+                label: `Historical verdict claim: ${verdict.value}`,
+            }),
+        ];
+    }
+    return [(0, index_ts_3.reportStatus)({
+            tone: verdictTone(verdict.value),
+            label: `Verdict: ${verdict.value}`,
+            detail: [(0, index_ts_3.reportText)("Four-state Verdict: passed, failed, errored, or skipped.")],
+        })];
+}
+function verdictTone(value) {
+    switch (value) {
+        case "passed":
+            return "positive";
+        case "skipped":
+            return "neutral";
+        case "failed":
+        case "errored":
+            return "negative";
+    }
+}
+function assertionBlocks(assertions) {
+    if (assertions === undefined)
+        return [projectionAlignmentStatus("Assertions")];
+    if (assertions.state !== "available")
+        return [attachmentStatus("Assertions", assertions)];
+    const entries = assertions.value.entries;
+    const visible = entries.slice(0, ASSERTION_ROWS_MAX);
+    const omitted = entries.length - visible.length;
+    return [
+        (0, index_ts_3.reportMetric)({ label: "Recorded Assertions", value: entries.length }),
+        (0, index_ts_3.reportTable)({
+            caption: "Assertion summary",
+            columns: [
+                { key: "result", label: "Result" },
+                { key: "assertions", label: "Assertions", align: "end" },
+            ],
+            rows: assertionResultStates.map((state) => ({
+                result: state,
+                assertions: entries.filter((entry) => entry.entry.result.state === state).length,
+            })),
+        }),
+        ...(entries.length === 0
+            ? [(0, index_ts_3.reportStatus)({ tone: "neutral", label: "No recorded Assertions" })]
+            : [(0, index_ts_3.reportTable)({
+                    caption: "Assertions",
+                    columns: [
+                        { key: "assertion", label: "Assertion" },
+                        { key: "result", label: "Result" },
+                        { key: "gate", label: "Gate" },
+                        { key: "score", label: "Score" },
+                        { key: "entry", label: "Entry" },
+                        { key: "reason", label: "Reason" },
+                    ],
+                    rows: visible.map(assertionRow),
+                })]),
+        ...(omitted === 0
+            ? []
+            : [(0, index_ts_3.reportStatus)({
+                    tone: "warning",
+                    label: `${omitted} additional Assertion(s) omitted from this bounded table`,
+                })]),
+    ];
+}
+function assertionRow(entry) {
+    return {
+        assertion: assertionLabel(entry),
+        result: entry.entry.result.state,
+        gate: entry.entry.result.gate,
+        score: assertionScoreLabel(entry.entry.result),
+        entry: assertionEntryState(entry),
+        reason: assertionReason(entry.entry.result),
+    };
+}
+function assertionLabel(entry) {
+    const display = entry.entry.display;
+    const label = display.label ?? display.key ?? entry.entry.entryId;
+    return display.groupPath.length === 0 ? label : `${display.groupPath.join(" / ")} / ${label}`;
+}
+function assertionScoreLabel(result) {
+    switch (result.score.state) {
+        case "not-scored":
+            return "not scored";
+        case "earned":
+            return `${result.score.earned} / ${result.score.points}`;
+        case "unavailable":
+            return `unavailable: ${result.score.reason}`;
+    }
+}
+function assertionEntryState(entry) {
+    return entry.state === "available" ? "available" : `${entry.state}: ${entry.reason}`;
+}
+function assertionReason(result) {
+    return result.state === "matched" ? "—" : result.reason;
+}
+function scoreBlocks(score, evaluationKind) {
+    if (evaluationKind === "pass") {
+        return [
+            (0, index_ts_3.reportStatus)({
+                tone: "neutral",
+                label: "Score: not applicable for a pass evaluation",
+            }),
+            ...(score === undefined
+                ? [projectionAlignmentStatus("Score")]
+                : score.state === "available"
+                    ? scoreValueBlocks(score.value)
+                    : [attachmentStatus("Score Attachment", score)]),
+        ];
+    }
+    if (evaluationKind === "score") {
+        if (score === undefined)
+            return [projectionAlignmentStatus("Score")];
+        return score.state === "available"
+            ? scoreValueBlocks(score.value)
+            : [attachmentStatus("Score", score)];
+    }
+    return [
+        (0, index_ts_3.reportStatus)({
+            tone: "warning",
+            label: "Score applicability is unknown because Evaluation kind is unavailable",
+        }),
+        ...(score === undefined
+            ? [projectionAlignmentStatus("Score")]
+            : score.state === "available"
+                ? scoreValueBlocks(score.value)
+                : [attachmentStatus("Score", score)]),
+    ];
+}
+function scoreValueBlocks(score) {
+    switch (score.state) {
+        case "complete":
+            return [(0, index_ts_3.reportStatus)({
+                    tone: "positive",
+                    label: `Score: ${score.earned}`,
+                })];
+        case "partial":
+            return [(0, index_ts_3.reportStatus)({
+                    tone: "warning",
+                    label: `Score: partial (${score.earned}; not comparable)`,
+                    detail: [(0, index_ts_3.reportText)(`Reasons: ${score.reasons.join(", ")}`)],
+                })];
+        case "unavailable":
+            return [(0, index_ts_3.reportStatus)({
+                    tone: "warning",
+                    label: "Score: unavailable",
+                    detail: [(0, index_ts_3.reportText)(`Reasons: ${score.reasons.join(", ")}`)],
+                })];
+    }
+}
+function projectionAlignmentStatus(name) {
+    return (0, index_ts_3.reportStatus)({
+        tone: "negative",
+        label: `${name}: projection alignment unavailable`,
+    });
+}
+function attachmentStatus(name, result) {
+    switch (result.state) {
+        case "unavailable":
+            return (0, index_ts_3.reportStatus)({ tone: "warning", label: `${name}: unavailable` });
+        case "migration-required":
+            return (0, index_ts_3.reportStatus)({
+                tone: "warning",
+                label: `${name}: migration required`,
+                detail: [(0, index_ts_3.reportText)(`${result.from} → ${result.to}; ${result.command}`)],
+            });
+        case "migration-unavailable":
+            return (0, index_ts_3.reportStatus)({
+                tone: "warning",
+                label: `${name}: migration unavailable`,
+                detail: [(0, index_ts_3.reportText)(result.reason)],
+            });
+        case "unsupported":
+            return (0, index_ts_3.reportStatus)({
+                tone: "warning",
+                label: `${name}: unsupported`,
+                detail: [(0, index_ts_3.reportText)(result.schemaId)],
+            });
+        case "invalid":
+            return (0, index_ts_3.reportStatus)({
+                tone: "negative",
+                label: `${name}: invalid`,
+                detail: [(0, index_ts_3.reportText)(result.issues.map((issue) => issue.code).join(", "))],
+            });
+    }
+}
+//# sourceMappingURL=attempt-overview.cjs.map