@pi-harness/pi-harness 0.1.13 → 0.1.14

package/packages/client-web/test/session-insights-view.test.ts

@@ -0,0 +1,152 @@
+import { describe, expect, test } from "vitest";
+import { sessionInsightsPanelView } from "../src/session-insights-view.js";
+
+function report(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    sessionFile: null,
+    sessionId: "session-1",
+    userMessages: 2,
+    assistantMessages: 2,
+    toolCalls: 1,
+    toolResults: 1,
+    totalMessages: 5,
+    tokens: { input: 10, output: 20, cacheRead: 3, cacheWrite: 2, total: 35 },
+    cost: 0.012_345,
+    contextUsage: { tokens: 250, contextWindow: 1_000, percent: 25 },
+    compaction: { status: "completed", requestedAt: "2026-09-06T00:00:00.000Z", startedAt: "2026-09-06T00:00:01.000Z", finishedAt: "2026-09-06T00:00:02.000Z" },
+    ...overrides,
+  };
+}
+
+describe("Session Insights panel view", () => {
+  test("normalizes a complete detached session report", () => {
+    const source = report();
+    const view = sessionInsightsPanelView(source);
+
+    expect(view).toEqual({
+      report: {
+        sessionId: "session-1",
+        userMessages: 2,
+        assistantMessages: 2,
+        toolCalls: 1,
+        toolResults: 1,
+        totalMessages: 5,
+        tokens: { input: 10, output: 20, cacheRead: 3, cacheWrite: 2, total: 35 },
+        cost: 0.012_345,
+        contextUsage: { tokens: 250, contextWindow: 1_000, percent: 25 },
+      },
+      compaction: {
+        status: "completed",
+        requestedAt: "2026-09-06T00:00:00.000Z",
+        startedAt: "2026-09-06T00:00:01.000Z",
+        finishedAt: "2026-09-06T00:00:02.000Z",
+        error: null,
+      },
+      malformed: false,
+      limits: { sessionIdCharacters: 512, errorCharacters: 2_000 },
+    });
+    (source.tokens as { total: number }).total = 999;
+    expect(view.report?.tokens.total).toBe(35);
+  });
+
+  test("preserves a temporarily unknown post-compaction context usage", () => {
+    expect(
+      sessionInsightsPanelView(
+        report({
+          contextUsage: { tokens: null, contextWindow: 1_000, percent: null },
+          compaction: { status: "idle" },
+        }),
+      ),
+    ).toMatchObject({
+      report: { contextUsage: { tokens: null, contextWindow: 1_000, percent: null } },
+      compaction: { status: "idle" },
+      malformed: false,
+    });
+    expect(sessionInsightsPanelView(report({ contextUsage: null }))).toMatchObject({ report: { contextUsage: null }, malformed: false });
+  });
+
+  test("fails closed instead of manufacturing healthy values from malformed reports", () => {
+    const malformed = [
+      null,
+      [],
+      report({ sessionId: "" }),
+      report({ totalMessages: 4 }),
+      report({ cost: Number.NaN }),
+      report({ tokens: { input: 10, output: 20, cacheRead: 3, cacheWrite: 2, total: 34 } }),
+      report({ contextUsage: { tokens: null, contextWindow: 1_000, percent: 25 } }),
+      report({ contextUsage: { tokens: 250, contextWindow: 1_000, percent: 24 } }),
+    ];
+
+    for (const value of malformed) {
+      const view = sessionInsightsPanelView(value);
+      expect(view.report).toBeNull();
+      expect(view.malformed).toBe(true);
+    }
+  });
+
+  test("does not invoke root or nested accessors", () => {
+    let accesses = 0;
+    const root = report();
+    Object.defineProperty(root, "cost", {
+      enumerable: true,
+      get() {
+        accesses += 1;
+        throw new Error("cost getter executed");
+      },
+    });
+    const nested = report();
+    Object.defineProperty(nested.tokens, "total", {
+      enumerable: true,
+      get() {
+        accesses += 1;
+        throw new Error("token getter executed");
+      },
+    });
+    const compaction = report();
+    Object.defineProperty(compaction.compaction, "status", {
+      enumerable: true,
+      get() {
+        accesses += 1;
+        throw new Error("compaction getter executed");
+      },
+    });
+    const revocable = Proxy.revocable({}, {});
+    revocable.revoke();
+
+    for (const value of [root, nested, compaction, revocable.proxy]) {
+      expect(() => sessionInsightsPanelView(value)).not.toThrow();
+      expect(sessionInsightsPanelView(value)).toMatchObject({ report: null, malformed: true });
+    }
+    expect(accesses).toBe(0);
+  });
+
+  test("marks malformed compaction state as unknown without discarding valid statistics", () => {
+    for (const state of [
+      { status: "queued" },
+      { status: "running", requestedAt: "invalid", startedAt: "2026-09-06T00:00:01.000Z" },
+      {
+        status: "completed",
+        requestedAt: "2026-09-06T00:00:02.000Z",
+        startedAt: "2026-09-06T00:00:01.000Z",
+        finishedAt: "2026-09-06T00:00:00.000Z",
+      },
+      { status: "failed", requestedAt: "2026-09-06T00:00:00.000Z", finishedAt: "2026-09-06T00:00:01.000Z", error: "x".repeat(2_001) },
+    ]) {
+      const view = sessionInsightsPanelView(report({ compaction: state }));
+      expect(view.report).not.toBeNull();
+      expect(view.compaction).toEqual({ status: "unknown", requestedAt: null, startedAt: null, finishedAt: null, error: null });
+      expect(view.malformed).toBe(true);
+    }
+  });
+
+  test("does not share fallback state between normalized views", () => {
+    const first = sessionInsightsPanelView(null);
+    (first.compaction as { status: string }).status = "completed";
+    (first.limits as { errorCharacters: number }).errorCharacters = 1;
+
+    expect(sessionInsightsPanelView(null)).toMatchObject({
+      compaction: { status: "unknown" },
+      limits: { errorCharacters: 2_000 },
+    });
+  });
+});

package/packages/client-web/test/skill-guard-view.test.ts

@@ -0,0 +1,138 @@
+import { describe, expect, it } from "vitest";
+import { skillGuardPanelView } from "../src/skill-guard-view.js";
+
+describe("Skill Guard view", () => {
+  it("normalizes scan status, inventory, and reports", () => {
+    expect(
+      skillGuardPanelView({
+        scans: 2,
+        total: 2,
+        blocked: 1,
+        review: 1,
+        reports: [
+          {
+            name: "unsafe",
+            risk: "blocked",
+            score: 5,
+            findings: [{ code: "instruction_override", severity: "high", message: "Override detected" }],
+            path: "/workspace/.agents/skills/unsafe/SKILL.md",
+            source: "project",
+            scannedBytes: 512,
+          },
+        ],
+        status: { state: "completed", at: "2026-09-05T12:00:00.000Z" },
+        inventory: { available: 2, scanned: 2, shown: 1, truncated: false, scanTruncated: false, displayTruncated: false },
+        limits: {
+          queryCharacters: 120,
+          skillBytes: 131_072,
+          skills: 50,
+          panelReports: 20,
+          nameCharacters: 64,
+          sourceCharacters: 128,
+          pathCharacters: 4_096,
+          statusErrorCharacters: 2_000,
+          findingsPerSkill: 6,
+          findingCodeCharacters: 64,
+          findingMessageCharacters: 256,
+          score: 28,
+        },
+      }),
+    ).toMatchObject({
+      scans: 2,
+      total: 2,
+      blocked: 1,
+      review: 1,
+      reports: [
+        {
+          name: "unsafe",
+          risk: "blocked",
+          score: 5,
+          findings: [{ code: "instruction_override", severity: "high", message: "Override detected" }],
+          path: "/workspace/.agents/skills/unsafe/SKILL.md",
+          source: "project",
+          scannedBytes: 512,
+        },
+      ],
+      status: { state: "completed", at: "2026-09-05T12:00:00.000Z", error: null },
+      inventory: { available: 2, scanned: 2, shown: 1, truncated: false },
+      limits: { skills: 50, panelReports: 20, findingsPerSkill: 6, score: 28 },
+    });
+  });
+
+  it("enforces fixed browser caps on hostile nested data", () => {
+    const long = "x".repeat(20_000);
+    const report = {
+      name: long,
+      risk: "blocked",
+      score: 9_999,
+      findings: Array.from({ length: 20 }, () => ({ code: long, severity: "high", message: long })),
+      path: long,
+      source: long,
+      scannedBytes: 9_999_999,
+    };
+    const view = skillGuardPanelView({
+      scans: Number.MAX_SAFE_INTEGER + 1,
+      total: 999,
+      blocked: 999,
+      review: 999,
+      reports: Array.from({ length: 40 }, () => report),
+      status: { state: "failed", at: "2026-09-05T12:01:00.000Z", error: long },
+      inventory: { available: 999, scanned: 999, shown: 999, truncated: true, scanTruncated: true, displayTruncated: true },
+      limits: Object.fromEntries(
+        [
+          "queryCharacters",
+          "skillBytes",
+          "skills",
+          "panelReports",
+          "nameCharacters",
+          "sourceCharacters",
+          "pathCharacters",
+          "statusErrorCharacters",
+          "findingsPerSkill",
+          "findingCodeCharacters",
+          "findingMessageCharacters",
+          "score",
+        ].map((key) => [key, 99_999_999]),
+      ),
+    });
+
+    expect(view.scans).toBe(0);
+    expect(view.total).toBe(0);
+    expect(view.blocked).toBe(0);
+    expect(view.review).toBe(0);
+    expect(view.reports).toHaveLength(20);
+    expect(view.reports[0]?.name).toHaveLength(64);
+    expect(view.reports[0]?.source).toHaveLength(128);
+    expect(view.reports[0]?.path).toHaveLength(4_096);
+    expect(view.reports[0]?.score).toBe(0);
+    expect(view.reports[0]?.scannedBytes).toBe(0);
+    expect(view.reports[0]?.findings).toHaveLength(6);
+    expect(view.reports[0]?.findings[0]?.code).toHaveLength(64);
+    expect(view.reports[0]?.findings[0]?.message).toHaveLength(256);
+    expect(view.status.error).toHaveLength(2_000);
+    expect(view.inventory).toMatchObject({ available: 999, scanned: 0, shown: 0, truncated: true, scanTruncated: true, displayTruncated: true });
+    expect(view.limits).toMatchObject({
+      queryCharacters: 120,
+      skillBytes: 131_072,
+      skills: 50,
+      panelReports: 20,
+      nameCharacters: 64,
+      sourceCharacters: 128,
+      pathCharacters: 4_096,
+      statusErrorCharacters: 2_000,
+      findingsPerSkill: 6,
+      findingCodeCharacters: 64,
+      findingMessageCharacters: 256,
+      score: 28,
+    });
+  });
+
+  it("preserves a safe available count beyond the bounded scan window", () => {
+    const view = skillGuardPanelView({
+      inventory: { available: 55, scanned: 50, shown: 20, truncated: true, scanTruncated: true, displayTruncated: true },
+      limits: { skills: 50, panelReports: 20 },
+    });
+
+    expect(view.inventory).toMatchObject({ available: 55, scanned: 50, shown: 20, truncated: true });
+  });
+});

package/packages/client-web/test/sql-lens-panel.test.ts

@@ -0,0 +1,52 @@
+import { createElement } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import { describe, expect, test } from "vitest";
+import { PluginPanelCard } from "../src/react-room.js";
+
+function renderPanel(data: unknown): string {
+  return renderToStaticMarkup(
+    createElement(PluginPanelCard, {
+      panel: { id: "sql-lens-panel", pluginId: "@pi-harness/core/plugins/sql-lens", title: "SQL Lens", data },
+    }),
+  );
+}
+
+const valid = {
+  status: { state: "completed", at: "2026-09-05T01:00:00.000Z" },
+  timeoutMs: 5_000,
+  latest: {
+    database: "data.db",
+    query: "SELECT id, name FROM users",
+    columns: ["id", "name"],
+    rows: [{ id: 1, name: "Ada" }],
+    truncated: false,
+    scannedRows: 1,
+    rowInventory: { scanned: 1, returned: 1, shown: 1, truncated: false, displayLimit: 20 },
+  },
+  limits: {
+    queryLength: 65_536,
+    databaseBytes: 268_435_456,
+    rows: 100,
+    columns: 128,
+    stringLength: 16_384,
+    resultBytes: 1_048_576,
+    blobPreviewBytes: 256,
+    panelRows: 20,
+  },
+};
+
+describe("SQL Lens panel", () => {
+  test("renders a validated result and limits", () => {
+    const html = renderPanel(valid);
+    for (const expected of ["已完成", "data.db", "1 rows", "Ada", "timeout:5000ms", "rows:100", "result:1024KiB"]) expect(html).toContain(expected);
+    expect(html).not.toContain("SQL Lens 面板数据异常");
+  });
+
+  test("fails closed for malformed data instead of showing a fake empty result", () => {
+    const html = renderPanel({ ...valid, latest: { ...valid.latest, rowInventory: { ...valid.latest.rowInventory, returned: 0 } } });
+    expect(html).toContain("SQL Lens 面板数据异常");
+    expect(html).toContain("面板数据不完整或不可信");
+    expect(html).not.toContain("0 rows");
+    expect(html).not.toContain("还没有查询数据库");
+  });
+});

package/packages/client-web/test/sql-lens-view.test.ts

@@ -0,0 +1,134 @@
+import { describe, expect, test } from "vitest";
+import { sqlLensPanelView } from "../src/sql-lens-view.js";
+
+describe("SQL Lens panel view", () => {
+  test("normalizes query results, status, row inventory, and limits", () => {
+    const view = sqlLensPanelView({
+      status: { state: "completed", at: "2026-09-05T01:00:00.000Z" },
+      timeoutMs: 1_500,
+      latest: {
+        database: "data.db",
+        query: "SELECT id, name FROM users",
+        columns: ["id", "name"],
+        rows: [{ id: 1, name: "Ada" }],
+        truncated: false,
+        scannedRows: 1,
+        rowInventory: { scanned: 1, returned: 1, shown: 1, truncated: false, displayLimit: 20 },
+      },
+      limits: {
+        queryLength: 65_536,
+        databaseBytes: 268_435_456,
+        rows: 100,
+        columns: 128,
+        stringLength: 16_384,
+        resultBytes: 1_048_576,
+        blobPreviewBytes: 256,
+        panelRows: 20,
+      },
+    });
+
+    expect(view).toMatchObject({
+      status: { state: "completed", at: "2026-09-05T01:00:00.000Z", error: null },
+      timeoutMs: 1_500,
+      latest: {
+        database: "data.db",
+        query: "SELECT id, name FROM users",
+        columns: ["id", "name"],
+        rows: [{ id: 1, name: "Ada" }],
+        rowInventory: { scanned: 1, returned: 1, shown: 1, truncated: false, displayLimit: 20 },
+      },
+      limits: {
+        queryLength: 65_536,
+        databaseBytes: 268_435_456,
+        rows: 100,
+        columns: 128,
+        stringLength: 16_384,
+        resultBytes: 1_048_576,
+        blobPreviewBytes: 256,
+        panelRows: 20,
+      },
+    });
+  });
+
+  test("fails closed for contradictory payloads without inventing zero-valued results", () => {
+    const base = {
+      status: { state: "completed", at: "2026-09-05T01:00:00.000Z" },
+      timeoutMs: 5_000,
+      latest: {
+        database: "data.db",
+        query: "SELECT id FROM users",
+        columns: ["id"],
+        rows: [{ id: 1 }],
+        truncated: false,
+        scannedRows: 1,
+        rowInventory: { scanned: 1, returned: 1, shown: 1, truncated: false, displayLimit: 20 },
+      },
+      limits: { queryLength: 65_536, databaseBytes: 268_435_456, rows: 100, columns: 128, stringLength: 16_384, resultBytes: 1_048_576, panelRows: 20 },
+    };
+    const malformed = [
+      null,
+      { ...base, unexpected: true },
+      { ...base, latest: { ...base.latest, columns: ["id", "id"] } },
+      { ...base, latest: { ...base.latest, rows: [{ id: 1, extra: 2 }] } },
+      { ...base, latest: { ...base.latest, rowInventory: { ...base.latest.rowInventory, returned: 0 } } },
+      { ...base, latest: { ...base.latest, scannedRows: 0 } },
+      { ...base, status: { state: "completed", at: "invalid" } },
+      { ...base, limits: { ...base.limits, rows: 99 } },
+    ];
+    for (const value of malformed) {
+      expect(sqlLensPanelView(value)).toMatchObject({ malformed: true, latest: null, status: { state: "unknown" } });
+    }
+  });
+
+  test("does not invoke accessors or revoked proxies", () => {
+    let getterCalls = 0;
+    const accessor = Object.defineProperty({}, "status", {
+      enumerable: true,
+      get() {
+        getterCalls += 1;
+        return { state: "idle" };
+      },
+    });
+    const revoked = Proxy.revocable({}, {});
+    revoked.revoke();
+    for (const value of [accessor, revoked.proxy]) {
+      expect(() => sqlLensPanelView(value)).not.toThrow();
+      expect(sqlLensPanelView(value).malformed).toBe(true);
+    }
+    expect(getterCalls).toBe(0);
+  });
+
+  test("fails closed for oversized or inconsistent untrusted rows and errors", () => {
+    const columns = Array.from({ length: 40 }, (_, index) => `column-${index}-${"c".repeat(400)}`);
+    const rows = Array.from({ length: 20 }, (_, index) => ({
+      [columns[0]!]: "x".repeat(5_000),
+      [columns[1]!]: { type: "blob", bytes: 70_000, previewBase64: "YQ==", truncated: true },
+      [columns[2]!]: Number.NaN,
+      [`unknown-${index}`]: "ignored",
+    }));
+    const view = sqlLensPanelView({
+      status: { state: "failed", at: "2026-09-05T01:00:00.000Z", error: "e".repeat(5_000) },
+      timeoutMs: Number.NaN,
+      latest: {
+        database: "d".repeat(8_000),
+        query: "q".repeat(80_000),
+        columns,
+        rows,
+        scannedRows: -1,
+        rowInventory: {},
+      },
+      limits: {
+        queryLength: 65_536,
+        databaseBytes: 268_435_456,
+        rows: 100,
+        columns: 128,
+        stringLength: 16_384,
+        resultBytes: 1_048_576,
+        blobPreviewBytes: 256,
+        panelRows: 20,
+      },
+    });
+
+    expect(view).toMatchObject({ malformed: true, latest: null, status: { state: "unknown", at: null, error: null }, timeoutMs: 5_000 });
+  });
+});

package/packages/client-web/test/test-harness-panel.test.ts

@@ -0,0 +1,228 @@
+import { createElement } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import { describe, expect, test } from "vitest";
+import { PluginPanelCard } from "../src/react-room.js";
+
+const allowedScripts = ["test", "build", "format:check", "lint", "typecheck"];
+
+function renderPanel(data: unknown): string {
+  return renderToStaticMarkup(
+    createElement(PluginPanelCard, {
+      panel: {
+        id: "test-harness-panel",
+        pluginId: "@pi-harness/core/plugins/test-harness",
+        title: "Test Harness",
+        data,
+      },
+    }),
+  );
+}
+
+function report(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    allowedScripts,
+    latest: {
+      script: "test",
+      command: "npm run test",
+      status: "passed",
+      exitCode: 0,
+      signal: null,
+      durationMs: 321,
+      output: "2 tests passed\n",
+      outputBytes: 15,
+      outputTruncated: false,
+      outputSanitized: false,
+    },
+    limits: { timeoutMs: 120_000, outputBytes: 12 * 1024 },
+    ...overrides,
+  };
+}
+
+describe("test-harness panel", () => {
+  test("renders validated status, limits, scripts, and process output", () => {
+    const html = renderPanel(report());
+
+    expect(html).toContain("验证通过");
+    expect(html).toContain("npm run test");
+    expect(html).toContain("exit 0");
+    expect(html).toContain("321 ms");
+    expect(html).toContain("2 tests passed");
+    expect(html).toContain("120000 ms");
+    for (const script of allowedScripts) expect(html).toContain(script);
+    expect(html).not.toContain("面板数据不完整");
+  });
+
+  test("renders failed, timed-out, and cancelled outcomes distinctly", () => {
+    const failed = renderPanel(
+      report({
+        latest: {
+          script: "build",
+          command: "npm run build",
+          status: "failed",
+          exitCode: 7,
+          signal: null,
+          durationMs: 400,
+          output: "build failed",
+          outputBytes: 12,
+          outputTruncated: false,
+          outputSanitized: false,
+        },
+      }),
+    );
+    const timedOut = renderPanel(
+      report({
+        latest: {
+          script: "lint",
+          command: "npm run lint",
+          status: "timed-out",
+          exitCode: null,
+          signal: "SIGTERM",
+          durationMs: 120_010,
+          output: "",
+          outputBytes: 0,
+          outputTruncated: false,
+          outputSanitized: false,
+        },
+      }),
+    );
+    const cancelled = renderPanel(
+      report({
+        latest: {
+          script: "typecheck",
+          command: "npm run typecheck",
+          status: "cancelled",
+          exitCode: null,
+          signal: "SIGTERM",
+          durationMs: 25,
+          output: "",
+          outputBytes: 0,
+          outputTruncated: false,
+          outputSanitized: false,
+        },
+      }),
+    );
+
+    expect(failed).toContain("验证失败");
+    expect(failed).toContain("exit 7");
+    expect(timedOut).toContain("验证超时");
+    expect(cancelled).toContain("验证已取消");
+  });
+
+  test("fails closed without invoking nested accessors or revoked proxies", () => {
+    let getterCalls = 0;
+    const latestAccessor = Object.defineProperty({}, "status", {
+      enumerable: true,
+      get() {
+        getterCalls += 1;
+        return "passed";
+      },
+    });
+    const revocable = Proxy.revocable({}, {});
+    revocable.revoke();
+    const scriptAccessors = [...allowedScripts];
+    Object.defineProperty(scriptAccessors, "0", {
+      enumerable: true,
+      get() {
+        getterCalls += 1;
+        return "test";
+      },
+    });
+    const revokedScripts = Proxy.revocable([...allowedScripts], {});
+    revokedScripts.revoke();
+
+    for (const data of [
+      report({ latest: latestAccessor }),
+      report({ latest: revocable.proxy }),
+      report({ allowedScripts: scriptAccessors }),
+      report({ allowedScripts: revokedScripts.proxy }),
+    ]) {
+      expect(() => renderPanel(data)).not.toThrow();
+      expect(renderPanel(data)).toContain("面板数据不完整");
+    }
+    expect(getterCalls).toBe(0);
+  });
+
+  test("rejects contradictory fields and safely bounds malformed output", () => {
+    const contradiction = renderPanel(
+      report({
+        latest: {
+          script: "test",
+          command: "npm run test",
+          status: "passed",
+          exitCode: 9,
+          signal: null,
+          durationMs: 1,
+          output: "impossible",
+          outputBytes: 10,
+          outputTruncated: false,
+          outputSanitized: false,
+        },
+      }),
+    );
+    const malformed = renderPanel(
+      report({
+        unexpected: true,
+        latest: {
+          script: "test",
+          command: "npm run test",
+          status: "passed",
+          exitCode: 0,
+          signal: null,
+          durationMs: 1,
+          output: `safe\u0000\u202E${"x".repeat(20_000)}`,
+          outputBytes: 20_008,
+          outputTruncated: true,
+          outputSanitized: true,
+        },
+      }),
+    );
+    const impossibleSignal = renderPanel(
+      report({
+        latest: {
+          script: "build",
+          command: "npm run build",
+          status: "failed",
+          exitCode: 7,
+          signal: "SIGTERM",
+          durationMs: 1,
+          output: "impossible signal",
+          outputBytes: 17,
+          outputTruncated: false,
+          outputSanitized: false,
+        },
+      }),
+    );
+
+    expect(contradiction).toContain("面板数据不完整");
+    expect(contradiction).not.toContain("impossible");
+    expect(impossibleSignal).toContain("面板数据不完整");
+    expect(impossibleSignal).not.toContain("impossible signal");
+    expect(malformed).toContain("面板数据不完整");
+    expect(malformed).not.toContain("\u0000");
+    expect(malformed).not.toContain("\u202E");
+    expect(malformed.length).toBeLessThan(16_000);
+  });
+
+  test("wraps long unbroken output instead of widening the panel", () => {
+    const output = "x".repeat(1_000);
+    const html = renderPanel(
+      report({
+        latest: {
+          script: "test",
+          command: "npm run test",
+          status: "passed",
+          exitCode: 0,
+          signal: null,
+          durationMs: 1,
+          output,
+          outputBytes: output.length,
+          outputTruncated: false,
+          outputSanitized: false,
+        },
+      }),
+    );
+
+    expect(html).toMatch(/<pre class="[^"]*break-all[^"]*">/u);
+    expect(html).toContain(output);
+  });
+});