niceeval 0.5.4 → 0.6.1

package/src/view/view-report.test.ts

@@ -1,24 +1,32 @@
-// niceeval view 的 --report 报告槽与宿主组合语义(docs/reports.md「宿主输入的组合语义」
+// niceeval view 的报告槽与宿主组合语义(docs/feature/reports/architecture.md「Selection 是计算入口」
 // 与裁决记录 6;公开行为准绳 docs-site/zh/guides/viewing-results.mdx / custom-reports.mdx)。
 // 覆盖:
-// - 组合语义与 show 对齐:位置前缀收窄报告槽选集、--experiment 过滤、匹配不到直说;
+// - 组合语义与 show 对齐:位置前缀收窄报告槽 Selection、--experiment 过滤、匹配不到直说;
 // - 单文件模式共存:存在的文件路径 → 单文件模式,目录报错直说走 --run,其余按 eval 前缀;
-// - 报告槽整槽替换:报告 HTML(含 <Style> 产物与证据室深链)烘进静态块,证据室数据原样保留;
-// - --out 静态导出:index.html 含报告块与官方样式,报告 HTML 零 <script>;
+// - 报告槽恒在:裸跑填充 ExperimentComparison,--report 整槽替换;en / zh-CN 双语各渲染一遍;
+//   裸跑 ≡ --report <re-export ExperimentComparison 的文件>(等价性);
+// - --out 静态导出:index.html 含两个语言的报告块、官方样式与增强 runtime,报告块零 <script>;
 // - dev server 装载语义:报告文件变更 → 下次装载整页重算(mtime cache-busting)。
+//
+// fixture 直接写新布局(<expDir>/<snapDir>/snapshot.json + <evalId>/a<n>/result.json),
+// 依据是 docs/feature/results/architecture.md 的稳定磁盘契约,不经 writer 运行时 API。
 
 import { mkdir, mkdtemp, readFile, rm, utimes, writeFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
-import { ReportLoadError } from "../report/load.ts";
+// dist-sourced: this must be the exact class loadViewScan()/data.ts's loadReportFile() throws
+// (see src/view/data.ts's comment) — a raw-src import would be a structurally-identical but
+// `instanceof`-incompatible class.
+import { ReportLoadError } from "../../dist/report/load.js";
 import { ViewInputError, loadViewScan } from "./data.ts";
 import { buildView, resolveViewInput } from "./index.ts";
 import { runShow } from "../show/index.ts";
-import { RESULTS_FORMAT, RESULTS_SCHEMA_VERSION, type EvalResult, type RunSummary } from "../types.ts";
+import { RESULTS_FORMAT, RESULTS_SCHEMA_VERSION, type EvalResult, type Verdict } from "../types.ts";
 
 const EXAM_REPORT = resolve(__dirname, "../../test/fixtures/report/exam-report.tsx");
+const DEFAULT_REPORT_REEXPORT = resolve(__dirname, "../../test/fixtures/report/default-report-reexport.tsx");
 
 const roots: string[] = [];
 async function makeRoot(): Promise<string> {
@@ -30,66 +38,58 @@ afterEach(async () => {
   await Promise.all(roots.splice(0).map((r) => rm(r, { recursive: true, force: true })));
 });
 
-function res(over: Partial<EvalResult> & Pick<EvalResult, "id">): EvalResult {
-  return { agent: "bub", outcome: "passed", attempt: 0, durationMs: 1000, assertions: [], ...over };
+type AttemptFixture = Pick<EvalResult, "id" | "verdict"> & Partial<Pick<EvalResult, "attempt" | "durationMs" | "assertions">>;
+
+function res(id: string, verdict: Verdict, extra: Partial<AttemptFixture> = {}): AttemptFixture {
+  return { id, verdict, attempt: 0, durationMs: 1000, assertions: [], ...extra };
+}
+
+interface SnapshotOpts {
+  experimentId: string;
+  agent?: string;
+  startedAt: string;
 }
 
-function summaryOf(results: EvalResult[], over: Partial<RunSummary> = {}): RunSummary {
-  const count = (o: EvalResult["outcome"]) => results.filter((r) => r.outcome === o).length;
-  return {
+/** 写一份新布局快照:snapshot.json + 各 attempt 的 result.json。返回快照目录绝对路径。 */
+async function writeSnapshot(
+  root: string,
+  expDirName: string,
+  snapDirName: string,
+  opts: SnapshotOpts,
+  results: AttemptFixture[],
+): Promise<string> {
+  const dir = join(root, expDirName, snapDirName);
+  await mkdir(dir, { recursive: true });
+  const meta = {
     format: RESULTS_FORMAT,
     schemaVersion: RESULTS_SCHEMA_VERSION,
     producer: { name: "niceeval", version: "0.4.6" },
-    agent: results[0]?.agent ?? "bub",
-    startedAt: "2026-07-08T10:00:00.000Z",
-    completedAt: "2026-07-08T10:10:00.000Z",
-    passed: count("passed"),
-    failed: count("failed"),
-    skipped: count("skipped"),
-    errored: count("errored"),
-    durationMs: 60_000,
-    results,
-    ...over,
+    experimentId: opts.experimentId,
+    agent: opts.agent ?? "bub",
+    startedAt: opts.startedAt,
+    completedAt: opts.startedAt,
   };
-}
-
-async function writeRun(root: string, dirName: string, summary: RunSummary): Promise<string> {
-  const dir = join(root, dirName);
-  await mkdir(dir, { recursive: true });
-  await writeFile(join(dir, "summary.json"), JSON.stringify(summary, null, 2), "utf-8");
+  await writeFile(join(dir, "snapshot.json"), JSON.stringify(meta, null, 2), "utf-8");
+  for (const r of results) {
+    const attemptDir = join(dir, r.id, `a${r.attempt ?? 0}`);
+    await mkdir(attemptDir, { recursive: true });
+    await writeFile(join(attemptDir, "result.json"), JSON.stringify(r, null, 2), "utf-8");
+  }
   return dir;
 }
 
 /** 两个实验、weather 通过 + button 失败:报告槽/证据室/深链断言都要用到失败案例。 */
 async function seedRoot(): Promise<string> {
   const root = await makeRoot();
-  await writeRun(
-    root,
-    "2026-07-08T10-00-00-000Z",
-    summaryOf(
-      [
-        res({ id: "weather/brooklyn", experimentId: "compare/bub", startedAt: "2026-07-08T10:00:01.000Z" }),
-        res({
-          id: "fixtures/button",
-          experimentId: "compare/bub",
-          outcome: "failed",
-          startedAt: "2026-07-08T10:00:02.000Z",
-          assertions: [
-            { name: 'fileChanged("Button.tsx")', severity: "gate", score: 0, passed: false },
-          ],
-        }),
-      ],
-      { startedAt: "2026-07-08T10:00:00.000Z" },
-    ),
-  );
-  await writeRun(
-    root,
-    "2026-07-09T10-00-00-000Z",
-    summaryOf(
-      [res({ id: "weather/brooklyn", experimentId: "compare/codex", agent: "codex", startedAt: "2026-07-09T10:00:01.000Z" })],
-      { agent: "codex", startedAt: "2026-07-09T10:00:00.000Z" },
-    ),
-  );
+  await writeSnapshot(root, "compare_bub", "2026-07-08T10-00-00-000Z", { experimentId: "compare/bub", agent: "bub", startedAt: "2026-07-08T10:00:00.000Z" }, [
+    res("weather/brooklyn", "passed"),
+    res("fixtures/button", "failed", {
+      assertions: [{ name: 'fileChanged("Button.tsx")', severity: "gate", score: 0, passed: false }],
+    }),
+  ]);
+  await writeSnapshot(root, "compare_codex", "2026-07-09T10-00-00-000Z", { experimentId: "compare/codex", agent: "codex", startedAt: "2026-07-09T10:00:00.000Z" }, [
+    res("weather/brooklyn", "passed"),
+  ]);
   return root;
 }
 
@@ -98,7 +98,7 @@ async function seedRoot(): Promise<string> {
 describe("resolveViewInput · 位置参数语义", () => {
   it("存在的文件路径 → 单文件模式;其余位置参数按 eval id 前缀", async () => {
     const root = await seedRoot();
-    const file = join(root, "2026-07-08T10-00-00-000Z", "summary.json");
+    const file = join(root, "compare_bub", "2026-07-08T10-00-00-000Z", "snapshot.json");
     expect(resolveViewInput(root, [file])).toEqual({ input: file, patterns: [] });
     expect(resolveViewInput(root, ["weather", "fixtures/button"])).toEqual({
       patterns: ["weather", "fixtures/button"],
@@ -108,13 +108,13 @@ describe("resolveViewInput · 位置参数语义", () => {
 
   it("目录位置参数:报错直说走 --run(位置参数留给 eval id 前缀)", async () => {
     const root = await seedRoot();
-    expect(() => resolveViewInput(root, ["2026-07-08T10-00-00-000Z"])).toThrow(ViewInputError);
-    expect(() => resolveViewInput(root, ["2026-07-08T10-00-00-000Z"])).toThrow(/--run/);
+    expect(() => resolveViewInput(root, ["compare_bub"])).toThrow(ViewInputError);
+    expect(() => resolveViewInput(root, ["compare_bub"])).toThrow(/--run/);
   });
 
   it("单文件模式不与其它位置参数或 --run 混用,歧义报错直说", async () => {
     const root = await seedRoot();
-    const file = join(root, "2026-07-08T10-00-00-000Z", "summary.json");
+    const file = join(root, "compare_bub", "2026-07-08T10-00-00-000Z", "snapshot.json");
     expect(() => resolveViewInput(root, [file, "weather"])).toThrow(/exactly one path/);
     expect(() => resolveViewInput(root, [file], root)).toThrow(/--run/);
   });
@@ -133,24 +133,23 @@ describe("resolveViewInput · 位置参数语义", () => {
 // ───────────────────────── 组合语义(与 show 对齐) ─────────────────────────
 
 describe("loadViewScan · 组合语义", () => {
-  it("位置前缀收窄报告槽选集(榜单/overview);证据室快照不收窄,深链恒可达", async () => {
+  it("位置前缀收窄报告槽 Selection;证据室快照不收窄,深链恒可达", async () => {
     const root = await seedRoot();
-    const { viewData } = await loadViewScan(root, { patterns: ["weather"] });
-    // 报告槽:两实验都只剩 weather/brooklyn 一题,全过。
-    expect(viewData.overview.totals.evals).toBe(1);
-    expect(viewData.overview.totals.attempts).toBe(2); // 2 个实验各 1 attempt
-    for (const row of viewData.table.rows) {
-      expect(row.cells["pass-rate"]!.value).toBe(1);
-    }
+    const { viewData, reportHtml } = await loadViewScan(root, { patterns: ["weather"] });
+    // 报告槽:两实验都只剩 weather/brooklyn 一题,范围外的失败不再出现。
+    expect(reportHtml.en).toContain("compare/bub");
+    expect(reportHtml.en).toContain("compare/codex");
+    expect(reportHtml.en).not.toContain("fixtures/button");
     // 证据室:快照明细仍含 fixtures/button(attempt 深链在收窄下也能解析)。
     const allIds = viewData.snapshots.flatMap((s) => s.results.map((r) => r.id));
     expect(allIds).toContain("fixtures/button");
   });
 
-  it("--experiment 过滤:选集只留该实验", async () => {
+  it("--experiment 过滤:报告槽 Selection 只留该实验", async () => {
     const root = await seedRoot();
-    const { viewData } = await loadViewScan(root, { experiment: "compare/codex" });
-    expect(viewData.table.rows.map((r) => r.key)).toEqual(["compare/codex"]);
+    const { reportHtml } = await loadViewScan(root, { experiment: "compare/codex" });
+    expect(reportHtml.en).toContain("compare/codex");
+    expect(reportHtml.en).not.toContain("compare/bub");
   });
 
   it("前缀/实验匹配不到:直说,不渲染空页面", async () => {
@@ -160,11 +159,51 @@ describe("loadViewScan · 组合语义", () => {
     await expect(loadViewScan(root, { experiment: "nosuch" })).rejects.toBeInstanceOf(ViewInputError);
   });
 
-  it("全部缺省:默认行为不变(results.latest() 口径,不走合成)", async () => {
+  it("全部缺省:报告槽使用现刻水位口径(与 show 相同的合成规则)", async () => {
+    const root = await seedRoot();
+    const { reportHtml } = await loadViewScan(root);
+    // 默认报告的榜单含两个实验;官方组件的稳定类名在场。
+    expect(reportHtml.en).toContain("compare/bub");
+    expect(reportHtml.en).toContain("compare/codex");
+    expect(reportHtml.en).toContain("nre-");
+  });
+});
+
+// ─────────────────── 报告槽恒在:裸跑 ≡ --report <ExperimentComparison> ───────────────────
+
+describe("loadViewScan · 默认报告槽(裸跑)", () => {
+  it("裸跑产出的报告槽 HTML 与 --report <re-export ExperimentComparison 的文件> 完全一致(双语)", async () => {
+    const root = await seedRoot();
+    const bare = await loadViewScan(root);
+    const viaReport = await loadViewScan(root, {
+      report: { path: DEFAULT_REPORT_REEXPORT, cwd: root },
+    });
+    expect(bare.reportHtml.en).toBe(viaReport.reportHtml.en);
+    expect(bare.reportHtml["zh-CN"]).toBe(viaReport.reportHtml["zh-CN"]);
+  });
+
+  it("报告槽双语渲染:同一棵树按 locale 渲染两遍,chrome 文案分语言、数据不分语言", async () => {
+    const root = await seedRoot();
+    const { reportHtml } = await loadViewScan(root);
+    expect(reportHtml.en).toContain("Pass rate"); // ExperimentList 主行(en)
+    expect(reportHtml["zh-CN"]).toContain("成功率"); // ExperimentList 主行(zh-CN,passRate 的 zh label)
+    for (const html of [reportHtml.en, reportHtml["zh-CN"]]) {
+      expect(html).toContain("compare/bub");
+      // 失败案例深链进证据室:不透明 AttemptLocator 单段路由 `#/attempt/@<locator>`,
+      // 不再是旧的两段式 `#/attempt/<snapshot>/<attempt>`。
+      expect(html).toMatch(/href="#\/attempt\/@[0-9a-z]+"/);
+      expect(html).not.toContain("<script"); // 报告槽产物零客户端 JS,不 hydrate
+    }
+  });
+
+  it("失败清单与警告住在报告槽里:ExperimentList 列出失败,壳的 viewData 不携带统计产物", async () => {
     const root = await seedRoot();
     const { viewData, reportHtml } = await loadViewScan(root);
-    expect(reportHtml).toBeUndefined();
-    expect(viewData.table.rows.map((r) => r.key).sort()).toEqual(["compare/bub", "compare/codex"]);
+    expect(reportHtml.en).toContain("fixtures/button");
+    // viewData 只有证据室数据:快照 + skipped + 壳元信息。
+    expect(viewData).not.toHaveProperty("overview");
+    expect(viewData).not.toHaveProperty("table");
+    expect(viewData).not.toHaveProperty("overall");
   });
 });
 
@@ -174,31 +213,33 @@ describe("loadViewScan · --report 报告槽", () => {
   it("报告树渲染为静态 HTML:官方水位 + 自定义摆法 + <Style> 产物 + 证据室深链,零 <script>", async () => {
     const root = await seedRoot();
     const scan = await loadViewScan(root, { report: { path: EXAM_REPORT, cwd: root } });
-    const html = scan.reportHtml!;
+    const html = scan.reportHtml.en;
     expect(html).toContain("考试成绩单"); // 自定义 Section
     expect(html).toContain("nre-"); // 官方组件的稳定类名
     expect(html).toContain("<style>.exam-note { color: #4a7; }</style>"); // <Style> 随树带走
-    expect(html).toContain("#/attempt/2026-07-08T10-00-00-000Z/"); // 失败案例深链进证据室
+    expect(html).toMatch(/href="#\/attempt\/@[0-9a-z]+"/); // 失败案例深链进证据室(单段 locator 路由)
     expect(html).not.toContain("<script"); // 报告槽产物零客户端 JS,不 hydrate
-    // 证据室数据契约(__NICEEVAL_VIEW_DATA__)原样保留:快照、attemptRef、skipped 不动。
+    // 用户报告同样双语渲染两遍(壳按界面语言摆放)。
+    expect(scan.reportHtml["zh-CN"]).toContain("考试成绩单");
+    // 证据室数据契约(__NICEEVAL_VIEW_DATA__)原样保留:快照、locator、skipped 不动。
     expect(scan.viewData.snapshots.length).toBeGreaterThan(0);
-    expect(scan.viewData.snapshots.flatMap((s) => s.results).every((r) => r.attemptRef)).toBe(true);
+    expect(scan.viewData.snapshots.flatMap((s) => s.results).every((r) => r.locator)).toBe(true);
     expect(JSON.stringify(scan.viewData)).not.toContain("考试成绩单"); // 报告块不进 viewData
   });
 
-  it("位置前缀对 --report 生效:收窄注入选集,报告只见范围内的 eval", async () => {
+  it("位置前缀对 --report 生效:收窄注入 Selection,报告只见范围内的 eval", async () => {
     const root = await seedRoot();
     const scan = await loadViewScan(root, {
       patterns: ["weather"],
       report: { path: EXAM_REPORT, cwd: root },
     });
     // 范围外的失败(fixtures/button)不再出现在报告里;范围内的实验行都在。
-    expect(scan.reportHtml).not.toContain("fixtures/button");
-    expect(scan.reportHtml).toContain("compare/bub");
-    expect(scan.reportHtml).toContain("compare/codex");
+    expect(scan.reportHtml.en).not.toContain("fixtures/button");
+    expect(scan.reportHtml.en).toContain("compare/bub");
+    expect(scan.reportHtml.en).toContain("compare/codex");
   });
 
-  it("show --report 与 view --report 吃同一个报告文件,判决口径一致", async () => {
+  it("show --report 与 view --report 吃同一个报告文件,判定口径一致", async () => {
     const root = await seedRoot();
     let text = "";
     const code = await runShow(root, [], { run: root, report: EXAM_REPORT }, {
@@ -211,7 +252,7 @@ describe("loadViewScan · --report 报告槽", () => {
     // 同一棵树的两个面:同一份失败清单与同一个自定义 Section。
     for (const needle of ["考试成绩单", "compare/bub", "compare/codex", "fixtures/button"]) {
       expect(text).toContain(needle);
-      expect(scan.reportHtml).toContain(needle);
+      expect(scan.reportHtml.en).toContain(needle);
     }
   });
 
@@ -258,51 +299,58 @@ describe("loadViewScan · 报告文件变更整页重算", () => {
     const path = join(root, "report.mjs");
     await writeFile(path, reportSource("FIRST_RENDER"), "utf-8");
     const first = await loadViewScan(root, { report: { path, cwd: root } });
-    expect(first.reportHtml).toContain("FIRST_RENDER");
+    expect(first.reportHtml.en).toContain("FIRST_RENDER");
 
     await writeFile(path, reportSource("SECOND_RENDER"), "utf-8");
     // mtime 精度兜底:显式把 mtime 拨到未来,确保与首次装载可区分。
     const future = new Date(Date.now() + 5000);
     await utimes(path, future, future);
     const second = await loadViewScan(root, { report: { path, cwd: root } });
-    expect(second.reportHtml).toContain("SECOND_RENDER");
-    expect(second.reportHtml).not.toContain("FIRST_RENDER");
+    expect(second.reportHtml.en).toContain("SECOND_RENDER");
+    expect(second.reportHtml.en).not.toContain("FIRST_RENDER");
   });
 });
 
 // ───────────────────────── --out 静态导出 ─────────────────────────
 
 describe("buildView · --out 与 --report", () => {
-  it("报告页为首页报告槽,证据室同站:index.html 含报告块与官方样式,工件照常复制", async () => {
+  it("报告页为首页报告槽,证据室同站:index.html 含报告块与官方样式,artifact 照常复制", async () => {
     const root = await seedRoot();
-    // 给 weather attempt 一份 events 工件,验证证据室工件照常进导出。
-    const artifactDir = join(root, "2026-07-09T10-00-00-000Z", "artifacts", "weather");
+    // 给 weather attempt 一份 events artifact,验证证据室 artifact 照常进导出。
+    // 本快照跑出的条目:artifact 目录 = <snapshot.dir>/<evalId>/a<n>,不需要声明字段。
+    const artifactDir = join(root, "compare_codex", "2026-07-09T10-00-00-000Z", "weather", "brooklyn", "a0");
     await mkdir(artifactDir, { recursive: true });
     await writeFile(join(artifactDir, "events.json"), "[]", "utf-8");
-    const summaryPath = join(root, "2026-07-09T10-00-00-000Z", "summary.json");
-    const summary = JSON.parse(await readFile(summaryPath, "utf-8")) as RunSummary;
-    summary.results[0]!.artifactsDir = "artifacts/weather";
-    await writeFile(summaryPath, JSON.stringify(summary), "utf-8");
 
     const out = join(root, "site");
     await buildView({ input: root, out, scan: { report: { path: EXAM_REPORT, cwd: root } } });
 
     const html = await readFile(join(out, "index.html"), "utf-8");
-    expect(html).toContain('<template id="niceeval-report">');
+    // 双语两个 <template> 静态块都在,壳按界面语言摆放。
+    expect(html).toContain('<template id="niceeval-report-en">');
+    expect(html).toContain('<template id="niceeval-report-zh-CN">');
     expect(html).toContain("考试成绩单");
     expect(html).toContain("nre-"); // 官方组件样式(report/react/styles.css)随页注入
     // 报告块本体零 <script>:静态块起于 <template>,内部只有标记与 <style>。
-    const block = html.split('<template id="niceeval-report">')[1]!.split("</template>")[0]!;
+    const block = html.split('<template id="niceeval-report-en">')[1]!.split("</template>")[0]!;
     expect(block).not.toContain("<script");
-    // 证据室同站:工件按 /artifact/<base>/ 布局复制。
-    expect(existsSync(join(out, "artifact", "2026-07-09T10-00-00-000Z/artifacts/weather", "events.json"))).toBe(true);
+    // 证据室同站: artifact 按 /artifact/<base>/ 布局复制。
+    expect(
+      existsSync(join(out, "artifact", "compare_codex/2026-07-09T10-00-00-000Z/weather/brooklyn/a0", "events.json")),
+    ).toBe(true);
   });
 
-  it("默认导出(无 --report)不含报告块,行为不变", async () => {
+  it("默认导出(无 --report):报告槽填充 ExperimentComparison,双语块与增强 runtime 恒内联", async () => {
     const root = await seedRoot();
     const out = join(root, "site");
     await buildView({ input: root, out });
     const html = await readFile(join(out, "index.html"), "utf-8");
-    expect(html).not.toContain('<template id="niceeval-report">');
+    expect(html).toContain('<template id="niceeval-report-en">');
+    expect(html).toContain('<template id="niceeval-report-zh-CN">');
+    expect(html).toContain("nre-"); // 官方组件的稳定类名(KPI / 榜单 / 散点来自 nre 组件)
+    // 渐进增强 runtime(排序 / 过滤 / tooltip)恒内联;报告块本体仍零 <script>。
+    expect(html).toContain("__nreEnhanced");
+    const block = html.split('<template id="niceeval-report-en">')[1]!.split("</template>")[0]!;
+    expect(block).not.toContain("<script");
   });
 });

package/src/report/default-report.tsx

@@ -1,222 +0,0 @@
-// DefaultReport:官方水位整块 —— 官方两扇门裸跑时渲染的就是它,零 props、纯声明。
-// 「渲染面纯同步」与它不冲突,靠的是一个数据事实:官方水位(overview、榜单、失败清单)
-// 只读瘦身条目、不碰任何懒加载工件,宿主对着已挑好的选集总是把这份数据备好、经上下文
-// 注入(renderReportToText / renderReportToStaticHtml 里 prepareDefaultReportData)。
-// 它渲染的口径钉死为宿主注入的那份选集 —— 零 props 意味着没有跟随的通道,这是锚点语义:
-// 官方口径与自定义口径并排对照。默认无特权:数据全部来自公开计算函数。
-//
-// text 面即 `niceeval show` 的榜单(docs-site/zh/guides/viewing-results.mdx 的示例块是
-// 行为规范):`Current verdicts` 头标注合成自几个 run、experiment 表带 eval 级折叠的
-// evals 列、Failing 清单每条带判决时间与下钻命令。
-
-import { basename } from "node:path";
-import type { Selection } from "../results/index.ts";
-import { foldEvalOutcome } from "../shared/outcome.ts";
-import { defineComponent } from "./tree.ts";
-import type { CaseListData, OverviewData, TableData } from "./types.ts";
-import { caseListData, overviewData, tableData } from "./compute.ts";
-import { attemptCostUSD, costUSD, durationMs, passRate } from "./metrics.ts";
-import { RunOverview, MetricTable, CaseList } from "./components.tsx";
-import { cellText } from "./text/faces.ts";
-import { renderAlignedRows } from "./text/layout.ts";
-
-/** 榜单的合成标注与 eval 级折叠(text 面用;与 verdicts/cases 出自同一选集)。 */
-export interface VerdictBoardData {
-  /** 判决合成自几个物理 run。 */
-  composedFromRuns: number;
-  /** 参与合成的最新 run(目录名,即时间戳)。 */
-  latestRun?: string;
-  /** experiment → eval 级折叠计票(evals 列的 13/15)。 */
-  tallies: Record<string, { passedEvals: number; totalEvals: number }>;
-  /** eval 级折叠后失败/出错的题,带判决时间;新失败在前。 */
-  failing: {
-    evalId: string;
-    experimentId: string;
-    outcome: "failed" | "errored";
-    /** 最新 attempt 的第一条失败断言("gate calledTool(...)")或错误摘要。 */
-    reason?: string;
-    /** 判决产生的时刻(最新 attempt 的 startedAt,缺失退快照时刻)。 */
-    verdictAt?: string;
-  }[];
-  /** limit 之外还有几条,如实报。 */
-  failingTruncated: number;
-}
-
-export interface DefaultReportData {
-  overview: OverviewData;
-  /** 现刻榜单:experiment × (passRate, costUSD, durationMs)。 */
-  verdicts: TableData;
-  cases: CaseListData;
-  board: VerdictBoardData;
-}
-
-/** 失败清单的出厂截断;完整清单自己摆 <CaseList>(截断如实报剩余)。 */
-const DEFAULT_CASE_LIMIT = 10;
-
-function buildBoard(selection: Selection): VerdictBoardData {
-  const tallies: VerdictBoardData["tallies"] = {};
-  const failing: VerdictBoardData["failing"] = [];
-  const runs = new Set<string>();
-  let latestRunDir = "";
-
-  for (const snapshot of selection.snapshots) {
-    let passedEvals = 0;
-    for (const ev of snapshot.evals) {
-      for (const attempt of ev.attempts) {
-        runs.add(attempt.runDir.dir);
-        if (attempt.runDir.dir > latestRunDir) latestRunDir = attempt.runDir.dir;
-      }
-      const outcome = foldEvalOutcome(ev.attempts.map((a) => a.result));
-      if (outcome === "passed") {
-        passedEvals += 1;
-        continue;
-      }
-      if (outcome !== "failed" && outcome !== "errored") continue;
-      const latest = ev.attempts.reduce((a, b) => (b.result.attempt >= a.result.attempt ? b : a));
-      const failedAssertion = latest.result.assertions.find((a) => !a.passed);
-      const reason = failedAssertion
-        ? `${failedAssertion.severity} ${failedAssertion.name}`
-        : latest.result.error !== undefined
-          ? `error: ${latest.result.error}`
-          : undefined;
-      failing.push({
-        evalId: ev.id,
-        experimentId: snapshot.experimentId,
-        outcome,
-        ...(reason !== undefined ? { reason } : {}),
-        ...(latest.result.startedAt !== undefined || snapshot.startedAt
-          ? { verdictAt: latest.result.startedAt ?? snapshot.startedAt }
-          : {}),
-      });
-    }
-    tallies[snapshot.experimentId] = { passedEvals, totalEvals: snapshot.evals.length };
-  }
-
-  failing.sort((a, b) => (b.verdictAt ?? "").localeCompare(a.verdictAt ?? ""));
-  const shown = failing.slice(0, DEFAULT_CASE_LIMIT);
-  return {
-    composedFromRuns: runs.size,
-    ...(latestRunDir ? { latestRun: basename(latestRunDir) } : {}),
-    tallies,
-    failing: shown,
-    failingTruncated: failing.length - shown.length,
-  };
-}
-
-/** 宿主渲染前备好官方水位:只读瘦身条目,代价可忽略。 */
-export async function prepareDefaultReportData(selection: Selection): Promise<DefaultReportData> {
-  return {
-    overview: await overviewData(selection),
-    verdicts: await tableData(selection, {
-      rows: "experiment",
-      columns: [passRate, costUSD, durationMs],
-      sort: passRate,
-    }),
-    cases: await caseListData(selection, { limit: DEFAULT_CASE_LIMIT }),
-    board: buildBoard(selection),
-  };
-}
-
-let activeData: DefaultReportData | null = null;
-
-/** 宿主(与渲染入口)用:在注入好的官方水位下同步渲染。 */
-export function runWithDefaultReportData<T>(data: DefaultReportData, fn: () => T): T {
-  const prev = activeData;
-  activeData = data;
-  try {
-    return fn();
-  } finally {
-    activeData = prev;
-  }
-}
-
-function requireData(): DefaultReportData {
-  if (!activeData) {
-    throw new Error(
-      "<DefaultReport /> renders the host-injected selection; render the report via " +
-        "`niceeval show --report` / `niceeval view --report` (or renderReportToText / renderReportToStaticHtml). " +
-        "Outside a host, compose the same blocks yourself: RunOverview, MetricTable, CaseList.",
-    );
-  }
-  return activeData;
-}
-
-/** 判决时间的相对标注(text 面的 "41s ago";渲染面纯同步,Date.now 不算 IO)。 */
-function agoText(iso: string | undefined, now: number): string {
-  if (!iso) return "";
-  const ms = now - Date.parse(iso);
-  if (!Number.isFinite(ms) || ms < 10_000) return "just now";
-  const seconds = Math.floor(ms / 1000);
-  if (seconds < 120) return `${seconds}s ago`;
-  const minutes = Math.floor(seconds / 60);
-  if (minutes < 120) return `${minutes}m ago`;
-  const hours = Math.floor(minutes / 60);
-  if (hours < 48) return `${hours}h ago`;
-  return `${Math.floor(hours / 24)}d ago`;
-}
-
-/** show 榜单(viewing-results.mdx「榜单」块):头 + experiment 表 + Failing 清单。 */
-function boardText(data: DefaultReportData): string {
-  const { verdicts, board, overview } = data;
-  const experiments = verdicts.rows.length;
-  const head = [
-    "Current verdicts",
-    `${experiments} ${experiments === 1 ? "experiment" : "experiments"}`,
-    `composed from ${board.composedFromRuns} ${board.composedFromRuns === 1 ? "run" : "runs"}`,
-    ...(board.latestRun ? [`latest ${board.latestRun}`] : []),
-  ].join(" · ");
-  const headBlock = [head, ...overview.warnings.map((w) => `! ${w.message}`)].join("\n");
-
-  // 表:experiment | evals(eval 级折叠计票)| pass | cost | duration(顺序随 verdicts 预排)
-  const header = [verdicts.dimension, "evals", "pass", "cost", "duration"];
-  const rows = verdicts.rows.map((row) => {
-    const tally = board.tallies[row.key];
-    const cells = row.cells as Record<string, TableData["rows"][number]["cells"][string]>;
-    return [
-      row.key,
-      tally ? `${tally.passedEvals}/${tally.totalEvals}` : "—",
-      cells[passRate.name] ? cellText(cells[passRate.name]) : "—",
-      cells[costUSD.name] ? cellText(cells[costUSD.name]) : "—",
-      cells[durationMs.name] ? cellText(cells[durationMs.name]) : "—",
-    ];
-  });
-  const table = renderAlignedRows([header, ...rows]);
-
-  const blocks = [headBlock, table];
-  if (board.failing.length > 0) {
-    const now = Date.now();
-    const aligned = renderAlignedRows(
-      board.failing.map((f) => [
-        `✗ ${f.evalId}`,
-        f.experimentId,
-        f.reason ?? f.outcome,
-        agoText(f.verdictAt, now),
-      ]),
-    ).split("\n");
-    const lines: string[] = ["Failing:"];
-    board.failing.forEach((f, i) => {
-      lines.push(`  ${aligned[i]}`);
-      lines.push(`      → niceeval show ${f.evalId}`);
-    });
-    if (board.failingTruncated > 0) lines.push(`  (${board.failingTruncated} more not shown)`);
-    blocks.push(lines.join("\n"));
-  }
-  return blocks.join("\n\n");
-}
-
-export const DefaultReport = defineComponent<Record<string, never>>({
-  web() {
-    const data = requireData();
-    return (
-      <div className="nre nre-default-report">
-        <RunOverview data={data.overview} />
-        <MetricTable data={data.verdicts} />
-        {data.cases.rows.length > 0 && <CaseList data={data.cases} />}
-      </div>
-    );
-  },
-  text() {
-    return boardText(requireData());
-  },
-});
-DefaultReport.displayName = "DefaultReport";