assertledger 1.0.0

package/benchmarks/self-hosted-core/campaign.ts

@@ -0,0 +1,233 @@
+import { createHash } from "node:crypto";
+
+export const CAMPAIGN_SCHEMA_VERSION = "1.0.0" as const;
+export const CAMPAIGN_ID = "assertledger-self-hosted-core-v1" as const;
+export const CANDIDATE_ROOT = "benchmarks/self-hosted-core/generated-candidates" as const;
+
+export interface MutationDefinition {
+  id: string;
+  description: string;
+  anchor: string;
+  replacement: string;
+}
+
+export const TARGET_MUTATIONS: readonly MutationDefinition[] = [
+  {
+    id: "target-dependent-gate-order",
+    description: "Permute les gates dependantes NEUTRAL et TARGET_STRENGTH.",
+    anchor: 'gates.push(notRun("REFERENCE"), notRun("NEUTRAL"), notRun("TARGET_STRENGTH"));',
+    replacement: 'gates.push(notRun("REFERENCE"), notRun("TARGET_STRENGTH"), notRun("NEUTRAL"));',
+  },
+  {
+    id: "target-threshold-strict-greater",
+    description: "Remplace la borne inclusive du seuil de poids par une borne stricte.",
+    anchor: "targetWeightKilled * 1_000 >= totalWeight * input.policy.minimumTargetWeightPermille;",
+    replacement:
+      "targetWeightKilled * 1_000 > totalWeight * input.policy.minimumTargetWeightPermille;",
+  },
+  {
+    id: "target-stability-completeness-only",
+    description: "Accepte des tentatives completes meme lorsque leurs outcomes se contredisent.",
+    anchor:
+      "if (!isComplete(runs, requiredAttempts)) return false;\n  return runs.every((run) => run.outcome === runs[0]?.outcome);",
+    replacement: "if (!isComplete(runs, requiredAttempts)) return false;\n  return true;",
+  },
+  {
+    id: "target-duration-in-decision-digest",
+    description: "Inclut la duree volatile dans le digest de decision.",
+    anchor: "durationMs: _durationMs,",
+    replacement: "",
+  },
+] as const;
+
+export const NEUTRAL_REWRITE: MutationDefinition = {
+  id: "neutral-comparator-rewrite",
+  description: "Reecrit la collecte des runs NEUTRAL sans changer son comportement.",
+  anchor: `const neutralRuns = worldRuns
+    .filter(({ world }) => world.kind === "NEUTRAL")
+    .flatMap(({ runs }) => runs);`,
+  replacement: `const neutralRuns = worldRuns.flatMap(({ world, runs }) =>
+    world.kind === "NEUTRAL" ? runs : [],
+  );`,
+};
+
+const COMMON_FIXTURE = `
+function digest(label) {
+  return core.sha256Canonical({ fixture: label });
+}
+
+function observation(candidateId, worldId, attempt, outcome, discovered = candidateId === null ? 0 : 1, attributed = candidateId !== null) {
+  return {
+    runId: \`\${candidateId ?? "control"}:\${worldId}:\${attempt}\`,
+    candidateId,
+    worldId,
+    attempt,
+    outcome,
+    testsDiscovered: candidateId === null ? 1 : 2,
+    candidateTestsDiscovered: discovered,
+    attributed,
+    durationMs: 10 + attempt,
+    exitCode: outcome === "PASS" ? 0 : 1,
+    stdoutDigest: digest(\`stdout:\${candidateId ?? "control"}:\${worldId}:\${attempt}\`),
+    stderrDigest: digest(\`stderr:\${candidateId ?? "control"}:\${worldId}:\${attempt}\`),
+  };
+}
+
+function campaign() {
+  const worlds = [
+    { id: "reference", kind: "REFERENCE", required: true, weight: 0 },
+    { id: "target-a", kind: "TARGET", required: true, weight: 1 },
+    { id: "target-b", kind: "TARGET", required: false, weight: 1 },
+    { id: "neutral", kind: "NEUTRAL", required: true, weight: 0 },
+  ];
+  const observations = worlds.flatMap((world) => [
+    observation(null, world.id, 1, "PASS"),
+    observation(null, world.id, 2, "PASS"),
+    observation("candidate", world.id, 1, world.kind === "TARGET" ? "ASSERTION_FAILURE" : "PASS"),
+    observation("candidate", world.id, 2, world.kind === "TARGET" ? "ASSERTION_FAILURE" : "PASS"),
+  ]);
+  return {
+    schemaVersion: "1.0.0",
+    repositoryDigest: digest("repository"),
+    evidenceContext: {
+      engine: { name: "testforge", version: "0.1.0" },
+      adapter: { name: "node-test", version: process.versions.node, configuration: {} },
+      execution: {
+        isolation: "UNSANDBOXED",
+        environmentAllowlist: [],
+        budgets: { timeoutMsPerExecution: 1000, maximumOutputBytes: 65536 },
+        candidateRoots: ["tests/candidates"],
+      },
+      worlds: worlds.map((world) => ({
+        id: world.id,
+        provenance: \`fixture:\${world.id}\`,
+        digest: digest(\`world:\${world.id}\`),
+      })),
+    },
+    policy: {
+      policyVersion: "1.0.0",
+      requiredAttempts: 2,
+      minimumTargetWeightPermille: 1000,
+      maximumSelectedCandidates: 1,
+      acceptedTargetOutcomes: ["ASSERTION_FAILURE"],
+    },
+    worlds,
+    candidates: [{ id: "candidate", digest: digest("candidate"), sizeBytes: 100 }],
+    observations,
+  };
+}
+`;
+
+function candidateSource(name: string, body: string): string {
+  return `import assert from "node:assert/strict";\nimport { test } from "node:test";\nimport * as core from "../../../../src/core/index.js";\n${COMMON_FIXTURE}\ntest(${JSON.stringify(name)}, () => {\n${body}\n});\n`;
+}
+
+export const TEST_SLICES = {
+  gateOrder: candidateSource(
+    "dependent gates retain their public order",
+    `  const input = campaign();
+  for (const run of input.observations) {
+    if (run.candidateId === "candidate") run.candidateTestsDiscovered = 0;
+  }
+  const manifest = core.decideEvidence(input);
+  assert.deepEqual(manifest.candidates[0].gates.map((gate) => gate.name), [
+    "COMPLETENESS", "STABILITY", "DISCOVERY", "REFERENCE", "NEUTRAL", "TARGET_STRENGTH",
+  ]);`,
+  ),
+  thresholdBoundary: candidateSource(
+    "the exact target threshold is inclusive",
+    `  const input = campaign();
+  input.policy.minimumTargetWeightPermille = 500;
+  for (const run of input.observations) {
+    if (run.candidateId === "candidate" && run.worldId === "target-b") run.outcome = "PASS";
+  }
+  const manifest = core.decideEvidence(input);
+  assert.equal(manifest.decision.status, "VERIFIED");`,
+  ),
+  contradictoryStability: candidateSource(
+    "contradictory attempts are unstable",
+    `  const input = campaign();
+  const contradictory = input.observations.find((run) =>
+    run.candidateId === "candidate" && run.worldId === "reference" && run.attempt === 2,
+  );
+  assert.ok(contradictory);
+  contradictory.outcome = "ASSERTION_FAILURE";
+  const manifest = core.decideEvidence(input);
+  assert.equal(manifest.decision.status, "INCONCLUSIVE");
+  assert.equal(manifest.candidates[0].status, "UNSTABLE");`,
+  ),
+  durationExclusion: candidateSource(
+    "duration is excluded from the decision digest",
+    `  const manifest = core.decideEvidence(campaign());
+  manifest.observations[0].durationMs += 1;
+  assert.equal(core.verifyDecisionDigest(manifest).valid, true);`,
+  ),
+} as const;
+
+export interface CandidateDefinition {
+  id: string;
+  files: readonly { name: string; content: string }[];
+}
+
+export const CANDIDATE_DEFINITIONS: readonly CandidateDefinition[] = [
+  { id: "gate-order", files: [{ name: "gate-order.test.ts", content: TEST_SLICES.gateOrder }] },
+  {
+    id: "threshold-boundary",
+    files: [{ name: "threshold-boundary.test.ts", content: TEST_SLICES.thresholdBoundary }],
+  },
+  {
+    id: "contradictory-stability",
+    files: [
+      { name: "contradictory-stability.test.ts", content: TEST_SLICES.contradictoryStability },
+    ],
+  },
+  {
+    id: "duration-exclusion",
+    files: [{ name: "duration-exclusion.test.ts", content: TEST_SLICES.durationExclusion }],
+  },
+  {
+    id: "core-contract-complete",
+    files: [
+      { name: "gate-order.test.ts", content: TEST_SLICES.gateOrder },
+      { name: "threshold-boundary.test.ts", content: TEST_SLICES.thresholdBoundary },
+      { name: "contradictory-stability.test.ts", content: TEST_SLICES.contradictoryStability },
+      { name: "duration-exclusion.test.ts", content: TEST_SLICES.durationExclusion },
+    ],
+  },
+  {
+    id: "weak-canonicalization",
+    files: [
+      {
+        name: "weak-canonicalization.test.ts",
+        content: candidateSource(
+          "canonicalization ignores object insertion order",
+          `  assert.equal(core.canonicalize({ b: 2, a: 1 }), core.canonicalize({ a: 1, b: 2 }));`,
+        ),
+      },
+    ],
+  },
+  {
+    id: "weak-safe-path",
+    files: [
+      {
+        name: "weak-safe-path.test.ts",
+        content: candidateSource(
+          "safe relative paths are normalized",
+          `  assert.equal(core.assertSafeRelativePath("tests/example.test.ts", ["tests"]), "tests/example.test.ts");`,
+        ),
+      },
+    ],
+  },
+] as const;
+
+export function sha256Bytes(content: string | Buffer): string {
+  return `sha256:${createHash("sha256").update(content).digest("hex")}`;
+}
+
+export function replaceExactlyOnce(source: string, definition: MutationDefinition): string {
+  const first = source.indexOf(definition.anchor);
+  if (first < 0 || source.indexOf(definition.anchor, first + definition.anchor.length) >= 0) {
+    throw new Error(`MUTATION_ANCHOR_NOT_UNIQUE:${definition.id}`);
+  }
+  return `${source.slice(0, first)}${definition.replacement}${source.slice(first + definition.anchor.length)}`;
+}

package/benchmarks/self-hosted-core/existing-tests-builder.ts

@@ -0,0 +1,217 @@
+import { mkdir, readFile, realpath, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseVerificationRequest } from "../../src/contracts/index.js";
+import {
+  CAMPAIGN_SCHEMA_VERSION,
+  NEUTRAL_REWRITE,
+  replaceExactlyOnce,
+  sha256Bytes,
+  TARGET_MUTATIONS,
+} from "./campaign.js";
+import {
+  buildExistingTestCandidates,
+  EXISTING_TESTS_CAMPAIGN_ID,
+  EXISTING_TESTS_CANDIDATE_ROOT,
+  EXISTING_TESTS_SNAPSHOT_COUNT,
+  EXISTING_TESTS_SOURCE_PATH,
+  extractExistingCoreTests,
+} from "./existing-tests.js";
+
+interface ExistingTestsOperatorPlan {
+  schemaVersion: "1.0.0";
+  campaignId: typeof EXISTING_TESTS_CAMPAIGN_ID;
+  repositoryRoot: string;
+  sourceTestCount: typeof EXISTING_TESTS_SNAPSHOT_COUNT;
+  targetIds: string[];
+  requiredAttempts: 2;
+  minimumTargetWeightPermille: 250;
+  maximumSelectedCandidates: typeof EXISTING_TESTS_SNAPSHOT_COUNT;
+}
+
+function stableJson(value: unknown): string {
+  const sort = (item: unknown): unknown => {
+    if (Array.isArray(item)) return item.map(sort);
+    if (typeof item !== "object" || item === null) return item;
+    return Object.fromEntries(
+      Object.entries(item)
+        .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
+        .map(([key, entry]) => [key, sort(entry)]),
+    );
+  };
+  return `${JSON.stringify(sort(value), null, 2)}\n`;
+}
+
+function parseOperatorPlan(value: unknown): ExistingTestsOperatorPlan {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error("INVALID_EXISTING_TESTS_OPERATOR_PLAN");
+  }
+  const plan = value as Record<string, unknown>;
+  const expected = [
+    "campaignId",
+    "maximumSelectedCandidates",
+    "minimumTargetWeightPermille",
+    "repositoryRoot",
+    "requiredAttempts",
+    "schemaVersion",
+    "sourceTestCount",
+    "targetIds",
+  ].sort();
+  if (
+    Object.keys(plan).sort().join("\0") !== expected.join("\0") ||
+    plan.schemaVersion !== CAMPAIGN_SCHEMA_VERSION ||
+    plan.campaignId !== EXISTING_TESTS_CAMPAIGN_ID ||
+    typeof plan.repositoryRoot !== "string" ||
+    plan.repositoryRoot.length === 0 ||
+    plan.sourceTestCount !== EXISTING_TESTS_SNAPSHOT_COUNT ||
+    plan.requiredAttempts !== 2 ||
+    plan.minimumTargetWeightPermille !== 250 ||
+    plan.maximumSelectedCandidates !== EXISTING_TESTS_SNAPSHOT_COUNT ||
+    !Array.isArray(plan.targetIds) ||
+    plan.targetIds.join("\0") !== TARGET_MUTATIONS.map(({ id }) => id).join("\0")
+  ) {
+    throw new Error("INVALID_EXISTING_TESTS_OPERATOR_PLAN");
+  }
+  return plan as unknown as ExistingTestsOperatorPlan;
+}
+
+export async function buildExistingCoreTestsCampaign(options: {
+  operatorPlanPath: string;
+  expectedOperatorPlanDigest: string;
+  outputDirectory: string;
+}): Promise<{ request: ReturnType<typeof parseVerificationRequest>; files: string[] }> {
+  const planBytes = await readFile(options.operatorPlanPath);
+  if (sha256Bytes(planBytes) !== options.expectedOperatorPlanDigest) {
+    throw new Error("OPERATOR_PLAN_DIGEST_MISMATCH");
+  }
+  const plan = parseOperatorPlan(JSON.parse(planBytes.toString("utf8")) as unknown);
+  const repositoryRoot = path.resolve(plan.repositoryRoot);
+  const dependencyRoot = await realpath(path.join(repositoryRoot, "node_modules"));
+  if (!(await stat(dependencyRoot)).isDirectory()) throw new Error("DEPENDENCY_ROOT_NOT_DIRECTORY");
+  const coreSource = await readFile(path.join(repositoryRoot, "src/core/index.ts"), "utf8");
+  const testSourcePath = path.join(repositoryRoot, EXISTING_TESTS_SOURCE_PATH);
+  const testSource = await readFile(testSourcePath, "utf8");
+  const extracted = buildExistingTestCandidates(
+    testSource,
+    extractExistingCoreTests(testSourcePath),
+  );
+  if (extracted.catalogue.length !== plan.sourceTestCount) {
+    throw new Error(
+      `CORE_TEST_COUNT_DRIFT:expected=${plan.sourceTestCount}:actual=${extracted.catalogue.length}`,
+    );
+  }
+  const corePath = "src/core/index.ts";
+  const worlds = [
+    {
+      id: "reference",
+      kind: "REFERENCE" as const,
+      required: true,
+      weight: 0,
+      provenance: `${EXISTING_TESTS_CAMPAIGN_ID}:reference`,
+      files: [],
+    },
+    {
+      id: NEUTRAL_REWRITE.id,
+      kind: "NEUTRAL" as const,
+      required: true,
+      weight: 0,
+      provenance: `${EXISTING_TESTS_CAMPAIGN_ID}:${NEUTRAL_REWRITE.id}`,
+      files: [{ path: corePath, content: replaceExactlyOnce(coreSource, NEUTRAL_REWRITE) }],
+    },
+    ...TARGET_MUTATIONS.map((target) => ({
+      id: target.id,
+      kind: "TARGET" as const,
+      required: true,
+      weight: 250,
+      provenance: `${EXISTING_TESTS_CAMPAIGN_ID}:${target.id}`,
+      files: [{ path: corePath, content: replaceExactlyOnce(coreSource, target) }],
+    })),
+  ];
+  const candidates = extracted.candidates.map((candidate) => ({
+    id: candidate.id,
+    files: candidate.files.map((file) => ({
+      path: `${EXISTING_TESTS_CANDIDATE_ROOT}/${candidate.id}/${file.name}`,
+      content: file.content,
+    })),
+  }));
+  const maximumExecutions = (1 + candidates.length) * worlds.length * plan.requiredAttempts;
+  const request = parseVerificationRequest({
+    schemaVersion: "1.0.0",
+    repository: {
+      root: repositoryRoot,
+      exclude: ["node_modules", ".git", "graphify-out", "RESULT-existing-tests-v1.md"],
+    },
+    adapter: {
+      kind: "testforge-command",
+      executable: process.execPath,
+      arguments: ["benchmarks/self-hosted-core/adapter.mjs", dependencyRoot],
+      protocolVersion: "1.0.0",
+    },
+    isolation: {
+      kind: "trusted-local",
+      acknowledgedUnsafeExecution: true,
+      environmentAllowlist: ["PATH", "SystemRoot", "TEMP", "TMP"],
+    },
+    candidateRoots: [EXISTING_TESTS_CANDIDATE_ROOT],
+    budgets: {
+      maximumCandidates: candidates.length,
+      maximumWorlds: worlds.length,
+      maximumExecutions,
+      maximumRepositoryFiles: 10_000,
+      maximumRepositoryBytes: 100_000_000,
+      maximumWorldOverlayBytes: 10_000_000,
+      maximumCandidateBytes: 1_000_000,
+      maximumTotalCandidateBytes: 5_000_000,
+      timeoutMsPerExecution: 30_000,
+      maximumOutputBytes: 1_000_000,
+    },
+    policy: {
+      policyVersion: "1.0.0",
+      requiredAttempts: plan.requiredAttempts,
+      minimumTargetWeightPermille: plan.minimumTargetWeightPermille,
+      maximumSelectedCandidates: plan.maximumSelectedCandidates,
+      acceptedTargetOutcomes: ["ASSERTION_FAILURE"],
+    },
+    worlds,
+    candidates,
+  });
+
+  const artifacts = new Map<string, string>();
+  artifacts.set("operator-plan.json", planBytes.toString("utf8"));
+  artifacts.set("request.json", stableJson(request));
+  artifacts.set("worlds.json", stableJson(worlds));
+  artifacts.set("candidates.json", stableJson(candidates));
+  artifacts.set("existing-test-catalogue.json", stableJson(extracted.catalogue));
+  artifacts.set(
+    "mutation-definitions.json",
+    stableJson({ neutral: NEUTRAL_REWRITE, targets: TARGET_MUTATIONS }),
+  );
+  await mkdir(options.outputDirectory, { recursive: true });
+  const files = [...artifacts.keys()].sort();
+  for (const file of files) {
+    await writeFile(
+      path.join(options.outputDirectory, file),
+      artifacts.get(file) as string,
+      "utf8",
+    );
+  }
+  return { request, files };
+}
+
+async function main(): Promise<void> {
+  const [operatorPlanPath, expectedOperatorPlanDigest, outputDirectory] = process.argv.slice(2);
+  if (!operatorPlanPath || !expectedOperatorPlanDigest || !outputDirectory) {
+    throw new Error(
+      "usage: existing-tests-builder.ts OPERATOR_PLAN EXPECTED_SHA256 OUTPUT_DIRECTORY",
+    );
+  }
+  await buildExistingCoreTestsCampaign({
+    operatorPlanPath,
+    expectedOperatorPlanDigest,
+    outputDirectory,
+  });
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  await main();
+}

package/benchmarks/self-hosted-core/existing-tests.ts

@@ -0,0 +1,146 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import {
+  isCallExpression,
+  isIdentifier,
+  isStringLiteral,
+  type Node,
+  visitEachChild,
+} from "typescript/unstable/ast";
+import { API } from "typescript/unstable/sync";
+import { sha256Bytes } from "./campaign.js";
+
+export const EXISTING_TESTS_CAMPAIGN_ID =
+  "assertledger-self-hosted-core-existing-tests-v1" as const;
+export const EXISTING_TESTS_CANDIDATE_ROOT =
+  "benchmarks/self-hosted-core/generated-existing-test-candidates" as const;
+export const EXISTING_TESTS_SOURCE_PATH = "tests/core.test.ts" as const;
+export const EXISTING_TESTS_SNAPSHOT_COUNT = 36 as const;
+
+export interface ExistingTestCase {
+  id: string;
+  ordinal: number;
+  title: string;
+  pattern: string;
+}
+
+export interface ExistingTestSelection {
+  schemaVersion: "1.0.0";
+  mode: "existing-core-test";
+  candidateId: string;
+  title: string;
+  pattern: string;
+  sourcePath: string;
+  sourceDigest: string;
+}
+
+export interface ExistingTestCandidate {
+  id: string;
+  files: readonly { name: string; content: string }[];
+}
+
+function stableJson(value: unknown): string {
+  const sort = (item: unknown): unknown => {
+    if (Array.isArray(item)) return item.map(sort);
+    if (typeof item !== "object" || item === null) return item;
+    return Object.fromEntries(
+      Object.entries(item)
+        .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
+        .map(([key, entry]) => [key, sort(entry)]),
+    );
+  };
+  return `${JSON.stringify(sort(value), null, 2)}\n`;
+}
+
+function exactPattern(title: string): string {
+  return `^${title.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`;
+}
+
+function stableId(title: string): string {
+  return `core-it-${createHash("sha256").update(title).digest("hex").slice(0, 16)}`;
+}
+
+export function extractExistingCoreTests(sourcePath: string): readonly ExistingTestCase[] {
+  const absolutePath = path.resolve(sourcePath);
+  const api = new API({ cwd: path.dirname(absolutePath) });
+  const titles: string[] = [];
+  try {
+    const snapshot = api.updateSnapshot({ openFiles: [absolutePath] });
+    const project = snapshot.getDefaultProjectForFile(absolutePath);
+    const sourceFile = project?.program.getSourceFile(absolutePath);
+    if (!project || !sourceFile) throw new Error("CORE_TEST_SOURCE_NOT_IN_TYPESCRIPT_PROJECT");
+    if (project.program.getSyntacticDiagnostics(absolutePath).length > 0) {
+      throw new Error("CORE_TEST_SOURCE_SYNTAX_INVALID");
+    }
+    const visit = (node: Node): void => {
+      if (
+        isCallExpression(node) &&
+        isIdentifier(node.expression) &&
+        node.expression.text === "it"
+      ) {
+        const title = node.arguments[0];
+        if (!title || !isStringLiteral(title)) throw new Error("CORE_TEST_TITLE_NOT_LITERAL");
+        titles.push(title.text);
+      }
+      visitEachChild(node, (child) => {
+        visit(child);
+        return child;
+      });
+    };
+    visit(sourceFile);
+  } finally {
+    api.close();
+  }
+
+  const seenTitles = new Set<string>();
+  const seenIds = new Set<string>();
+  return titles.map((title, index) => {
+    if (seenTitles.has(title)) throw new Error(`CORE_TEST_TITLE_COLLISION:${title}`);
+    seenTitles.add(title);
+    const id = stableId(title);
+    if (seenIds.has(id)) throw new Error(`CORE_TEST_ID_COLLISION:${id}`);
+    seenIds.add(id);
+    return { id, ordinal: index + 1, title, pattern: exactPattern(title) };
+  });
+}
+
+export function adaptExistingCoreTestSource(source: string): string {
+  const original = 'import("../src/core/index.js")';
+  const adapted = 'import("../../../../src/core/index.js")';
+  const first = source.indexOf(original);
+  if (first < 0 || source.indexOf(original, first + original.length) >= 0) {
+    throw new Error("CORE_TEST_IMPORT_NOT_UNIQUE");
+  }
+  return `${source.slice(0, first)}${adapted}${source.slice(first + original.length)}`;
+}
+
+export function buildExistingTestCandidates(
+  source: string,
+  catalogue: readonly ExistingTestCase[],
+): {
+  catalogue: readonly ExistingTestCase[];
+  candidates: readonly ExistingTestCandidate[];
+  adaptedSource: string;
+} {
+  const adaptedSource = adaptExistingCoreTestSource(source);
+  const sourceDigest = sha256Bytes(adaptedSource);
+  const candidates = catalogue.map((testCase) => {
+    const selection: ExistingTestSelection = {
+      schemaVersion: "1.0.0",
+      mode: "existing-core-test",
+      candidateId: testCase.id,
+      title: testCase.title,
+      pattern: testCase.pattern,
+      sourcePath: "core.test.ts",
+      sourceDigest,
+    };
+    return {
+      id: testCase.id,
+      files: [
+        { name: "core.test.ts", content: adaptedSource },
+        { name: "selection.json", content: stableJson(selection) },
+      ],
+    };
+  });
+  return { catalogue, candidates, adaptedSource };
+}

package/benchmarks/self-hosted-core/liveness.test.mjs

@@ -0,0 +1,8 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import * as core from "../../src/core/index.js";
+
+test("the self-hosted adapter can import the mutated core surface", () => {
+  assert.equal(typeof core.decideEvidence, "function");
+  assert.equal(typeof core.verifyDecisionDigest, "function");
+});