@afokapu/atdd-bun 0.10.97 → 0.10.99

package/detectors/atdd_traceability_closure/detect.mjs

@@ -12,7 +12,7 @@ if (!report || !Array.isArray(roots) || !roots.length) process.exit(2);
 const sourceExtensions = new Set([".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs"]);
 const testName = /(?:^test_.*|.*(?:\.test|\.spec|\.e2e|_test))\.(?:[cm]?[jt]sx?)$/;
 const violations = [];
-const plans = { acc: new Set(), wmbt: new Set(), train: new Set() };
+const plans = { acc: new Set(), wmbt: new Set(), train: new Set(), journey: new Set() };
 const tests = new Map();
 const declaredAt = new Map();
 const sources = [];
@@ -36,7 +36,8 @@ function add(rule_id, file, line, evidence, source_line = "") {
 function lineOf(content, token) { return lineAt(content, content.indexOf(token)); }
 function lineAt(content, index) { return content.slice(0, index).split("\n").length; }
 // The identity each binding header must carry.
-const PREFIX = { Acceptance: "acc:", WMBT: "wmbt:", Train: "train:" };
+const PREFIX = { Acceptance: "acc:", WMBT: "wmbt:", Train: "train:", Journey: "journey:" };
+const JOURNEY_ID = /^journey:[a-z][a-z0-9-]*$/;
 
 for (const root of roots) {
   // `plan_root: .` (or `./`) must still match root-relative paths, which never start with `./`.
@@ -44,12 +45,16 @@ for (const root of roots) {
   walk(root, (path) => {
     const name = path.split("/").pop() || "";
     const content = text(path);
-    if (/\.ya?ml$/i.test(name) && relative(root, path).replaceAll("\\", "/").startsWith(planPrefix)) {
+    const planPath = relative(root, path).replaceAll("\\", "/");
+    if (/\.ya?ml$/i.test(name) && planPath.startsWith(planPrefix)) {
       for (const [kind, re] of Object.entries({
         acc: /\bacc:[A-Za-z0-9_.:-]+/g,
         wmbt: /\bwmbt:[A-Za-z0-9_.:-]+/g,
         train: /\btrain:[A-Za-z0-9_.:-]+/g,
       })) for (const match of content.matchAll(re)) plans[kind].add(match[0]);
+      if (planPath.startsWith(`${planPrefix}_journeys/`)) {
+        for (const match of content.matchAll(/["']?\bjourney_id["']?[ \t]*:[ \t]*["']?(journey:[A-Za-z0-9_.:-]+)/g)) plans.journey.add(match[1]);
+      }
       // Where each acceptance is DECLARED (its `urn:` line), so a missing test is reported on the artifact to fix.
       for (const m of content.matchAll(/["']?\burn["']?[ \t]*:[ \t]*["']?(acc:[A-Za-z0-9_.:-]+)/g)) if (!declaredAt.has(m[1])) declaredAt.set(m[1], { path, line: lineAt(content, m.index) });
       return;
@@ -60,14 +65,14 @@ for (const root of roots) {
       const urn = head.match(/^\s*\/\/\s*URN:\s*(test:[^\s]+)/m);
       if (!urn) return;
       // 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]));
+      const headers = [...head.matchAll(/^[ \t]*\/\/[ \t]*(Acceptance|WMBT|Train|Journey):[ \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.kind === "Journey" ? JOURNEY_ID.test(h.id) : h.id.startsWith(PREFIX[h.kind]));
       // 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]);
+      if (!headers.length) add("traceability.test.binding-resolves", path, lineOf(head, urn[0]), "test has a URN but no Acceptance:, WMBT:, Train:, or Journey: 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_coverage/_shared/interlocking.mjs

@@ -8,7 +8,7 @@
 // data (snake_case, plan/_trains/_interlockings/**); the e2e tests are Bun/TS under e2e/**.
 
 import { excludedPath } from "../../../lib/scan.mjs";
-import { entryDelegatedAction, provenJourneyAction } from "../../../lib/journey-chain.mjs";
+import { directInterlockingExecutionProofs, entryDelegatedAction, provenJourneyAction } from "../../../lib/journey-chain.mjs";
 import { existsSync, readFileSync, statSync, readdirSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve, sep } from "node:path";
 
@@ -556,9 +556,10 @@ function resolutionTrainExecution(after, resolution) {
 }
 
 export function productionExecutionProofs(text, file, croot) {
-  if (file && croot && !hasResolvedProductionRunnerImports(text, file, croot)) return [];
+  const directProofs = file && croot ? directInterlockingExecutionProofs(text, file, croot) : [];
+  if (file && croot && !hasResolvedProductionRunnerImports(text, file, croot)) return directProofs;
   const receivers = productionReceivers(text);
-  const proofs = [];
+  const proofs = [...directProofs];
   const resolutions = new RegExp(`\\b(?:const|let|var)\\s+(${ident})(?:\\s*:\\s*[^=;\\n]+)?\\s*=\\s*([^=;{}\\n]{0,240}?)\\.resolveTrain\\s*\\(`, "g");
   for (const m of text.matchAll(resolutions)) {
     const [whole, resolution, receiver] = m;
@@ -577,8 +578,16 @@ export function assertsExpression(text, expression, expected = null) {
   return Boolean(m && (!expected || tokenCovered(expected, m[0])));
 }
 
+function directResolutionAssertion(proof, fields, expected = null) {
+  return fields.some((field) => (proof.direct?.resolution[field] ?? [])
+    .some((assertion) => !expected || tokenCovered(expected, assertion)));
+}
+
 export function hasProductionExecutionProof(text, file, croot) {
-  return productionExecutionProofs(text, file, croot).some(({ resolution, execution }) => {
+  return productionExecutionProofs(text, file, croot).some((proof) => {
+    const { resolution, execution, direct } = proof;
+    if (direct) return directResolutionAssertion(proof, ["routeId", "trainId", "selectedTrainId"]) ||
+      direct.execution || direct.traceFields.length > 0;
     if (assertsExpression(text, `${escaped(resolution)}\\.(?:routeId|trainId|selectedTrainId)`) ||
       (execution && assertsExpression(text, escaped(execution)))) return true;
     if (!execution) return false;
@@ -589,16 +598,24 @@ export function hasProductionExecutionProof(text, file, croot) {
 
 export function routeHasProductionProof(route, text, interlockingId = null, file, croot) {
   const slug = interlockingId?.replace(/^interlocking:/, "");
-  return productionExecutionProofs(text, file, croot).some(({ resolution, execution }) => {
-    const assertedRoute = assertsExpression(text, `${escaped(resolution)}\\.routeId`, route.routeId);
-    const assertedTrain = assertsExpression(text, `${escaped(resolution)}\\.(?:trainId|selectedTrainId)`, route.trainId);
+  return productionExecutionProofs(text, file, croot).some((proof) => {
+    const { resolution, execution, direct } = proof;
+    const assertedRoute = direct
+      ? directResolutionAssertion(proof, ["routeId"], route.routeId)
+      : assertsExpression(text, `${escaped(resolution)}\\.routeId`, route.routeId);
+    const assertedTrain = direct
+      ? directResolutionAssertion(proof, ["trainId", "selectedTrainId"], route.trainId)
+      : assertsExpression(text, `${escaped(resolution)}\\.(?:trainId|selectedTrainId)`, route.trainId);
     const scoped = !interlockingId || tokenCovered(interlockingId, text) || tokenCovered(slug, text);
-    return (assertedRoute && scoped) || assertedTrain || Boolean(scoped && execution && assertsExpression(text, escaped(execution)) && (tokenCovered(route.routeId, text) || tokenCovered(route.trainId, text)));
+    const assertedExecution = direct ? direct.execution : execution && assertsExpression(text, escaped(execution));
+    return (assertedRoute && scoped) || assertedTrain || Boolean(scoped && assertedExecution &&
+      (tokenCovered(route.routeId, text) || tokenCovered(route.trainId, text)));
   });
 }
 
 export function traceHasProductionProvenance(text, file, croot) {
-  return productionExecutionProofs(text, file, croot).some(({ execution }) => {
+  return productionExecutionProofs(text, file, croot).some(({ execution, direct }) => {
+    if (direct) return direct.traceBound && REQUIRED_TRACE_FIELDS.every(([field]) => direct.traceFields.includes(field));
     if (!execution) return false;
     const trace = new RegExp(`\\b(?:const|let|var)\\s+(${ident})(?:\\s*:\\s*[^=;\\n]+)?\\s*=\\s*(?:await\\s+)?${escaped(execution)}\\.trace\\b`).exec(text)?.[1];
     return Boolean(trace);
@@ -706,7 +723,10 @@ export function routeHasStationModuleProof(route, text, action, stationText, sta
 // kills reorder/removal mutants, objectContaining records a handoff edge, and at(-1) observes the
 // final wagon.  All three must be about the TrainRunner result, never a hand-built literal.
 export function hasSequenceMutationProof(text, trainId, file, croot) {
-  return productionExecutionProofs(text, file, croot).some(({ resolution, execution }) => {
+  return productionExecutionProofs(text, file, croot).some((proof) => {
+    const { resolution, execution, direct } = proof;
+    if (direct) return directResolutionAssertion(proof, ["trainId", "selectedTrainId"], trainId) &&
+      direct.sequence.ordered && direct.sequence.handoff && direct.sequence.final;
     if (!execution || !assertsExpression(text, `${escaped(resolution)}\\.(?:trainId|selectedTrainId)`, trainId)) return false;
     const result = escaped(execution);
     const ordered = new RegExp(`expect\\s*\\(\\s*${result}\\.(?:steps|sequence|wagons)\\s*\\)\\s*\\.to(?:Equal|StrictEqual)\\s*\\(\\s*\\[`, "s").test(text);

package/integrity.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.10.97",
+  "version": "0.10.99",
   "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": "aac7e9e8d7885d762d6c5ae94f2094d6eddfdf07a336724a8458b249a73a43ac",
+    "detectors/atdd_traceability_closure/detect.mjs": "4fe2f6c73fc5535255f15676fb89f0a887598e3bf80c82f048c8e69432c38342",
     "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",
@@ -385,7 +385,7 @@
     "detectors/bun_interlocking_binding/fixtures/dirty_transcribed_runtime/server.ts": "d5bc34c5b1b2b0a511e0c4604ce6f9c77491dca9aee994be720540f3052babc1",
     "detectors/bun_interlocking_binding/fixtures/dirty_transcribed_runtime/src/trains/interlocking.ts": "9bcfdb4ecff6efd1f658b9fd587342615179924e25468c75daa07c2626d4d8ab",
     "detectors/bun_interlocking_binding/fixtures/dirty_transcribed_runtime/src/trains/runner.ts": "0e4b885e50f12cc2a8c8f6740bf83e7b2e7137a28e1e143586e9a8550ea5bd45",
-    "detectors/bun_interlocking_coverage/_shared/interlocking.mjs": "8a90490daaaa6eecf4c971fb569da38156b45969d48755dbcf355175dde0b079",
+    "detectors/bun_interlocking_coverage/_shared/interlocking.mjs": "e4de9503c31ed631e2e6a0bd5b21e78ee8ca1f1186fa93ff65106ff47695013e",
     "detectors/bun_interlocking_coverage/atdd.implementation.yaml": "f160517a8138ba3ca05e3d130e6fbfb796e643376f25743fdef4fc210196525b",
     "detectors/bun_interlocking_coverage/checks/_map.json": "0a218ea319cc6258af7bd721c2154cb9561fe67e80d80ef32d08fc77bc9403c3",
     "detectors/bun_interlocking_coverage/checks/interlocking_production_runner.mjs": "97224d46f0c4c3259f15e41f90bb7f9f5a4e651d4facd41f1e037cac919be500",
@@ -1034,7 +1034,7 @@
     "lib/frontend.mjs": "d6d9b29c3d7f2d162cda03bb34b20a3224a82887b6be3db7cab375510913c9a3",
     "lib/imports.mjs": "3db4979269488fa26f6e7aefded6ece9c646be6587a10e249821a5a208109962",
     "lib/interlocking.mjs": "d0803d080ac7d7477c51be70112df1e85213d339fd3c6b71f75f26145fa8accd",
-    "lib/journey-chain.mjs": "bdafc9cc3da4ade644aebacc6e1015e29285b764465588d764b7c581bade9025",
+    "lib/journey-chain.mjs": "34b1efa073b17940fa398af2970c85bb2fac35e4b2608ce635cfb6c39e3adc53",
     "lib/scan.mjs": "b6973e411ecd14c548a055c871e01e948f002b772042136be8401f38d998e687",
     "planner-nodes/ENFORCEMENT_SCOPE.yaml": "d8ec7039c219857f3d77af5d4d84612b533b69c1a5fcef935fbf46470adafed4",
     "planner-nodes/nodes/planner.acceptance.abstract-fields-required.convention.yaml": "bd565693f0ae861f0561ad2f7a91a8c55f9a209c3acd59c5750cfcffd96a85d8",

package/lib/journey-chain.mjs

@@ -134,7 +134,7 @@ const accessName = (node) =>
 
 // Why the module can replace a runner's behaviour outside its declared method (see the override
 // contract above), or null. Deliberately module-wide: it fails closed.
-function tampered(ctx) {
+function tampered(ctx, allowedRunnerWrite = () => false) {
   let found = null;
   const runnerClass = (node) => (ts.isClassDeclaration(node) || ts.isClassExpression(node)) && RUNNERS.has(node.name?.text);
   const insideRunnerClass = (node) => {
@@ -207,7 +207,8 @@ function tampered(ctx) {
       node.operatorToken.kind <= ts.SyntaxKind.LastAssignment) {
       const target = unwrap(node.left);
       if ((ts.isPropertyAccessExpression(target) || ts.isElementAccessExpression(target)) &&
-        (reachesRunner(target.expression) || (MEMBERS.has(accessName(target)) && prototypeish(target.expression)))) found = "runner write";
+        (reachesRunner(target.expression) || (MEMBERS.has(accessName(target)) && prototypeish(target.expression))) &&
+        !allowedRunnerWrite(node, target)) found = "runner write";
     }
     if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
       const api = node.expression.name.text;
@@ -612,6 +613,289 @@ function journeyExecutes(croot) {
   };
 }
 
+function importedValue(ctx, identifier, croot) {
+  if (!identifier || !ts.isIdentifier(identifier)) return null;
+  const declaration = declarationOf(ctx, identifier);
+  if (!declaration || !ts.isImportSpecifier(declaration) || declaration.isTypeOnly) return null;
+  const clause = declaration.parent.parent;
+  const statement = clause.parent;
+  if (clause.isTypeOnly || !ts.isStringLiteral(statement.moduleSpecifier)) return null;
+  const file = productionModule(statement.moduleSpecifier.text, ctx.file, croot);
+  return file ? { file, name: (declaration.propertyName ?? declaration.name).text } : null;
+}
+
+function exportedConst(ctx, name) {
+  let found = null;
+  let directlyExported = false;
+  let listed = false;
+  for (const statement of ctx.source.statements) {
+    if (ts.isVariableStatement(statement) && statement.declarationList.flags & ts.NodeFlags.Const) {
+      for (const declaration of statement.declarationList.declarations) {
+        if (!ts.isIdentifier(declaration.name) || declaration.name.text !== name) continue;
+        if (found) return null;
+        found = declaration;
+        directlyExported = Boolean(ts.getCombinedModifierFlags(statement) & ts.ModifierFlags.Export);
+      }
+    }
+    if (ts.isExportDeclaration(statement) && !statement.moduleSpecifier && statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+      listed ||= statement.exportClause.elements.some((element) =>
+        (element.propertyName ?? element.name).text === name && element.name.text === name);
+    }
+  }
+  return found && (directlyExported || listed) ? found : null;
+}
+
+function handlerConfiguration(ctx, expression, seen = new Set()) {
+  const value = unwrap(expression);
+  if (!value) return false;
+  if (ts.isObjectLiteralExpression(value)) return value.properties.length > 0;
+  if (!ts.isIdentifier(value)) return false;
+  const initializer = constInitializer(ctx, value);
+  if (!initializer || seen.has(initializer)) return false;
+  seen.add(initializer);
+  return handlerConfiguration(ctx, initializer, seen);
+}
+
+function injectedTrainField(ctx, cls) {
+  const constructors = cls.members.filter(ts.isConstructorDeclaration);
+  if (constructors.length !== 1 || !constructors[0].body || constructors[0].parameters.length !== 1) return null;
+  const constructor = constructors[0];
+  const parameter = constructor.parameters[0].name;
+  if (!ts.isObjectBindingPattern(parameter)) return null;
+  const binding = parameter.elements.find((element) =>
+    !element.dotDotDotToken && ts.isIdentifier(element.name) &&
+    (element.propertyName ?? element.name).getText() === "trainRunner");
+  if (!binding || !ts.isIdentifier(binding.name)) return null;
+  const parameterSymbol = symbolOf(ctx, binding.name);
+  const assignments = [];
+  walk(constructor.body, (node) => {
+    if (!ts.isBinaryExpression(node) || node.operatorToken.kind !== ts.SyntaxKind.EqualsToken) return;
+    const target = unwrap(node.left);
+    const value = unwrap(node.right);
+    if (ts.isPropertyAccessExpression(target) && target.expression.kind === ts.SyntaxKind.ThisKeyword &&
+      ts.isIdentifier(value) && symbolOf(ctx, value) === parameterSymbol) assignments.push({ node, field: target.name.text });
+  }, false);
+  return assignments.length === 1 ? assignments[0] : null;
+}
+
+function objectProperty(ctx, expression, name, seen = new Set()) {
+  const value = unwrap(expression);
+  if (!value) return null;
+  if (ts.isIdentifier(value)) {
+    const initializer = constInitializer(ctx, value);
+    if (!initializer || seen.has(initializer)) return null;
+    seen.add(initializer);
+    return objectProperty(ctx, initializer, name, seen);
+  }
+  if (!ts.isObjectLiteralExpression(value)) return null;
+  const properties = value.properties.filter((property) => memberName(property) === name);
+  if (properties.length !== 1) return null;
+  const property = properties[0];
+  if (ts.isPropertyAssignment(property)) return property.initializer;
+  if (ts.isShorthandPropertyAssignment(property)) return property.name;
+  return null;
+}
+
+function directInterlockingMethod(ctx, cls, field) {
+  if (!soleMethod(ctx, cls, "resolveTrain")) return null;
+  const method = soleMethod(ctx, cls, "execute");
+  const returns = method && liveReturns(method);
+  if (!method || !returns?.length) return null;
+  const declarations = [];
+  walk(method.body, (node) => {
+    if (!ts.isVariableDeclaration(node) || !ts.isIdentifier(node.name) || !node.initializer) return;
+    const call = unwrap(node.initializer);
+    if (ts.isCallExpression(call) && ts.isPropertyAccessExpression(call.expression) &&
+      call.expression.expression.kind === ts.SyntaxKind.ThisKeyword && call.expression.name.text === "resolveTrain") declarations.push(node);
+  }, false);
+  for (const declaration of declarations) {
+    const symbol = symbolOf(ctx, declaration.name);
+    if (!symbol) continue;
+    const isResolution = (node) => Boolean(node) && ts.isIdentifier(unwrap(node)) && symbolOf(ctx, unwrap(node)) === symbol;
+    const isExecution = (node) => {
+      const call = unwrap(node);
+      return Boolean(call && ts.isCallExpression(call) && ts.isPropertyAccessExpression(call.expression) &&
+        call.expression.name.text === "execute" && ts.isPropertyAccessExpression(call.expression.expression) &&
+        call.expression.expression.expression.kind === ts.SyntaxKind.ThisKeyword &&
+        call.expression.expression.name.text === field && isResolution(call.arguments[0]));
+    };
+    const returned = returns.every((expression) => {
+      const resolution = expression && objectProperty(ctx, expression, "resolution");
+      const trainResult = expression && objectProperty(ctx, expression, "trainResult");
+      return resolution && trainResult && carries(ctx, resolution, isResolution) && carries(ctx, trainResult, isExecution);
+    });
+    if (returned && resolutionUnchanged(ctx, method, declaration, symbol, returns, isExecution)) return method;
+  }
+  return null;
+}
+
+function compositionProof(serverFile, exportName, croot) {
+  const server = analyze(serverFile);
+  const interlocking = exportedConst(server, exportName);
+  const construction = interlocking?.initializer && unwrap(interlocking.initializer);
+  if (!construction || !ts.isNewExpression(construction)) return null;
+  const interlockingFile = importedRunner(server, construction.expression, "InterlockingRunner", croot);
+  const argument = construction.arguments?.[0];
+  const trainReference = argument && objectProperty(server, argument, "trainRunner");
+  if (!interlockingFile || !trainReference || !ts.isIdentifier(unwrap(trainReference))) return null;
+  const trainDeclaration = declarationOf(server, unwrap(trainReference));
+  if (!trainDeclaration || !ts.isVariableDeclaration(trainDeclaration) ||
+    !ts.isVariableDeclarationList(trainDeclaration.parent) || !(trainDeclaration.parent.flags & ts.NodeFlags.Const)) return null;
+  const trainConstruction = trainDeclaration.initializer && unwrap(trainDeclaration.initializer);
+  if (!trainConstruction || !ts.isNewExpression(trainConstruction) ||
+    !handlerConfiguration(server, trainConstruction.arguments?.[0])) return null;
+  const trainFile = importedRunner(server, trainConstruction.expression, "TrainRunner", croot);
+  if (!trainFile) return null;
+
+  const interlockingCtx = analyze(interlockingFile);
+  const interlockingClass = exportedClass(interlockingCtx, "InterlockingRunner");
+  const injection = interlockingClass && injectedTrainField(interlockingCtx, interlockingClass);
+  if (!interlockingClass || !injection || constructorReturnsValue(interlockingClass) ||
+    tampered(interlockingCtx, (node) => node === injection.node) ||
+    !directInterlockingMethod(interlockingCtx, interlockingClass, injection.field)) return null;
+
+  const trainCtx = analyze(trainFile);
+  const trainClass = exportedClass(trainCtx, "TrainRunner");
+  if (!trainClass || constructorReturnsValue(trainClass) || tampered(trainCtx) || !soleMethod(trainCtx, trainClass, "execute")) return null;
+  return { interlockingFile, interlockingCtx, injection, trainFile };
+}
+
+function awaitedCall(expression) {
+  let value = expression;
+  while (value && (ts.isParenthesizedExpression(value) || ts.isAsExpression(value) || ts.isNonNullExpression(value) ||
+    ts.isSatisfiesExpression(value) || ts.isTypeAssertionExpression(value))) value = value.expression;
+  return value && ts.isAwaitExpression(value) ? unwrap(value.expression) : null;
+}
+
+function expectIdentifier(ctx, node) {
+  if (!ts.isIdentifier(node) || node.text !== "expect") return false;
+  const declaration = declarationOf(ctx, node);
+  if (!declaration) return true;
+  const statement = ts.isImportSpecifier(declaration) ? declaration.parent.parent.parent : null;
+  return Boolean(statement && ts.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === "bun:test" &&
+    (declaration.propertyName ?? declaration.name).text === "expect");
+}
+
+function expectAssertion(ctx, node) {
+  if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression)) return null;
+  let access = node.expression;
+  const matcher = access.name.text;
+  let receiver = access.expression, negated = false;
+  if (ts.isPropertyAccessExpression(receiver) && receiver.name.text === "not") {
+    negated = true;
+    receiver = receiver.expression;
+  }
+  if (!MATCHERS.has(matcher) || (negated && !NEGATED_MATCHERS.has(matcher)) ||
+    !ts.isCallExpression(receiver) || !expectIdentifier(ctx, receiver.expression) || !receiver.arguments[0]) return null;
+  return { actual: receiver.arguments[0], matcher, negated, expected: node.arguments[0] ?? null, call: node };
+}
+
+function pathFromSymbol(ctx, expression, symbol) {
+  const node = unwrap(expression);
+  if (!node) return null;
+  if (ts.isIdentifier(node)) return symbolOf(ctx, node) === symbol ? [] : null;
+  if (ts.isPropertyAccessExpression(node)) {
+    const path = pathFromSymbol(ctx, node.expression, symbol);
+    return path && [...path, node.name.text];
+  }
+  if (ts.isElementAccessExpression(node) && node.argumentExpression && ts.isStringLiteralLike(node.argumentExpression)) {
+    const path = pathFromSymbol(ctx, node.expression, symbol);
+    return path && [...path, node.argumentExpression.text];
+  }
+  if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "at" &&
+    node.arguments.length === 1 && node.arguments[0].getText() === "-1") {
+    const path = pathFromSymbol(ctx, node.expression.expression, symbol);
+    return path && [...path, "at(-1)"];
+  }
+  return null;
+}
+
+function directAssertionFacts(ctx, resolutionSymbol, executionSymbol) {
+  const traceSymbols = new Set();
+  walk(ctx.source, (node) => {
+    if (!ts.isVariableDeclaration(node) || !ts.isIdentifier(node.name) || !node.initializer ||
+      !(ts.isVariableDeclarationList(node.parent) && node.parent.flags & ts.NodeFlags.Const)) return;
+    const path = pathFromSymbol(ctx, node.initializer, executionSymbol);
+    if (path?.length === 1 && path[0] === "trace") traceSymbols.add(symbolOf(ctx, node.name));
+  });
+  const facts = {
+    resolution: { routeId: [], trainId: [], selectedTrainId: [] },
+    execution: false,
+    traceBound: traceSymbols.size > 0,
+    traceFields: [],
+    sequence: { ordered: false, handoff: false, final: false },
+  };
+  walk(ctx.source, (node) => {
+    const assertion = expectAssertion(ctx, node);
+    if (!assertion || dead(node, ctx.source) || insideCatch(node, ctx.source)) return;
+    const resolutionPath = pathFromSymbol(ctx, assertion.actual, resolutionSymbol);
+    if (resolutionPath?.length === 1 && Object.hasOwn(facts.resolution, resolutionPath[0])) {
+      facts.resolution[resolutionPath[0]].push(assertion.call.getText(ctx.source));
+    }
+    const executionPath = pathFromSymbol(ctx, assertion.actual, executionSymbol);
+    if (executionPath?.length === 0) facts.execution = true;
+    if (!assertion.negated && executionPath?.length === 1 && ["steps", "sequence", "wagons"].includes(executionPath[0])) {
+      facts.sequence.ordered ||= ["toEqual", "toStrictEqual"].includes(assertion.matcher) &&
+        Boolean(assertion.expected && ts.isArrayLiteralExpression(unwrap(assertion.expected)));
+      facts.sequence.handoff ||= assertion.matcher === "toContainEqual" &&
+        /\bexpect\.objectContaining\s*\(\s*\{[\s\S]{0,240}?\b(?:from|to)\s*:/.test(assertion.expected?.getText(ctx.source) ?? "");
+    }
+    if (!assertion.negated && executionPath?.length === 2 && executionPath[1] === "at(-1)" &&
+      ["steps", "sequence", "wagons"].includes(executionPath[0]) &&
+      ["toBe", "toEqual", "toStrictEqual", "toMatch"].includes(assertion.matcher)) facts.sequence.final = true;
+    for (const traceSymbol of traceSymbols) {
+      const tracePath = pathFromSymbol(ctx, assertion.actual, traceSymbol);
+      if (tracePath?.length === 1 && !facts.traceFields.includes(tracePath[0])) facts.traceFields.push(tracePath[0]);
+    }
+  });
+  return facts;
+}
+
+// Direct production proof for a test that awaits an imported, server-composed InterlockingRunner,
+// destructures its real resolution/trainResult pair, and leaves the whole local production chain
+// untampered. Assertion facts retain checker-symbol identity so a shadowed same-name literal cannot
+// satisfy any downstream route, runner, trace or sequence proof.
+export function directInterlockingExecutionProofs(testText, testFile, croot) {
+  if (!testText || !testFile || !croot ||
+    !/\bconst\s*\{(?=[^}\n]*\bresolution\b)(?=[^}\n]*\btrainResult\b)[^}\n]*\}[^=;\n]*=\s*await\b/.test(testText)) return [];
+  const ctx = analyze(testFile, testText);
+  const proofs = [];
+  walk(ctx.source, (node) => {
+    if (!ts.isVariableDeclaration(node) || !ts.isObjectBindingPattern(node.name) || !node.initializer ||
+      !(ts.isVariableDeclarationList(node.parent) && node.parent.flags & ts.NodeFlags.Const) ||
+      dead(node, ctx.source) || insideCatch(node, ctx.source)) return;
+    const call = awaitedCall(node.initializer);
+    if (!call || !ts.isCallExpression(call) || !ts.isPropertyAccessExpression(call.expression) ||
+      call.expression.name.text !== "execute" || !ts.isIdentifier(call.expression.expression)) return;
+    const imported = importedValue(ctx, call.expression.expression, croot);
+    if (!imported) return;
+    const composition = compositionProof(imported.file, imported.name, croot);
+    if (!composition) return;
+    const binding = (property) => {
+      const element = node.name.elements.find((candidate) => !candidate.dotDotDotToken &&
+        (candidate.propertyName ?? candidate.name).getText() === property);
+      return element && ts.isIdentifier(element.name) ? element.name : null;
+    };
+    const resolutionBinding = binding("resolution"), executionBinding = binding("trainResult");
+    const resolutionSymbol = resolutionBinding && symbolOf(ctx, resolutionBinding);
+    const executionSymbol = executionBinding && symbolOf(ctx, executionBinding);
+    if (!resolutionBinding || !executionBinding || !resolutionSymbol || !executionSymbol) return;
+    const closure = localImportClosure(testFile, croot);
+    const clean = [...closure].every((file) => {
+      const module = analyze(file);
+      return file === composition.interlockingFile
+        ? !tampered(module, (assignment) => assignment === composition.injection.node)
+        : !tampered(module);
+    });
+    if (clean) proofs.push({
+      resolution: resolutionBinding.text,
+      execution: executionBinding.text,
+      direct: directAssertionFacts(ctx, resolutionSymbol, executionSymbol),
+    });
+  });
+  return proofs;
+}
+
 // Exported functions of the module by name: declarations and const-bound arrow/function expressions.
 function exportedFunctions(ctx) {
   const out = new Map();

package/package.json

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