@afokapu/atdd-bun 0.10.68 → 0.10.69

package/detectors/atdd_traceability_closure/detect.mjs

@@ -62,7 +62,11 @@ for (const root of roots) {
       // EVERY binding header is judged, not only the first: a valid Acceptance: must not carry an unresolved Train:.
       const headers = [...head.matchAll(/^[ \t]*\/\/[ \t]*(Acceptance|WMBT|Train):[ \t]*(\S*)/gm)].map((m) => ({ kind: m[1], id: m[2], raw: m[0].trim(), line: lineAt(head, m.index) }));
       const bindings = headers.filter((h) => h.id.startsWith(PREFIX[h.kind]));
-      tests.set(urn[1], { path, bindings });
+      // A test identity may be reused by equivalent smoke harnesses. Preserve every
+      // independently declared binding: replacing the earlier record made a valid
+      // acceptance disappear solely because a later file had the same test URN.
+      const prior = tests.get(urn[1]);
+      tests.set(urn[1], { path, bindings: [...(prior?.bindings ?? []), ...bindings] });
       if (!headers.length) add("traceability.test.binding-resolves", path, lineOf(head, urn[0]), "test has a URN but no Acceptance:, WMBT:, or Train: binding", urn[0]);
       for (const h of headers) if (!bindings.includes(h)) add("traceability.test.binding-resolves", path, h.line, `${h.kind}: ${h.id || "<empty>"} is not a ${PREFIX[h.kind]} identity`, h.raw);
       return;

package/detectors/bun_interlocking_infrastructure/checks/journey_runner_boundary.mjs

@@ -47,25 +47,56 @@ function journeyRunnerLine(text) {
   return match ? lineOfIndex(text, match.index) : 1;
 }
 
+// Declaration helpers that verifiably read AND parse the file named by their own parameter.
+function declarationHelpers(masked) {
+  const names = [];
+  const helper = /\b(?:async\s+)?function\s+((?=[A-Za-z_$\w]*(?:declaration|journey))[A-Za-z_$][\w$]*)\s*\(\s*([A-Za-z_$][\w$]*)?[^)]*\)\s*(?::[^\{]+)?\{([\s\S]*?)\n\}/gi;
+  for (const match of masked.matchAll(helper)) {
+    const [, name, param, body] = match;
+    if (!param || !/\b(?:Bun\.YAML\.parse|JSON\.parse)\s*\(/.test(body)) continue;
+    // The read argument must reference the helper's own parameter, not a fixed path.
+    const paramName = param.replace(/[$]/g, "\\$");
+    if (!new RegExp(`\\b(?:Bun\\.file|readFile(?:Sync)?)\\s*\\(\\s*[^)]*\\b${paramName}\\b`).test(body)) continue;
+    // JourneyRunner must pass its own declared path to that helper.
+    const callee = name.replace(/[$]/g, "\\$");
+    if (new RegExp(`\\b${callee}\\s*\\(\\s*this\\s*\\.\\s*journeyYamlPath\\s*\\)`).test(masked)) names.push(name);
+  }
+  return names;
+}
+
 function loadsJourneyDeclaration(text) {
   const masked = maskComments(text);
   const readsJourneyPath =
     /Bun\.file\s*\(\s*[^)]*(?:journey|_journeys)/i.test(masked) ||
     /\breadFile(?:Sync)?\s*\(\s*[^,)]*(?:journey|_journeys)/i.test(masked);
   const parsesDeclaration = /Bun\.YAML\.parse\s*\(|JSON\.parse\s*\(/.test(masked);
-  return readsJourneyPath && parsesDeclaration;
+  if (readsJourneyPath && parsesDeclaration) return true;
+  // Production runners may centralize parsing and validation in a declaration helper.
+  return declarationHelpers(masked).length > 0;
 }
 
 function consumesDeclaredTopology(text) {
   const masked = maskComments(text);
-  const declaration = /\b(?:const|let)\s+([A-Za-z_$][\w$]*)\s*=\s*Bun\.YAML\.parse\s*\(/.exec(masked);
-  if (!declaration) return false;
-  const name = declaration[1].replace(/[$]/g, "\\$");
+  // The topology variable must come from the original parse or from the one verified helper
+  // called with this.journeyYamlPath; a topology from any other call is not the declaration.
+  const escape = (value) => value.replace(/[$]/g, "\\$");
+  const sources = ["Bun\\.YAML\\.parse\\s*\\(", ...declarationHelpers(masked).map(helper =>
+    `(?:await\\s+)?${escape(helper)}\\s*\\(\\s*this\\s*\\.\\s*journeyYamlPath\\s*\\)`)];
+  const declarations = [...masked.matchAll(new RegExp("\\b(?:const|let)\\s+([A-Za-z_$][\\w$]*)\\s*=\\s*(?:" + sources.join("|") + ")", "g"))];
+  return declarations.some(declaration => consumesTopologyFrom(masked, declaration[1]));
+}
+
+function consumesTopologyFrom(masked, variable) {
+  const name = variable.replace(/[$]/g, "\\$");
   const reads = (field) => new RegExp("\\b" + name + "\\s*\\.\\s*" + field + "\\s*\\.\\s*find\\s*\\(").test(masked);
   // A runner must retain the interlocking result long enough to decide whether the
   // declared route continues or terminates. Returning the first execute() directly
   // is the characteristic skipped-continuation mutation.
-  const retainsResolution = /\b(?:const|let)\s+[A-Za-z_$][\w$]*\s*=\s*await\s+(?:new\s+InterlockingRunner\s*\([^)]*\)|[A-Za-z_$][\w$]*)\s*\.\s*execute\s*\(/.test(masked);
+  const execution = "await\\s+(?:new\\s+InterlockingRunner\\s*\\([^)]*\\)|[A-Za-z_$][\\w$]*)\\s*\\.\\s*execute\\s*\\(";
+  // The result may also be declared first and assigned once inside a try that has a catch:
+  // `let run: T; try { run = await runner.execute(...) } catch { throw error }`.
+  const retainsResolution = new RegExp("\\b(?:const|let)\\s+[A-Za-z_$][\\w$]*\\s*=\\s*" + execution).test(masked) ||
+    new RegExp("\\blet\\s+([A-Za-z_$][\\w$]*)\\s*(?::[^=;]+)?;\\s*try\\s*\\{\\s*\\1\\s*=\\s*" + execution + "[\\s\\S]{0,400}?\\}\\s*catch\\s*(?:\\([^)]*\\))?\\s*\\{[^}]*\\b(?:throw|return)\\b").test(masked);
   const readsEntrypoint = new RegExp("\\b" + name + "\\s*\\.\\s*entrypoint\\b").test(masked);
   // Reading both lists is only discovery. A continuation must alter control flow to
   // another declared interlocking and a terminal must decide the returned outcome;

package/detectors/bun_ts_metrics_detector/checks/ts_dead_code.mjs

@@ -12,7 +12,7 @@
 // obligation, measured correctly, and only possible because the runtime is Bun.
 import { walk, readRoots, readExcludes, readText, emit } from "../../../lib/scan.mjs";
 import * as M from "../ts_metrics.mjs";
-import { basename, dirname, join, resolve } from "node:path";
+import { basename, dirname, join, relative, resolve } from "node:path";
 import { existsSync } from "node:fs";
 
 const RULE = "coder.bun.dead-code-reachability";
@@ -64,6 +64,16 @@ for (const root of readRoots()) {
   if (!roots.size) continue;
 
   const forward = M.reachableFrom(roots, graph);
+  // Tests are executable entrypoints, but only for test-support modules (e2e/, tests/ ...). A
+  // production module imported solely by a test is still dead production code.
+  const SUPPORT_SEGMENTS = new Set(["e2e", "test", "tests", "__tests__", "spec", "fixtures"]);
+  const isSupport = (f) => relative(root, f).split(/[\\/]/).slice(0, -1).some(segment => SUPPORT_SEGMENTS.has(segment));
+  const queue = files.filter(M.isTestFile);
+  while (queue.length) {
+    for (const next of graph.get(queue.pop()) || []) {
+      if (isSupport(next) && !forward.has(next)) { forward.add(next); queue.push(next); }
+    }
+  }
   const backward = M.reachableFrom(roots, M.reverseGraph(graph));
 
   for (const f of files) {

package/integrity.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.10.68",
+  "version": "0.10.69",
   "files": {
     "HOOK_AUDIT.md": "5329d840db37671b1918f688ead26865473b87db73dbc75f7c8b2a8bbe8d6d43",
     "PLANNER_PORT.md": "fb5935bac8b7ac18994de21e43ace3a5ef8cd55f85b0e3349fca261280054f11",
@@ -191,7 +191,7 @@
     "detectors/atdd_topology/fixtures/dirty/src/wagons/orders/features/place-order/domain/order.ts": "6fdaad52671ef25b47d93f9b4e97e12c62eb78f5b4cde727435c3ac135a1c0e5",
     "detectors/atdd_topology/fixtures/dirty/tests/wagons/orders/features/place-order/unit/order.test.ts": "f117e6c8b034700e1f00889bea48cb1528f0003d699cfd3e279cd9164b264a38",
     "detectors/atdd_traceability_closure/atdd.implementation.yaml": "82e56cc85539476e42fc8d58e718bc998f1eff6c325a0cd240c0284625834d68",
-    "detectors/atdd_traceability_closure/detect.mjs": "b3f5afbfa4d4970f56a2a361d3392652dd4f536d5018ac0f54aa7fc97c3ead11",
+    "detectors/atdd_traceability_closure/detect.mjs": "17582d256ee4b1555bd62ba4decfe2ff15b664400a243ff28b0e87604d3aa05d",
     "detectors/atdd_traceability_closure/fixtures/clean/plan/orders/E001.yaml": "0ddad928dde10c2ab690558259a6975125af540a1f30eca9aa0c615bf0ad69fb",
     "detectors/atdd_traceability_closure/fixtures/clean/src/order.ts": "efe6db7e3f723c7b6096abdf58dec9c88b27ec8978d434a10135b3e77bfce321",
     "detectors/atdd_traceability_closure/fixtures/clean/test/order.test.ts": "bee451198d472749616f85c1f1e97c0a06ad28255b9a6a2cc8701bd2e8d56562",
@@ -490,7 +490,7 @@
     "detectors/bun_interlocking_infrastructure/checks/interlocking_resolution_model.mjs": "e761495b19eed0af09fcb4db34126d0e2398e91f086e04f5ef84d0b5c1c3ec16",
     "detectors/bun_interlocking_infrastructure/checks/interlocking_runner_exists.mjs": "6b63d3f26a51f2dd27847edd27c4d9c9f15c1f02747dba611cebccfc76f13169",
     "detectors/bun_interlocking_infrastructure/checks/interlocking_station_routing.mjs": "f3870fb3bacee46a6c3e10238284ef4d359182030d40d4f33b0f0ad465f7a284",
-    "detectors/bun_interlocking_infrastructure/checks/journey_runner_boundary.mjs": "ad74ebb76d63ef648202ca31316647221e152f79bcba6aa2d30be4f0464ac10e",
+    "detectors/bun_interlocking_infrastructure/checks/journey_runner_boundary.mjs": "6284a8532722e5a6bff7e5184e24c7f273c1e63f1331204502e0e3704db5c86b",
     "detectors/bun_interlocking_infrastructure/checks/journey_station_routing.mjs": "66c09cdc17b099a55fa0ca894bd85a44706742bdd29caa5347f10e6487b4e724",
     "detectors/bun_interlocking_infrastructure/checks/wagon_contract_honoured.mjs": "79b5f824e7510f50e4925a98c01ef263290025748f64a27a11555f608d8001dc",
     "detectors/bun_interlocking_infrastructure/detect.mjs": "6494579ec7b9d4680099401346337d73f4a52368ffb6b9d3b0fbca5dce2cde15",
@@ -717,7 +717,7 @@
     "detectors/bun_ts_metrics_detector/checks/ts_complexity_cyclomatic.mjs": "56640b3a0f565c45a73b7c174adb1d6b4b6ac24d286a907bc1426f013cd6039e",
     "detectors/bun_ts_metrics_detector/checks/ts_complexity_length.mjs": "e49fe93dbf2c52a91fe97b1e0b810d60f7d34d43581dfb96d4827640e6f5e3fd",
     "detectors/bun_ts_metrics_detector/checks/ts_complexity_nesting.mjs": "8d8f61ea1748f33b037beb3f3fe5c84acbce395575e24fb1d01432813762e4d1",
-    "detectors/bun_ts_metrics_detector/checks/ts_dead_code.mjs": "154fdf7b8e896f73ae86d7a9609a953fcb8d33c1b61eabcb6d190b06d64d97b4",
+    "detectors/bun_ts_metrics_detector/checks/ts_dead_code.mjs": "8f2205274f5056993a888ea4141be4d0b64c287e4641d0a464d178530b5297d4",
     "detectors/bun_ts_metrics_detector/checks/ts_duplication.mjs": "12b5087c34741ce3fde573059d1afbaafc80ce1bfe8a235780113fd558dbbc7d",
     "detectors/bun_ts_metrics_detector/checks/ts_quality_comments.mjs": "872d71d2165eba4cb39c975b09365cf67a64f1db5c55c0df9e86ff411e02ea31",
     "detectors/bun_ts_metrics_detector/checks/ts_quality_mi.mjs": "69765d88441e98f4f38b7da0a416b7dab8b7f0072e562ea9d40d399802452067",
@@ -1034,7 +1034,7 @@
     "lib/frontend.mjs": "d6d9b29c3d7f2d162cda03bb34b20a3224a82887b6be3db7cab375510913c9a3",
     "lib/imports.mjs": "3db4979269488fa26f6e7aefded6ece9c646be6587a10e249821a5a208109962",
     "lib/interlocking.mjs": "d0803d080ac7d7477c51be70112df1e85213d339fd3c6b71f75f26145fa8accd",
-    "lib/journey-chain.mjs": "6db114d3c3f05b3276d5d9b258a6215a90f829ca4c67d61318922020ac3fb8c8",
+    "lib/journey-chain.mjs": "aaa0e6acdd73f1a8cfeea9a523a86c6d3133c020c37f97e7ec61db00f957ec6a",
     "lib/scan.mjs": "02b0fa864cab24157a8f27b50a87a2bb66a875f90cf6632c753c4627d61456ef",
     "planner-nodes/ENFORCEMENT_SCOPE.yaml": "d8ec7039c219857f3d77af5d4d84612b533b69c1a5fcef935fbf46470adafed4",
     "planner-nodes/nodes/planner.acceptance.abstract-fields-required.convention.yaml": "bd565693f0ae861f0561ad2f7a91a8c55f9a209c3acd59c5750cfcffd96a85d8",

package/lib/journey-chain.mjs

@@ -430,12 +430,40 @@ function liveReturns(fn) {
 // arms of a conditional, as a member/spread of it, an object property or array element, an
 // `Object.freeze` argument, or a `const` bound to it. Logical, comma, arithmetic, unary (`void`, `!`)
 // and calls to anything else replace or may skip the value, so they never carry it.
+// A runner result may be declared before a try and assigned exactly once in the
+// try body. The catch must itself exit (throw or return); otherwise a swallowed error would
+// let the later return observe an unassigned value. Do not generalize this to ordinary
+// `let` assignments: conditional or multiply-written values are not a proof chain.
+function caughtSingleAssignment(ctx, identifier) {
+  const declaration = declarationOf(ctx, identifier);
+  if (!declaration || !ts.isVariableDeclaration(declaration) || declaration.initializer ||
+    !ts.isVariableDeclarationList(declaration.parent) || !(declaration.parent.flags & ts.NodeFlags.Let)) return null;
+  let fn = declaration.parent;
+  while (fn && !ts.isFunctionLike(fn)) fn = fn.parent;
+  if (!fn || !fn.body) return null;
+  const writes = [];
+  walk(fn.body, (node) => {
+    if (!ts.isBinaryExpression(node) || node.operatorToken.kind !== ts.SyntaxKind.EqualsToken ||
+      !ts.isIdentifier(unwrap(node.left)) || symbolOf(ctx, unwrap(node.left)) !== symbolOf(ctx, identifier) || dead(node, fn.body)) return;
+    let inCaughtTry = false;
+    for (let parent = node.parent; parent && parent !== fn.body; parent = parent.parent) {
+      if (ts.isTryStatement(parent) && parent.tryBlock && node.pos >= parent.tryBlock.pos && node.end <= parent.tryBlock.end && parent.catchClause &&
+        parent.catchClause.block.statements.some(statement => ts.isThrowStatement(statement) || ts.isReturnStatement(statement))) {
+        inCaughtTry = true;
+        break;
+      }
+    }
+    if (inCaughtTry) writes.push(node.right);
+  }, false);
+  return writes.length === 1 ? writes[0] : null;
+}
+
 function carries(ctx, expression, matches, seen = new Set()) {
   const node = unwrap(expression);
   if (!node) return false;
   if (matches(node)) return true;
   if (ts.isIdentifier(node)) {
-    const initializer = constInitializer(ctx, node);
+    const initializer = constInitializer(ctx, node) ?? caughtSingleAssignment(ctx, node);
     // `seen` guards cycles along this path only; sibling branches may resolve the same const.
     if (!initializer || seen.has(initializer)) return false;
     seen.add(initializer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@afokapu/atdd-bun",
-  "version": "0.10.68",
+  "version": "0.10.69",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/afokapu/atdd-bun.git"