assertledger 1.1.0 → 1.2.0

package/integrations/bun/assertions.mjs

@@ -0,0 +1,25 @@
+const ASSERTION_ERROR_NAME = "AssertLedgerBunAssertionError";
+const ASSERTION_ERROR_MESSAGE = "AssertLedger assertSame failed";
+const issuedErrors = new WeakSet();
+const addIssuedError = WeakSet.prototype.add.bind(issuedErrors);
+const hasIssuedError = WeakSet.prototype.has.bind(issuedErrors);
+
+class AssertLedgerBunAssertionError extends Error {
+  constructor() {
+    super(ASSERTION_ERROR_MESSAGE);
+    this.name = ASSERTION_ERROR_NAME;
+  }
+}
+
+export function assertSame(actual, expected) {
+  if (!Object.is(actual, expected)) {
+    const error = new AssertLedgerBunAssertionError();
+    addIssuedError(error);
+    throw error;
+  }
+}
+
+/** @internal Identifies an error instance issued by this helper. */
+export function isAssertSameFailure(error) {
+  return typeof error === "object" && error !== null && hasIssuedError(error);
+}

package/integrations/bun/driver.d.mts

@@ -0,0 +1,27 @@
+export interface BunInstrumentedResult {
+  protocolVersion: "1.0.0";
+  outcome:
+    | "PASS"
+    | "ASSERTION_FAILURE"
+    | "PROCESS_CRASH"
+    | "TIMEOUT"
+    | "INFRA_ERROR"
+    | "NO_TEST_DISCOVERED";
+  testsDiscovered: number;
+  candidateTestsDiscovered: number;
+  attributed: boolean;
+}
+
+export type BunTestEvent =
+  | { kind: "found"; id: string; file: string }
+  | { kind: "end"; id: string; status: "pass" | "fail"; owned: boolean }
+  | { kind: "hook-error" };
+
+export function classifyBunInstrumentedEvidence(
+  events: readonly BunTestEvent[] | undefined,
+  junit: { tests: number; failures: number; skipped: number } | undefined,
+  baseFiles: ReadonlySet<string>,
+  candidateFiles: ReadonlySet<string>,
+  exitCode: number | null,
+  operationalError?: boolean,
+): BunInstrumentedResult;

package/integrations/bun/driver.mjs

@@ -0,0 +1,383 @@
+import { spawn, spawnSync } from "node:child_process";
+import { createHmac, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
+import { lstat, mkdir, readFile, realpath, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const RESULT_VERSION = "1.0.0";
+const BUN_REVISION = "1.4.2+744846f84";
+const MAX_REPORT_BYTES = 8 * 1024 * 1024;
+const MAX_OUTPUT_BYTES = 64 * 1024;
+const ANSI_SGR = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "gu");
+const PRELOAD_SOURCE_PATH = fileURLToPath(new URL("./preload.mjs", import.meta.url));
+
+function report(outcome, testsDiscovered = 0, candidateTestsDiscovered = 0, attributed = false) {
+  return {
+    protocolVersion: RESULT_VERSION,
+    outcome,
+    testsDiscovered,
+    candidateTestsDiscovered,
+    attributed,
+  };
+}
+
+function infrastructureFailure(reason) {
+  console.error(`BUN_TEST_INFRA_ERROR:${reason}`);
+  return report("INFRA_ERROR");
+}
+
+function normalizeRelativeFile(value) {
+  if (
+    typeof value !== "string" ||
+    value.length === 0 ||
+    value.startsWith("-") ||
+    path.isAbsolute(value)
+  )
+    return undefined;
+  const normalized = path.normalize(value);
+  if (normalized === ".." || normalized.startsWith(`..${path.sep}`)) return undefined;
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+
+function normalizeAbsoluteFile(value, root) {
+  if (typeof value !== "string" || !path.isAbsolute(value)) return undefined;
+  const relative = path.relative(root, path.resolve(value));
+  return normalizeRelativeFile(relative);
+}
+
+function strictInteger(value) {
+  if (typeof value !== "string" || !/^(0|[1-9][0-9]*)$/u.test(value)) return undefined;
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) ? parsed : undefined;
+}
+
+function parseJunitSummary(xml) {
+  if (
+    typeof xml !== "string" ||
+    !xml.startsWith('<?xml version="1.0" encoding="UTF-8"?>') ||
+    !xml.trimEnd().endsWith("</testsuites>") ||
+    xml.includes("<!DOCTYPE")
+  )
+    return undefined;
+  const root = xml.match(/<testsuites\b([^>]*)>/u);
+  if (root === null) return undefined;
+  const attributes = new Map();
+  const matches = [...root[1].matchAll(/\s+([A-Za-z][A-Za-z0-9-]*)="([^"]*)"/gu)];
+  if (root[1].replace(/\s+([A-Za-z][A-Za-z0-9-]*)="([^"]*)"/gu, "").trim() !== "") {
+    return undefined;
+  }
+  for (const match of matches) {
+    if (attributes.has(match[1])) return undefined;
+    attributes.set(match[1], match[2]);
+  }
+  if (attributes.get("name") !== "bun test") return undefined;
+  const tests = strictInteger(attributes.get("tests"));
+  const failures = strictInteger(attributes.get("failures"));
+  const skipped = strictInteger(attributes.get("skipped"));
+  if (
+    tests === undefined ||
+    failures === undefined ||
+    skipped === undefined ||
+    failures > tests ||
+    skipped > tests
+  ) {
+    return undefined;
+  }
+  return { tests, failures, skipped };
+}
+
+function parseEvents(content, root, allowedFiles, evidenceKey) {
+  if (!content.endsWith("\n")) return undefined;
+  const lines = content.trimEnd().split("\n");
+  if (lines.length === 1 && lines[0] === "") return [];
+  const events = [];
+  for (const line of lines) {
+    let envelope;
+    try {
+      envelope = JSON.parse(line);
+    } catch {
+      return undefined;
+    }
+    if (
+      typeof envelope !== "object" ||
+      envelope === null ||
+      Array.isArray(envelope) ||
+      Object.keys(envelope).sort().join(",") !== "event,mac" ||
+      typeof envelope.mac !== "string" ||
+      !/^[0-9a-f]{64}$/u.test(envelope.mac)
+    )
+      return undefined;
+    const expectedMac = createHmac("sha256", evidenceKey)
+      .update(JSON.stringify(envelope.event))
+      .digest();
+    if (!timingSafeEqual(expectedMac, Buffer.from(envelope.mac, "hex"))) return undefined;
+    const value = envelope.event;
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      return undefined;
+    }
+    if (value.kind === "hook-error") {
+      if (Object.keys(value).join(",") !== "kind") return undefined;
+      events.push({ kind: "hook-error" });
+      continue;
+    }
+    if (typeof value.id !== "string" || !/^[0-9a-f-]{36}$/u.test(value.id)) {
+      return undefined;
+    }
+    if (value.kind === "found") {
+      if (Object.keys(value).sort().join(",") !== "file,id,kind") return undefined;
+      const file = normalizeAbsoluteFile(value.file, root);
+      if (file === undefined || !allowedFiles.has(file)) return undefined;
+      events.push({ kind: "found", id: value.id, file });
+    } else if (value.kind === "end") {
+      if (value.status !== "pass" && value.status !== "fail") return undefined;
+      const expectedKeys = value.status === "pass" ? "id,kind,status" : "id,kind,owned,status";
+      if (Object.keys(value).sort().join(",") !== expectedKeys) return undefined;
+      if (value.status === "fail" && typeof value.owned !== "boolean") return undefined;
+      events.push({ kind: "end", id: value.id, status: value.status, owned: value.owned ?? false });
+    } else return undefined;
+  }
+  return events;
+}
+
+export function classifyBunInstrumentedEvidence(
+  events,
+  junit,
+  baseFiles,
+  candidateFiles,
+  exitCode,
+  operationalError = false,
+) {
+  if (
+    events === undefined ||
+    junit === undefined ||
+    exitCode === null ||
+    junit.skipped !== 0 ||
+    operationalError ||
+    events.some((event) => event.kind === "hook-error")
+  ) {
+    return infrastructureFailure("INCOMPLETE_CONTROLLED_REPORT");
+  }
+  const found = new Map();
+  const ended = new Map();
+  for (const event of events) {
+    if (event.kind === "found") {
+      if (found.has(event.id)) return infrastructureFailure("DUPLICATE_TEST_ID");
+      found.set(event.id, event.file);
+    } else {
+      if (!found.has(event.id)) return infrastructureFailure("UNMATCHED_TEST_END");
+      if (ended.has(event.id)) return infrastructureFailure("DUPLICATE_TEST_END");
+      ended.set(event.id, event);
+    }
+  }
+  const completed = [...ended.values()];
+  if (found.size === 0 || found.size !== ended.size || completed.length !== junit.tests) {
+    return infrastructureFailure("TEST_COUNT_MISMATCH");
+  }
+  const files = new Set(found.values());
+  if ([...baseFiles].some((file) => !files.has(file))) {
+    return infrastructureFailure("BASE_TEST_FILE_NOT_STARTED");
+  }
+  if ([...files].some((file) => !baseFiles.has(file) && !candidateFiles.has(file))) {
+    return infrastructureFailure("UNEXPECTED_TEST_FILE");
+  }
+  const failures = completed.filter((entry) => entry.status === "fail");
+  if (failures.length !== junit.failures || (exitCode === 0) !== (junit.failures === 0)) {
+    return infrastructureFailure("BUN_STATUS_MISMATCH");
+  }
+  const candidateIds = completed
+    .filter((entry) => candidateFiles.has(found.get(entry.id)))
+    .map((entry) => entry.id);
+  if (exitCode === 0) {
+    return candidateFiles.size > 0 && candidateIds.length === 0
+      ? report("NO_TEST_DISCOVERED", completed.length, 0, false)
+      : report("PASS", completed.length, candidateIds.length, candidateFiles.size > 0);
+  }
+  const candidateFailures = failures.filter((entry) => candidateFiles.has(found.get(entry.id)));
+  const baseFailures = failures.filter((entry) => baseFiles.has(found.get(entry.id)));
+  if (baseFailures.length > 0 || candidateIds.length === 0) {
+    return report("PROCESS_CRASH", completed.length, candidateIds.length, false);
+  }
+  const attributed =
+    candidateFailures.length > 0 &&
+    failures.length === candidateFailures.length &&
+    candidateFailures.every((entry) => entry.owned);
+  return report(
+    attributed ? "ASSERTION_FAILURE" : "PROCESS_CRASH",
+    completed.length,
+    candidateIds.length,
+    attributed,
+  );
+}
+
+async function readBoundedRegularFile(file, root) {
+  const details = await lstat(file);
+  if (!details.isFile() || details.size > MAX_REPORT_BYTES) throw new Error("INVALID_REPORT_FILE");
+  const resolved = await realpath(file);
+  const relative = path.relative(root, resolved);
+  if (
+    relative === "" ||
+    relative === ".." ||
+    relative.startsWith(`..${path.sep}`) ||
+    path.isAbsolute(relative)
+  ) {
+    throw new Error("REPORT_PATH_ESCAPE");
+  }
+  return readFile(file, "utf8");
+}
+
+async function installHelper(helperSource, root) {
+  const packageRoot = path.join(root, "node_modules", "assertledger");
+  await mkdir(packageRoot, { recursive: true });
+  await writeFile(path.join(packageRoot, "bun.mjs"), helperSource, { flag: "wx" });
+  await writeFile(
+    path.join(packageRoot, "preload.mjs"),
+    await readFile(PRELOAD_SOURCE_PATH, "utf8"),
+    { flag: "wx" },
+  );
+  await writeFile(
+    path.join(packageRoot, "package.json"),
+    `${JSON.stringify({ name: "assertledger", type: "module", exports: { "./bun": "./bun.mjs" } }, null, 2)}\n`,
+    { flag: "wx" },
+  );
+}
+
+async function runBun(executable, files, junitFile, root, evidenceKey) {
+  const exactPath = (file) => `./${file.replaceAll(path.sep, "/")}`;
+  const childEnvironment = { ...process.env };
+  delete childEnvironment.TESTFORGE_RESULT_FILE;
+  delete childEnvironment.TESTFORGE_CANDIDATE_FILES;
+  delete childEnvironment.ASSERTLEDGER_BUN_EVENTS_FILE;
+  childEnvironment.ASSERTLEDGER_BUN_ROOT = root;
+  const child = spawn(
+    executable,
+    [
+      "test",
+      "--max-concurrency=1",
+      "--retry=0",
+      "--preload",
+      "./node_modules/assertledger/preload.mjs",
+      "--reporter=junit",
+      `--reporter-outfile=${junitFile}`,
+      ...files.map(exactPath),
+    ],
+    {
+      cwd: root,
+      env: childEnvironment,
+      shell: false,
+      stdio: ["ignore", "pipe", "pipe", "pipe", "pipe"],
+    },
+  );
+  let keyDeliveryError = false;
+  child.stdio[4].on("error", () => {
+    keyDeliveryError = true;
+  });
+  child.stdio[4].end(evidenceKey);
+  let outputBytes = 0;
+  let overflow = false;
+  let stderr = "";
+  let evidenceBytes = 0;
+  const evidenceChunks = [];
+  const collect = (chunk) => {
+    outputBytes += chunk.length;
+    if (outputBytes > MAX_OUTPUT_BYTES) {
+      overflow = true;
+      child.kill();
+    }
+  };
+  child.stdout.on("data", collect);
+  child.stderr.on("data", (chunk) => {
+    collect(chunk);
+    if (!overflow) stderr += chunk.toString("utf8");
+  });
+  child.stdio[3].on("data", (chunk) => {
+    evidenceBytes += chunk.length;
+    if (evidenceBytes > MAX_REPORT_BYTES) {
+      overflow = true;
+      child.kill();
+    } else {
+      evidenceChunks.push(chunk);
+    }
+  });
+  const exitCode = await new Promise((resolve) => {
+    child.once("error", () => resolve(null));
+    child.once("close", (code) => resolve(code));
+  });
+  const plainStderr = stderr.replace(ANSI_SGR, "");
+  const operationalError =
+    plainStderr.includes("Unhandled error between tests") ||
+    /(?:^|\r?\n)\s*[1-9][0-9]*\s+errors?\s*(?:\r?\n|$)/u.test(plainStderr);
+  return {
+    exitCode: overflow || keyDeliveryError ? null : exitCode,
+    operationalError,
+    eventContent: overflow ? undefined : Buffer.concat(evidenceChunks).toString("utf8"),
+  };
+}
+
+async function main() {
+  const root = await realpath(process.cwd());
+  const [executable, helperSourcePath, ...baseTests] = process.argv.slice(2);
+  if (
+    !path.isAbsolute(executable ?? "") ||
+    !path.isAbsolute(helperSourcePath ?? "") ||
+    baseTests.length === 0
+  ) {
+    throw new Error("INVALID_ARGUMENTS");
+  }
+  const revision = spawnSync(executable, ["--revision"], {
+    cwd: process.cwd(),
+    encoding: "utf8",
+    shell: false,
+    windowsHide: true,
+    timeout: 5_000,
+    maxBuffer: MAX_OUTPUT_BYTES,
+  });
+  if (revision.status !== 0 || revision.stderr !== "" || revision.stdout.trim() !== BUN_REVISION) {
+    throw new Error("UNSUPPORTED_BUN_REVISION");
+  }
+  const candidates = JSON.parse(process.env.TESTFORGE_CANDIDATE_FILES ?? "[]");
+  if (!Array.isArray(candidates)) throw new Error("INVALID_CANDIDATES");
+  const normalizedBase = baseTests.map(normalizeRelativeFile);
+  const normalizedCandidates = candidates.map(normalizeRelativeFile);
+  if ([...normalizedBase, ...normalizedCandidates].some((file) => file === undefined)) {
+    throw new Error("INVALID_PATH");
+  }
+  const files = [...normalizedBase, ...normalizedCandidates];
+  if (new Set(files).size !== files.length) throw new Error("DUPLICATE_TEST_FILE");
+  await installHelper(await readFile(helperSourcePath, "utf8"), root);
+  const junitFile = path.join(root, `__assertledger_bun_junit_${randomUUID()}.xml`);
+  const evidenceKey = randomBytes(32);
+  const execution = await runBun(
+    executable,
+    [...baseTests, ...candidates],
+    junitFile,
+    root,
+    evidenceKey,
+  );
+  let outcome;
+  try {
+    const junitContent = await readBoundedRegularFile(junitFile, root);
+    const allowed = new Set(files);
+    outcome = classifyBunInstrumentedEvidence(
+      execution.eventContent === undefined
+        ? undefined
+        : parseEvents(execution.eventContent, root, allowed, evidenceKey),
+      parseJunitSummary(junitContent),
+      new Set(normalizedBase),
+      new Set(normalizedCandidates),
+      execution.exitCode,
+      execution.operationalError,
+    );
+  } catch {
+    outcome = infrastructureFailure("MISSING_OR_INVALID_REPORT");
+  }
+  process.stdout.write(`${JSON.stringify(outcome)}\n`);
+  process.exitCode = outcome.outcome === "PASS" ? 0 : 1;
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) {
+  main().catch((error) => {
+    console.error(error instanceof Error ? error.message : "UNKNOWN_DRIVER_ERROR");
+    process.stdout.write(`${JSON.stringify(report("INFRA_ERROR"))}\n`);
+    process.exitCode = 1;
+  });
+}

package/integrations/bun/preload.mjs

@@ -0,0 +1,165 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createHmac, randomUUID } from "node:crypto";
+import { closeSync, readSync, writeSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import * as assertionHelper from "./bun.mjs";
+import * as bunTest from "bun:test";
+
+const root = process.env.ASSERTLEDGER_BUN_ROOT;
+if (!path.isAbsolute(root ?? "")) {
+  throw new Error("ASSERTLEDGER_BUN_PRELOAD_CONFIGURATION_INVALID");
+}
+
+const preloadPath = fileURLToPath(import.meta.url);
+const safeApply = Reflect.apply.bind(Reflect);
+const safeGet = Reflect.get.bind(Reflect);
+const rawAssertSame = assertionHelper.assertSame;
+const verifyIssuedError = assertionHelper.isAssertSameFailure;
+const issuedDuringTest = new WeakMap();
+const markIssuingTest = WeakMap.prototype.set.bind(issuedDuringTest);
+const issuingTest = WeakMap.prototype.get.bind(issuedDuringTest);
+const activeTestExecution = new AsyncLocalStorage();
+const currentTestId = AsyncLocalStorage.prototype.getStore.bind(activeTestExecution);
+const runInTest = AsyncLocalStorage.prototype.run.bind(activeTestExecution);
+function scopedAssertSame(...arguments_) {
+  try {
+    return safeApply(rawAssertSame, undefined, arguments_);
+  } catch (error) {
+    const id = currentTestId();
+    if (id !== undefined && verifyIssuedError(error)) markIssuingTest(error, id);
+    throw error;
+  }
+}
+const stringify = JSON.stringify.bind(JSON);
+const evidenceKey = Buffer.alloc(32);
+let received = 0;
+while (received < evidenceKey.length) {
+  const length = readSync(4, evidenceKey, received, evidenceKey.length - received, null);
+  if (length === 0) throw new Error("ASSERTLEDGER_BUN_EVIDENCE_KEY_MISSING");
+  received += length;
+}
+closeSync(4);
+function record(event) {
+  const body = stringify(event);
+  const mac = createHmac("sha256", evidenceKey).update(body).digest("hex");
+  writeSync(3, `${stringify({ event, mac })}\n`);
+}
+
+function registrationFile() {
+  const lines = new Error().stack?.split(/\r?\n/u).slice(1) ?? [];
+  for (const line of lines) {
+    let location = line.trim().replace(/^at\s+/u, "");
+    if (location.endsWith(")") && location.includes("(")) {
+      location = location.slice(location.lastIndexOf("(") + 1, -1);
+    }
+    const match = location.match(/^(.+?):\d+(?::\d+)?$/u);
+    if (match === null) continue;
+    let file = match[1];
+    if (file.startsWith("file:")) {
+      try {
+        file = fileURLToPath(file);
+      } catch {
+        continue;
+      }
+    }
+    if (!path.isAbsolute(file)) continue;
+    const absolute = path.resolve(file);
+    if (absolute === preloadPath) continue;
+    return absolute;
+  }
+  throw new Error("ASSERTLEDGER_BUN_REGISTRATION_FILE_UNAVAILABLE");
+}
+
+function wrapRegistration(native, cache) {
+  if (cache.has(native)) return cache.get(native);
+  const wrapper = new Proxy(native, {
+    apply(target, thisArg, arguments_) {
+      const callbackIndex = arguments_.findIndex(
+        (value, index) => typeof value === "function" && (index > 0 || arguments_.length === 1),
+      );
+      if (callbackIndex < 0) {
+        const result = safeApply(target, thisArg, arguments_);
+        return typeof result === "function" ? wrapRegistration(result, cache) : result;
+      }
+      const callback = arguments_[callbackIndex];
+      const file = registrationFile();
+      const wrappedArguments = [...arguments_];
+      wrappedArguments[callbackIndex] = function (...callbackArguments) {
+        const id = randomUUID();
+        record({ kind: "found", id, file });
+        return runInTest(id, () => {
+          const passed = (value) => {
+            record({ kind: "end", id, status: "pass" });
+            return value;
+          };
+          const failed = (error) => {
+            record({
+              kind: "end",
+              id,
+              status: "fail",
+              owned: verifyIssuedError(error) && issuingTest(error) === id,
+            });
+            throw error;
+          };
+          try {
+            const result = safeApply(callback, this, callbackArguments);
+            return result && typeof result.then === "function"
+              ? Promise.resolve(result).then(passed, failed)
+              : passed(result);
+          } catch (error) {
+            return failed(error);
+          }
+        });
+      };
+      return safeApply(target, thisArg, wrappedArguments);
+    },
+    get(target, property, receiver) {
+      const value = safeGet(target, property, receiver);
+      return typeof value === "function" && property !== "constructor"
+        ? wrapRegistration(value.bind(target), cache)
+        : value;
+    },
+  });
+  cache.set(native, wrapper);
+  return wrapper;
+}
+
+function wrapHook(nativeHook) {
+  return (callback, ...options) => {
+    if (typeof callback !== "function")
+      return safeApply(nativeHook, bunTest, [callback, ...options]);
+    const wrappedCallback = function (...arguments_) {
+      const failed = (error) => {
+        record({ kind: "hook-error" });
+        throw error;
+      };
+      try {
+        const result = safeApply(callback, this, arguments_);
+        return result && typeof result.then === "function"
+          ? Promise.resolve(result).catch(failed)
+          : result;
+      } catch (error) {
+        return failed(error);
+      }
+    };
+    return safeApply(nativeHook, bunTest, [wrappedCallback, ...options]);
+  };
+}
+
+const cache = new WeakMap();
+const wrappedTest = wrapRegistration(bunTest.test, cache);
+const wrappedIt = wrapRegistration(bunTest.it, cache);
+bunTest.mock.module("bun:test", () => ({
+  ...bunTest,
+  test: wrappedTest,
+  it: wrappedIt,
+  beforeAll: wrapHook(bunTest.beforeAll),
+  afterAll: wrapHook(bunTest.afterAll),
+  beforeEach: wrapHook(bunTest.beforeEach),
+  afterEach: wrapHook(bunTest.afterEach),
+}));
+bunTest.mock.module("assertledger/bun", () => ({
+  ...assertionHelper,
+  assertSame: scopedAssertSame,
+}));

package/integrations/skill/SKILL.md

@@ -16,7 +16,10 @@ window.
 ## Preferred path: a committed regression
 
 1. Run `assertledger doctor <repo> --json` for static readiness. Runtime probes require the separate
-   `doctor --runtime --allow-unsafe-execution` command and prior operator authorization.
+   `doctor --runtime --allow-unsafe-execution` command and prior operator authorization. A
+   `UNSUPPORTED_REPOSITORY_SYMLINK` conflict stays a refusal: only the operator may declare the
+   local-only entry that holds the link with `--exclude NAME`. Never add names to
+   `repository.exclude` yourself; the configured list never removes files from campaign evidence.
 2. Ask the operator or harness for the buggy, corrected and neutral revisions, the neutral reason,
    candidate path and unchanged base tests. Do not invent a neutral control's meaning.
 3. For committed dependency-free JavaScript `node:test`, use `assertledger check` or the MCP

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assertledger",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Verify that regression tests detect a declared bug, with deterministic verdicts and replayable evidence.",
   "type": "module",
   "private": false,
@@ -31,6 +31,10 @@
     "./core": {
       "types": "./dist/core/index.d.ts",
       "import": "./dist/core/index.js"
+    },
+    "./bun": {
+      "types": "./integrations/bun/assertions.d.mts",
+      "import": "./integrations/bun/assertions.mjs"
     }
   },
   "files": [
@@ -73,10 +77,10 @@
     "zod": "4.4.3"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.5.6",
+    "@biomejs/biome": "2.5.14",
     "@modelcontextprotocol/client": "2.0.0",
-    "@types/node": "22.20.1",
-    "tsx": "4.23.5"
+    "@types/node": "22.20.4",
+    "tsx": "4.23.13"
   },
   "directories": {
     "doc": "docs",