@velum-labs/routekit-eval-setup 1.3.2 → 1.5.0

package/dist/test/fixtures/vitest-boundary-panel.js

@@ -0,0 +1,120 @@
+// These are ordinary framework boundary regressions and causal controls, not
+// generated benchmark cases or production grading authority.
+const hookPass = ["module-enter", "before-all-enter", "before-all-return", "body-enter", "body-return",
+    "after-each-enter", "after-each-return", "after-all-enter", "after-all-return"];
+export const VITEST_BOUNDARY_CASES = [
+    { id: "edge-hooks-clean", kind: "hooks", bodyOk: true, expected: "pass", events: hookPass, taskState: "passed" },
+    { id: "edge-hooks-body-only", kind: "hooks", bodyOk: false, expected: "fail",
+        events: hookPass.filter(phase => phase !== "body-return"), taskState: "failed" },
+    { id: "edge-before-all", kind: "hooks", bodyOk: true, hookFailure: "before-all", expected: "unknown",
+        events: ["module-enter", "before-all-enter", "after-all-enter", "after-all-return"], taskState: "skipped" },
+    { id: "edge-after-each", kind: "hooks", bodyOk: true, hookFailure: "after-each", expected: "unknown",
+        events: hookPass.filter(phase => phase !== "after-each-return"), taskState: "failed" },
+    { id: "edge-after-all", kind: "hooks", bodyOk: true, hookFailure: "after-all", expected: "unknown",
+        events: hookPass.filter(phase => phase !== "after-all-return"), taskState: "passed" },
+    { id: "edge-import-ok", kind: "import-ok", expected: "pass",
+        events: ["module-enter", "imported-module-enter", "import-return", "body-enter", "body-return"], taskState: "passed" },
+    { id: "edge-import-error", kind: "import-error", expected: "unknown",
+        events: ["module-enter", "imported-module-enter", "import-rejected"], taskState: "none" },
+    { id: "edge-syntax-error", kind: "syntax-error", expected: "unknown",
+        events: ["module-enter", "import-rejected"], taskState: "none" },
+    { id: "edge-no-tests", kind: "no-tests", expected: "unknown",
+        events: ["module-enter"], taskState: "none" },
+    { id: "edge-all-skipped", kind: "all-skipped", expected: "unknown",
+        events: ["module-enter"], taskState: "skipped" }
+];
+export const VITEST_COLLECTION_FAILURE_CASES = VITEST_BOUNDARY_CASES.filter(scenario => scenario.kind === "import-error" || scenario.kind === "syntax-error");
+export const REPOSITORY_BOUNDARY_EVENTS_SOURCE = String.raw `
+import { appendFileSync, mkdirSync, readFileSync } from "node:fs";
+const identity = JSON.parse(readFileSync("identity.json", "utf8"));
+const sequences = new Map();
+export function phase(scenario, name, diagnostic) {
+  const sequence = sequences.get(scenario) ?? 0;
+  sequences.set(scenario, sequence + 1);
+  mkdirSync("phases", { recursive: true });
+  appendFileSync("phases/" + scenario + ".jsonl", JSON.stringify({
+    runId: identity.runId, scenario, sequence, phase: name,
+    process: { pid: process.pid, parentPid: process.ppid, checkout: process.cwd(),
+      home: process.env.HOME, temporary: process.env.TMPDIR },
+    ...(diagnostic === undefined ? {} : { diagnostic })
+  }) + "\n");
+}
+export const diagnostic = error => ({
+  name: typeof error?.name === "string" ? error.name : "UnknownError",
+  message: typeof error?.message === "string" ? error.message : String(error),
+  ...(typeof error?.code === "string" ? { code: error.code } : {}),
+  ...(typeof error?.id === "string" ? { id: error.id } : {})
+});
+`;
+const registerSource = String.raw `
+import assert from "node:assert/strict";
+import { afterAll, afterEach, beforeAll, test } from "vitest";
+import { diagnostic, phase } from "./edge-events.mjs";
+export async function register(scenario) {
+  const event = (name, detail) => phase(scenario.id, name, detail);
+  event("module-enter");
+  if (scenario.kind === "no-tests") return;
+  if (scenario.kind === "hooks") {
+    beforeAll(() => {
+      event("before-all-enter");
+      assert.notEqual(scenario.hookFailure, "before-all", "beforeAll sentinel assertion");
+      event("before-all-return");
+    });
+    afterEach(() => {
+      event("after-each-enter");
+      assert.notEqual(scenario.hookFailure, "after-each", "afterEach sentinel assertion");
+      event("after-each-return");
+    });
+    afterAll(() => {
+      event("after-all-enter");
+      assert.notEqual(scenario.hookFailure, "after-all", "afterAll sentinel assertion");
+      event("after-all-return");
+    });
+  }
+  if (scenario.kind === "import-ok" || scenario.kind === "import-error" || scenario.kind === "syntax-error") {
+    try {
+      const module = scenario.kind === "import-ok" ? await import("./edge-import-valid.mjs")
+        : scenario.kind === "import-error" ? await import("./edge-import-throws.mjs")
+        : await import("./edge-import-syntax-bad.mjs");
+      assert.equal(module.value, "routekit-import-syntax-control");
+      event("import-return");
+    } catch (error) {
+      event("import-rejected", diagnostic(error));
+      throw error;
+    }
+  }
+  const body = () => {
+    event("body-enter");
+    assert.notEqual(scenario.bodyOk, false, "body sentinel assertion");
+    event("body-return");
+  };
+  if (scenario.kind === "all-skipped") test.skip("boundary " + scenario.id, body);
+  else test("boundary " + scenario.id, body);
+}
+`;
+export const VITEST_BOUNDARY_FILES = {
+    "test/edge-events.mjs": REPOSITORY_BOUNDARY_EVENTS_SOURCE,
+    "test/edge-register.mjs": registerSource,
+    "test/edge-import-valid.mjs": String.raw `
+import { phase } from "./edge-events.mjs";
+phase("edge-import-ok", "imported-module-enter");
+export const value = "routekit-import-syntax-control";
+`,
+    "test/edge-import-throws.mjs": String.raw `
+import { phase } from "./edge-events.mjs";
+phase("edge-import-error", "imported-module-enter");
+const error = new Error("routekit fixture import failed before test registration");
+error.name = "RouteKitFixtureImportError";
+error.code = "ROUTEKIT_FIXTURE_IMPORT_FAILURE";
+throw error;
+`,
+    "test/edge-import-syntax-bad.mjs": String.raw `
+import { phase } from "./edge-events.mjs";
+phase("edge-syntax-error", "malformed-module-enter");
+export const = "routekit-import-syntax-control";
+`,
+    ...Object.fromEntries(VITEST_BOUNDARY_CASES.map(scenario => [
+        `test/${scenario.id}.test.mjs`,
+        `import { register } from "./edge-register.mjs";\nawait register(${JSON.stringify(scenario)});\n`
+    ]))
+};

package/dist/test/fixtures/vitest-phase-panel.d.ts

@@ -0,0 +1,135 @@
+export declare const VITEST_PHASE_CASES: readonly [{
+    readonly id: "positive";
+    readonly bodyOk: true;
+    readonly cleanupOk: true;
+    readonly expected: "pass";
+    readonly events: string[];
+}, {
+    readonly id: "body-only";
+    readonly bodyOk: false;
+    readonly cleanupOk: true;
+    readonly expected: "fail";
+    readonly events: string[];
+}, {
+    readonly id: "cleanup-only";
+    readonly bodyOk: true;
+    readonly cleanupOk: false;
+    readonly expected: "unknown";
+    readonly events: readonly ["body-enter", "body-return", "cleanup-enter"];
+}, {
+    readonly id: "mixed";
+    readonly bodyOk: false;
+    readonly cleanupOk: false;
+    readonly expected: "unknown";
+    readonly events: readonly ["body-enter", "cleanup-enter"];
+}, {
+    readonly id: "mixed-runtime-cleanup";
+    readonly bodyOk: false;
+    readonly cleanupOk: true;
+    readonly cleanupRuntime: true;
+    readonly expected: "unknown";
+    readonly events: readonly ["body-enter", "cleanup-enter"];
+}, {
+    readonly id: "global-finished-empty";
+    readonly bodyOk: false;
+    readonly cleanupOk: true;
+    readonly cleanupEmpty: true;
+    readonly expected: "unknown";
+    readonly events: readonly ["body-enter", "cleanup-enter"];
+}, {
+    readonly id: "global-failed-empty-late";
+    readonly bodyOk: false;
+    readonly cleanupOk: true;
+    readonly failedFromFinished: true;
+    readonly expected: "unknown";
+    readonly events: readonly [...string[], "failed-cleanup-enter"];
+}, {
+    readonly id: "fixture-init";
+    readonly bodyOk: true;
+    readonly cleanupOk: true;
+    readonly fixture: "setup-error";
+    readonly expected: "unknown";
+    readonly events: readonly ["fixture-setup-enter"];
+}, {
+    readonly id: "fixture-teardown";
+    readonly bodyOk: true;
+    readonly cleanupOk: true;
+    readonly fixture: "cleanup-error";
+    readonly expected: "unknown";
+    readonly events: readonly ["fixture-setup-enter", "fixture-setup-return", "body-enter", "body-return", "fixture-cleanup-enter", "cleanup-enter", "cleanup-return"];
+}, {
+    readonly id: "fixture-clean";
+    readonly bodyOk: true;
+    readonly cleanupOk: true;
+    readonly fixture: "clean";
+    readonly expected: "unknown";
+    readonly events: readonly ["fixture-setup-enter", "fixture-setup-return", "body-enter", "body-return", "fixture-cleanup-enter", "fixture-cleanup-return", "cleanup-enter", "cleanup-return"];
+}, {
+    readonly id: "returned-hook-cleanup";
+    readonly bodyOk: true;
+    readonly cleanupOk: true;
+    readonly returnedHook: true;
+    readonly expected: "unknown";
+    readonly events: readonly ["hook-setup-enter", "hook-setup-return", "body-enter", "body-return", "hook-cleanup-enter", "cleanup-enter", "cleanup-return"];
+}, {
+    readonly id: "before-each-setup";
+    readonly bodyOk: true;
+    readonly cleanupOk: true;
+    readonly beforeEachFailure: true;
+    readonly expected: "unknown";
+    readonly events: readonly ["hook-setup-enter"];
+}, {
+    readonly id: "unobserved-nested";
+    readonly bodyOk: true;
+    readonly cleanupOk: true;
+    readonly nested: true;
+    readonly expected: "unknown";
+    readonly events: string[];
+}, {
+    readonly id: "expected-failure";
+    readonly bodyOk: false;
+    readonly cleanupOk: true;
+    readonly expectedFailure: true;
+    readonly expected: "unknown";
+    readonly events: string[];
+}, {
+    readonly id: "recovered-retry";
+    readonly bodyOk: true;
+    readonly cleanupOk: true;
+    readonly retry: true;
+    readonly expected: "unknown";
+    readonly events: readonly string[];
+}, {
+    readonly id: "repeated-pass";
+    readonly bodyOk: true;
+    readonly cleanupOk: true;
+    readonly repeat: true;
+    readonly expected: "unknown";
+    readonly events: readonly string[];
+}];
+export declare const VITEST_PHASE_TIMEOUT_CASES: readonly [{
+    readonly id: "returned-hook-short-local-timeout";
+    readonly bodyOk: true;
+    readonly cleanupOk: true;
+    readonly returnedHookTimeout: true;
+    readonly cleanupTimeoutMs: 25;
+    readonly cleanupDelayMs: 250;
+    readonly hookTimeoutMs: 1000;
+    readonly expected: "unknown";
+    readonly events: readonly ["hook-setup-enter", "hook-setup-return", "body-enter", "body-return", "hook-cleanup-enter", "hook-cleanup-abort", "cleanup-enter", "cleanup-return"];
+}, {
+    readonly id: "returned-hook-long-local-timeout";
+    readonly bodyOk: true;
+    readonly cleanupOk: true;
+    readonly returnedHookTimeout: true;
+    readonly cleanupTimeoutMs: 1000;
+    readonly cleanupDelayMs: 250;
+    readonly hookTimeoutMs: 25;
+    readonly expected: "pass";
+    readonly events: readonly ["hook-setup-enter", "hook-setup-return", "body-enter", "body-return", "hook-cleanup-enter", "hook-cleanup-return", "cleanup-enter", "cleanup-return"];
+}];
+export declare const VITEST_PHASE_REGISTER_SOURCE: string;
+export declare const VITEST_PHASE_READER_SOURCE: string;
+export declare const VITEST_PHASE_STOCK_READER_SOURCE: string;
+export declare const VITEST_PHASE_VERSIONS_SOURCE: string;
+export declare const VITEST_PHASE_CUSTOM_RUNNER_SOURCE: string;

package/dist/test/fixtures/vitest-phase-panel.js

@@ -0,0 +1,213 @@
+// Executable regression fixtures, not production phase authority. Only the
+// test harness reads these causal event files, after real runner execution.
+const clean = ["body-enter", "body-return", "cleanup-enter", "cleanup-return"];
+const failedBody = ["body-enter", "cleanup-enter", "cleanup-return"];
+export const VITEST_PHASE_CASES = [
+    { id: "positive", bodyOk: true, cleanupOk: true, expected: "pass", events: clean },
+    { id: "body-only", bodyOk: false, cleanupOk: true, expected: "fail", events: failedBody },
+    { id: "cleanup-only", bodyOk: true, cleanupOk: false, expected: "unknown",
+        events: ["body-enter", "body-return", "cleanup-enter"] },
+    { id: "mixed", bodyOk: false, cleanupOk: false, expected: "unknown",
+        events: ["body-enter", "cleanup-enter"] },
+    { id: "mixed-runtime-cleanup", bodyOk: false, cleanupOk: true, cleanupRuntime: true,
+        expected: "unknown", events: ["body-enter", "cleanup-enter"] },
+    { id: "global-finished-empty", bodyOk: false, cleanupOk: true, cleanupEmpty: true,
+        expected: "unknown", events: ["body-enter", "cleanup-enter"] },
+    { id: "global-failed-empty-late", bodyOk: false, cleanupOk: true, failedFromFinished: true,
+        expected: "unknown", events: [...failedBody, "failed-cleanup-enter"] },
+    { id: "fixture-init", bodyOk: true, cleanupOk: true, fixture: "setup-error", expected: "unknown",
+        events: ["fixture-setup-enter"] },
+    { id: "fixture-teardown", bodyOk: true, cleanupOk: true, fixture: "cleanup-error", expected: "unknown",
+        events: ["fixture-setup-enter", "fixture-setup-return", "body-enter", "body-return",
+            "fixture-cleanup-enter", "cleanup-enter", "cleanup-return"] },
+    { id: "fixture-clean", bodyOk: true, cleanupOk: true, fixture: "clean", expected: "unknown",
+        events: ["fixture-setup-enter", "fixture-setup-return", "body-enter", "body-return",
+            "fixture-cleanup-enter", "fixture-cleanup-return", "cleanup-enter", "cleanup-return"] },
+    { id: "returned-hook-cleanup", bodyOk: true, cleanupOk: true, returnedHook: true, expected: "unknown",
+        events: ["hook-setup-enter", "hook-setup-return", "body-enter", "body-return", "hook-cleanup-enter",
+            "cleanup-enter", "cleanup-return"] },
+    { id: "before-each-setup", bodyOk: true, cleanupOk: true, beforeEachFailure: true, expected: "unknown",
+        events: ["hook-setup-enter"] },
+    { id: "unobserved-nested", bodyOk: true, cleanupOk: true, nested: true, expected: "unknown", events: clean },
+    { id: "expected-failure", bodyOk: false, cleanupOk: true, expectedFailure: true, expected: "unknown",
+        events: failedBody },
+    { id: "recovered-retry", bodyOk: true, cleanupOk: true, retry: true, expected: "unknown",
+        events: [...failedBody, ...clean] },
+    { id: "repeated-pass", bodyOk: true, cleanupOk: true, repeat: true, expected: "unknown",
+        events: [...clean, ...clean] }
+];
+// Paired against uninstrumented Vitest in a separate replay of the same fixture
+// commit. The shorter local timeout must still fire, and the longer local
+// timeout must not be silently replaced with the global default.
+export const VITEST_PHASE_TIMEOUT_CASES = [
+    { id: "returned-hook-short-local-timeout", bodyOk: true, cleanupOk: true,
+        returnedHookTimeout: true, cleanupTimeoutMs: 25, cleanupDelayMs: 250, hookTimeoutMs: 1000,
+        expected: "unknown", events: ["hook-setup-enter", "hook-setup-return", "body-enter", "body-return",
+            "hook-cleanup-enter", "hook-cleanup-abort", "cleanup-enter", "cleanup-return"] },
+    { id: "returned-hook-long-local-timeout", bodyOk: true, cleanupOk: true,
+        returnedHookTimeout: true, cleanupTimeoutMs: 1000, cleanupDelayMs: 250, hookTimeoutMs: 25,
+        expected: "pass", events: ["hook-setup-enter", "hook-setup-return", "body-enter", "body-return",
+            "hook-cleanup-enter", "hook-cleanup-return", "cleanup-enter", "cleanup-return"] }
+];
+export const VITEST_PHASE_REGISTER_SOURCE = String.raw `
+import assert from "node:assert/strict";
+import { appendFileSync, mkdirSync, readFileSync } from "node:fs";
+import { setTimeout as delay } from "node:timers/promises";
+import { beforeEach, describe, onTestFailed, onTestFinished, test } from "vitest";
+const identity = JSON.parse(readFileSync("identity.json", "utf8"));
+export function register(scenario) {
+  let sequence = 0;
+  let attempts = 0;
+  const phase = (name, error) => {
+    mkdirSync("phases", { recursive: true });
+    appendFileSync("phases/" + scenario.id + ".jsonl", JSON.stringify({
+      runId: identity.runId, scenario: scenario.id, sequence: sequence++, phase: name,
+      ...(error === undefined ? {} : { error: {
+        name: error.name, message: error.message, stack: error.stack
+      } })
+    }) + "\n");
+  };
+  if (scenario.beforeEachFailure) beforeEach(() => {
+    phase("hook-setup-enter");
+    assert.equal(false, true, "setup assertion");
+  });
+  if (scenario.returnedHook) beforeEach(() => {
+    phase("hook-setup-enter");
+    phase("hook-setup-return");
+    return () => {
+      phase("hook-cleanup-enter");
+      assert.equal(false, true, "returned cleanup assertion");
+      phase("hook-cleanup-return");
+    };
+  });
+  if (scenario.returnedHookTimeout) beforeEach(({ signal }) => {
+    phase("hook-setup-enter");
+    signal.addEventListener("abort", () => phase("hook-cleanup-abort", signal.reason), { once: true });
+    phase("hook-setup-return");
+    return async () => {
+      phase("hook-cleanup-enter");
+      await delay(scenario.cleanupDelayMs, undefined, { signal });
+      phase("hook-cleanup-return");
+    };
+  }, scenario.cleanupTimeoutMs);
+  const body = () => {
+    phase("body-enter");
+    onTestFinished(() => {
+      phase("cleanup-enter");
+      if (scenario.cleanupRuntime) throw new TypeError("cleanup runtime error");
+      if (scenario.cleanupEmpty) throw [];
+      assert.equal(scenario.cleanupOk, true, "cleanup assertion");
+      if (scenario.failedFromFinished) onTestFailed(() => {
+        phase("failed-cleanup-enter");
+        throw [];
+      });
+      phase("cleanup-return");
+    });
+    const bodyOk = scenario.retry ? attempts++ > 0 : scenario.bodyOk;
+    assert.equal(bodyOk, true, "behavioral assertion");
+    phase("body-return");
+  };
+  const registerTest = () => {
+    if (scenario.fixture) {
+      const extended = test.extend({
+        resource: async ({}, use) => {
+          phase("fixture-setup-enter");
+          assert.notEqual(scenario.fixture, "setup-error", "fixture setup assertion");
+          phase("fixture-setup-return");
+          await use(true);
+          phase("fixture-cleanup-enter");
+          assert.notEqual(scenario.fixture, "cleanup-error", "fixture teardown assertion");
+          phase("fixture-cleanup-return");
+        }
+      });
+      extended("phase " + scenario.id, ({ resource }) => { assert.equal(resource, true); body(); });
+    } else if (scenario.expectedFailure) test.fails("phase " + scenario.id, body);
+    else if (scenario.retry) test("phase " + scenario.id, { retry: 1 }, body);
+    else if (scenario.repeat) test("phase " + scenario.id, { repeats: 1 }, body);
+    else test("phase " + scenario.id, body);
+  };
+  if (scenario.nested) describe("deliberately unsupported collector", registerTest);
+  else registerTest();
+}
+`;
+export const VITEST_PHASE_READER_SOURCE = String.raw `
+import { existsSync, readFileSync } from "node:fs";
+const scenario = process.argv[2];
+const path = "phases/" + scenario + ".jsonl";
+const events = existsSync(path) ? readFileSync(path, "utf8").trim().split("\n").filter(Boolean).map(JSON.parse) : [];
+console.log("ROUTEKIT_PHASE_CAUSAL_CONTROL " + JSON.stringify({
+  ...JSON.parse(readFileSync("identity.json", "utf8")), scenario, events,
+  customRunnerImported: existsSync("custom-runner-imported")
+}));
+`;
+// The stock JSON report is a causal comparison only, never semantic evidence.
+// Its invocation intentionally uses the uninstrumented pinned Vitest CLI.
+export const VITEST_PHASE_STOCK_READER_SOURCE = String.raw `
+import "./read-phases.mjs";
+import { readFileSync } from "node:fs";
+const scenario = process.argv[2];
+console.log("ROUTEKIT_STOCK_VITEST_CONTROL " + JSON.stringify({
+  ...JSON.parse(readFileSync("identity.json", "utf8")), scenario,
+  report: JSON.parse(readFileSync("stock-" + scenario + ".json", "utf8"))
+}));
+`;
+export const VITEST_PHASE_VERSIONS_SOURCE = String.raw `
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { accessSync, constants, readFileSync, realpathSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+const checkout = realpathSync(process.cwd());
+const localFile = path => {
+  const actual = realpathSync(path);
+  const local = relative(checkout, actual);
+  assert.equal(local === ".." || local.startsWith(".." + sep) || isAbsolute(local), false,
+    "pinned runtime files and launchers must belong to the isolated checkout");
+  assert.equal(statSync(actual).isFile(), true, "pinned runtime paths must be files");
+  return actual;
+};
+const require = createRequire(import.meta.url);
+const vitestPath = localFile(require.resolve("vitest/package.json"));
+const fromVitest = createRequire(vitestPath);
+const runnerPath = localFile(fromVitest.resolve("@vitest/runner/package.json"));
+const vitePath = localFile(fromVitest.resolve("vite/package.json"));
+const version = path => JSON.parse(readFileSync(path, "utf8")).version;
+const versions = {
+  vitest: version(vitestPath),
+  runner: version(runnerPath),
+  vite: version(vitePath)
+};
+assert.deepEqual(versions, { vitest: "3.2.7", runner: "3.2.7", vite: "7.3.6" });
+for (const [name, manifestPath] of [["vite", vitePath], ["vitest", vitestPath]]) {
+  const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+  const declaredEntry = typeof manifest.bin === "string" ? manifest.bin : manifest.bin?.[name];
+  assert.equal(typeof declaredEntry, "string", name + " must declare its executable");
+  const entry = localFile(resolve(dirname(manifestPath), declaredEntry));
+  const launcher = localFile(join(checkout, "node_modules", ".bin",
+    name + (process.platform === "win32" ? ".cmd" : "")));
+  accessSync(launcher, constants.X_OK);
+  // Frozen installs need truthful hasBin metadata. A package/version check
+  // alone can pass while pnpm exec falls back to the workspace's binary.
+  // Observe the actual Node entrypoint, not a shim comment or version text.
+  const proof = "ROUTEKIT_PINNED_EXECUTABLE " + name;
+  const preload = 'import { realpathSync } from "node:fs";\n' +
+    'let entry; try { entry = process.argv[1] && realpathSync(process.argv[1]); } catch {}\n' +
+    'if (entry === ' + JSON.stringify(entry) + ') process.stdout.write(' +
+    JSON.stringify(proof + "\n") + ');\n';
+  const output = execFileSync("corepack", ["pnpm@11.15.1", "exec", name, "--version"], {
+    cwd: checkout,
+    env: { ...process.env, NODE_OPTIONS: "--import=data:text/javascript;base64," +
+      Buffer.from(preload).toString("base64") },
+    encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], maxBuffer: 65536
+  });
+  assert.equal(output.split("\n").filter(line => line === proof).length, 1,
+    name + " must execute its checkout-local pinned entrypoint");
+}
+console.log("ROUTEKIT_PINNED_VITEST_RUNTIME " + JSON.stringify(versions));
+`;
+// This module must never execute when the host refuses a configured runner.
+export const VITEST_PHASE_CUSTOM_RUNNER_SOURCE = String.raw `
+import { writeFileSync } from "node:fs";
+writeFileSync("custom-runner-imported", "unsafe runner executed");
+export default class CustomRunner { constructor() { throw new Error("must not instantiate"); } }
+`;

package/dist/test/fixtures/vitest-reporter-results.d.ts

@@ -0,0 +1,76 @@
+export declare const VITEST_REPORTER_RESULTS: readonly [{
+    readonly name: "test/pass.test.js";
+    readonly expected: "pass";
+    readonly exitCode: 0;
+    readonly stdout: "ROUTEKIT_VITEST_EVIDENCE_V1 {\"version\":1,\"complete\":true,\"starts\":1,\"ends\":1,\"reason\":\"passed\",\"eventIntegrity\":true,\"unfinishedHooks\":false,\"completedTestIds\":[\"-2123656795_0\"],\"unhandledErrors\":[],\"modules\":[{\"id\":\"-2123656795\",\"state\":\"passed\",\"errors\":[],\"hooks\":[],\"suites\":[],\"tests\":[{\"id\":\"-2123656795_0\",\"name\":\"asserted success\",\"state\":\"passed\",\"errors\":[],\"hooks\":[],\"diagnostic\":{\"retryCount\":0,\"repeatCount\":0,\"flaky\":false,\"duration\":0.49945799999998997}}]}]}\n";
+}, {
+    readonly name: "test/assertion.test.js";
+    readonly expected: "fail";
+    readonly exitCode: 1;
+    readonly stdout: "ROUTEKIT_VITEST_EVIDENCE_V1 {\"version\":1,\"complete\":true,\"starts\":1,\"ends\":1,\"reason\":\"failed\",\"eventIntegrity\":true,\"unfinishedHooks\":false,\"completedTestIds\":[\"1562894588_0\"],\"unhandledErrors\":[],\"modules\":[{\"id\":\"1562894588\",\"state\":\"failed\",\"errors\":[],\"hooks\":[],\"suites\":[],\"tests\":[{\"id\":\"1562894588_0\",\"name\":\"body assertion\",\"state\":\"failed\",\"errors\":[{\"name\":\"AssertionError\"}],\"hooks\":[],\"diagnostic\":{\"retryCount\":0,\"repeatCount\":0,\"flaky\":false,\"duration\":3.3549999999999898}}]}]}\n";
+}, {
+    readonly name: "test/runtime.test.js";
+    readonly expected: "unknown";
+    readonly exitCode: 1;
+    readonly stdout: "ROUTEKIT_VITEST_EVIDENCE_V1 {\"version\":1,\"complete\":true,\"starts\":1,\"ends\":1,\"reason\":\"failed\",\"eventIntegrity\":true,\"unfinishedHooks\":false,\"completedTestIds\":[\"2121496722_0\"],\"unhandledErrors\":[],\"modules\":[{\"id\":\"2121496722\",\"state\":\"failed\",\"errors\":[],\"hooks\":[],\"suites\":[],\"tests\":[{\"id\":\"2121496722_0\",\"name\":\"body runtime error\",\"state\":\"failed\",\"errors\":[{\"name\":\"TypeError\"}],\"hooks\":[],\"diagnostic\":{\"retryCount\":0,\"repeatCount\":0,\"flaky\":false,\"duration\":1.7253749999999997}}]}]}\n";
+}, {
+    readonly name: "test/before_each.test.js";
+    readonly expected: "unknown";
+    readonly exitCode: 1;
+    readonly stdout: "ROUTEKIT_VITEST_EVIDENCE_V1 {\"version\":1,\"complete\":true,\"starts\":1,\"ends\":1,\"reason\":\"failed\",\"eventIntegrity\":true,\"unfinishedHooks\":true,\"completedTestIds\":[\"2072471803_0\"],\"unhandledErrors\":[],\"modules\":[{\"id\":\"2072471803\",\"state\":\"failed\",\"errors\":[],\"hooks\":[],\"suites\":[],\"tests\":[{\"id\":\"2072471803_0\",\"name\":\"beforeEach assertion\",\"state\":\"failed\",\"errors\":[{\"name\":\"AssertionError\"}],\"hooks\":[\"run\"],\"diagnostic\":{\"retryCount\":0,\"repeatCount\":0,\"flaky\":false,\"duration\":3.4626250000000027}}]}]}\n";
+}, {
+    readonly name: "test/after_each.test.js";
+    readonly expected: "unknown";
+    readonly exitCode: 1;
+    readonly stdout: "ROUTEKIT_VITEST_EVIDENCE_V1 {\"version\":1,\"complete\":true,\"starts\":1,\"ends\":1,\"reason\":\"failed\",\"eventIntegrity\":true,\"unfinishedHooks\":true,\"completedTestIds\":[\"-282103976_0\"],\"unhandledErrors\":[],\"modules\":[{\"id\":\"-282103976\",\"state\":\"failed\",\"errors\":[],\"hooks\":[],\"suites\":[],\"tests\":[{\"id\":\"-282103976_0\",\"name\":\"afterEach assertion\",\"state\":\"failed\",\"errors\":[{\"name\":\"AssertionError\"}],\"hooks\":[\"run\"],\"diagnostic\":{\"retryCount\":0,\"repeatCount\":0,\"flaky\":false,\"duration\":3.2887079999999997}}]}]}\n";
+}, {
+    readonly name: "test/before_all.test.js";
+    readonly expected: "unknown";
+    readonly exitCode: 1;
+    readonly stdout: "ROUTEKIT_VITEST_EVIDENCE_V1 {\"version\":1,\"complete\":true,\"starts\":1,\"ends\":1,\"reason\":\"failed\",\"eventIntegrity\":true,\"unfinishedHooks\":true,\"completedTestIds\":[\"-532777803_0\"],\"unhandledErrors\":[],\"modules\":[{\"id\":\"-532777803\",\"state\":\"failed\",\"errors\":[{\"name\":\"AssertionError\"}],\"hooks\":[\"run\"],\"suites\":[],\"tests\":[{\"id\":\"-532777803_0\",\"name\":\"beforeAll assertion\",\"state\":\"skipped\",\"errors\":[],\"hooks\":[],\"diagnostic\":null}]}]}\n";
+}, {
+    readonly name: "test/after_all.test.js";
+    readonly expected: "unknown";
+    readonly exitCode: 1;
+    readonly stdout: "ROUTEKIT_VITEST_EVIDENCE_V1 {\"version\":1,\"complete\":true,\"starts\":1,\"ends\":1,\"reason\":\"failed\",\"eventIntegrity\":true,\"unfinishedHooks\":true,\"completedTestIds\":[\"-193089864_0\"],\"unhandledErrors\":[],\"modules\":[{\"id\":\"-193089864\",\"state\":\"failed\",\"errors\":[{\"name\":\"AssertionError\"}],\"hooks\":[\"run\"],\"suites\":[],\"tests\":[{\"id\":\"-193089864_0\",\"name\":\"afterAll assertion\",\"state\":\"passed\",\"errors\":[],\"hooks\":[],\"diagnostic\":{\"retryCount\":0,\"repeatCount\":0,\"flaky\":false,\"duration\":0.4870829999999984}}]}]}\n";
+}, {
+    readonly name: "test/import_error.test.js";
+    readonly expected: "unknown";
+    readonly exitCode: 1;
+    readonly stdout: "ROUTEKIT_VITEST_EVIDENCE_V1 {\"version\":1,\"complete\":true,\"starts\":1,\"ends\":1,\"reason\":\"failed\",\"eventIntegrity\":true,\"unfinishedHooks\":false,\"completedTestIds\":[],\"unhandledErrors\":[],\"modules\":[{\"id\":\"-1876038526\",\"state\":\"failed\",\"errors\":[{\"name\":\"Error\"}],\"hooks\":[],\"suites\":[],\"tests\":[]}]}\n";
+}, {
+    readonly name: "test/mixed.test.js";
+    readonly expected: "unknown";
+    readonly exitCode: 1;
+    readonly stdout: "ROUTEKIT_VITEST_EVIDENCE_V1 {\"version\":1,\"complete\":true,\"starts\":1,\"ends\":1,\"reason\":\"failed\",\"eventIntegrity\":true,\"unfinishedHooks\":false,\"completedTestIds\":[\"-1962563979_0\",\"-1962563979_1\"],\"unhandledErrors\":[],\"modules\":[{\"id\":\"-1962563979\",\"state\":\"failed\",\"errors\":[],\"hooks\":[],\"suites\":[],\"tests\":[{\"id\":\"-1962563979_0\",\"name\":\"assertion\",\"state\":\"failed\",\"errors\":[{\"name\":\"AssertionError\"}],\"hooks\":[],\"diagnostic\":{\"retryCount\":0,\"repeatCount\":0,\"flaky\":false,\"duration\":3.106250000000003}},{\"id\":\"-1962563979_1\",\"name\":\"runtime\",\"state\":\"failed\",\"errors\":[{\"name\":\"TypeError\"}],\"hooks\":[],\"diagnostic\":{\"retryCount\":0,\"repeatCount\":0,\"flaky\":false,\"duration\":0.1493329999999986}}]}]}\n";
+}, {
+    readonly name: "test/retry.test.js";
+    readonly expected: "unknown";
+    readonly exitCode: 0;
+    readonly stdout: "ROUTEKIT_VITEST_EVIDENCE_V1 {\"version\":1,\"complete\":true,\"starts\":1,\"ends\":1,\"reason\":\"passed\",\"eventIntegrity\":true,\"unfinishedHooks\":false,\"completedTestIds\":[\"1385381922_0\"],\"unhandledErrors\":[],\"modules\":[{\"id\":\"1385381922\",\"state\":\"passed\",\"errors\":[],\"hooks\":[],\"suites\":[],\"tests\":[{\"id\":\"1385381922_0\",\"name\":\"retried body\",\"state\":\"passed\",\"errors\":[{\"name\":\"AssertionError\"}],\"hooks\":[],\"diagnostic\":{\"retryCount\":1,\"repeatCount\":0,\"flaky\":true,\"duration\":4.030708000000004}}]}]}\n";
+}, {
+    readonly name: "test/skipped.test.js";
+    readonly expected: "unknown";
+    readonly exitCode: 0;
+    readonly stdout: "ROUTEKIT_VITEST_EVIDENCE_V1 {\"version\":1,\"complete\":true,\"starts\":1,\"ends\":1,\"reason\":\"passed\",\"eventIntegrity\":true,\"unfinishedHooks\":false,\"completedTestIds\":[\"436221930_0\"],\"unhandledErrors\":[],\"modules\":[{\"id\":\"436221930\",\"state\":\"skipped\",\"errors\":[],\"hooks\":[],\"suites\":[],\"tests\":[{\"id\":\"436221930_0\",\"name\":\"skipped\",\"state\":\"skipped\",\"errors\":[],\"hooks\":[],\"diagnostic\":null}]}]}\n";
+}, {
+    readonly name: "hook-attribution/successful-hooks-assertion.test.js";
+    readonly expected: "fail";
+    readonly exitCode: 1;
+    readonly stdout: "ROUTEKIT_VITEST_EVIDENCE_V1 {\"version\":1,\"complete\":true,\"starts\":1,\"ends\":1,\"reason\":\"failed\",\"eventIntegrity\":true,\"unfinishedHooks\":false,\"completedTestIds\":[\"-496486493_0\"],\"unhandledErrors\":[],\"modules\":[{\"id\":\"-496486493\",\"state\":\"failed\",\"errors\":[],\"hooks\":[],\"suites\":[],\"tests\":[{\"id\":\"-496486493_0\",\"name\":\"body assertion with healthy hooks\",\"state\":\"failed\",\"errors\":[{\"name\":\"AssertionError\"}],\"hooks\":[\"pass\",\"pass\"],\"diagnostic\":{\"retryCount\":0,\"repeatCount\":0,\"flaky\":false,\"duration\":3.904875000000004}}]}]}\n";
+}, {
+    readonly name: "hook-attribution/successful-hooks-pass.test.js";
+    readonly expected: "pass";
+    readonly exitCode: 0;
+    readonly stdout: "ROUTEKIT_VITEST_EVIDENCE_V1 {\"version\":1,\"complete\":true,\"starts\":1,\"ends\":1,\"reason\":\"passed\",\"eventIntegrity\":true,\"unfinishedHooks\":false,\"completedTestIds\":[\"-1264882018_0\"],\"unhandledErrors\":[],\"modules\":[{\"id\":\"-1264882018\",\"state\":\"passed\",\"errors\":[],\"hooks\":[],\"suites\":[],\"tests\":[{\"id\":\"-1264882018_0\",\"name\":\"body success with healthy hooks\",\"state\":\"passed\",\"errors\":[],\"hooks\":[\"pass\",\"pass\"],\"diagnostic\":{\"retryCount\":0,\"repeatCount\":0,\"flaky\":false,\"duration\":0.6971669999999932}}]}]}\n";
+}, {
+    readonly name: "hook-attribution/nested-before-all.test.js";
+    readonly expected: "unknown";
+    readonly exitCode: 1;
+    readonly stdout: "ROUTEKIT_VITEST_EVIDENCE_V1 {\"version\":1,\"complete\":true,\"starts\":1,\"ends\":1,\"reason\":\"failed\",\"eventIntegrity\":true,\"unfinishedHooks\":true,\"completedTestIds\":[\"747178342_0_0_0\"],\"unhandledErrors\":[],\"modules\":[{\"id\":\"747178342\",\"state\":\"failed\",\"errors\":[],\"hooks\":[],\"suites\":[{\"id\":\"747178342_0\",\"state\":\"failed\",\"errors\":[],\"hooks\":[]},{\"id\":\"747178342_0_0\",\"state\":\"failed\",\"errors\":[{\"name\":\"AssertionError\"}],\"hooks\":[\"run\"]}],\"tests\":[{\"id\":\"747178342_0_0_0\",\"name\":\"unreached body\",\"state\":\"skipped\",\"errors\":[],\"hooks\":[],\"diagnostic\":null}]}]}\n";
+}, {
+    readonly name: "hook-attribution/unhandled-error.test.js";
+    readonly expected: "unknown";
+    readonly exitCode: 1;
+    readonly stdout: "ROUTEKIT_VITEST_EVIDENCE_V1 {\"version\":1,\"complete\":true,\"starts\":1,\"ends\":1,\"reason\":\"passed\",\"eventIntegrity\":true,\"unfinishedHooks\":false,\"completedTestIds\":[\"-1575706821_0\"],\"unhandledErrors\":[{\"name\":\"Error\"}],\"modules\":[{\"id\":\"-1575706821\",\"state\":\"passed\",\"errors\":[],\"hooks\":[],\"suites\":[],\"tests\":[{\"id\":\"-1575706821_0\",\"name\":\"apparently successful body\",\"state\":\"passed\",\"errors\":[],\"hooks\":[],\"diagnostic\":{\"retryCount\":0,\"repeatCount\":0,\"flaky\":false,\"duration\":12.362875000000003}}]}]}\n";
+}];