@afokapu/atdd-bun 0.10.79 → 0.10.81

package/conventions/coder.bun/coder.bun.duplication-intra-layer.convention.yaml

@@ -56,6 +56,7 @@ content:
   - Test, spec, and `.d.ts` files are excluded, as are `index.ts` barrels and `__tests__` directories.
   - Trivial lines (bare braces, closing punctuation) are not counted toward the 7.
   - Import and re-export declarations are not counted, because two files importing the same names from one shared module match because the logic was shared, which is the fix this rule asks for.
+  - Property signatures inside a `type X = {` or `interface X {` body (optional `readonly`, a name, optional `?`, `:` a type, ending `;` or `,`), including the members of nested object types, are not counted, because two unrelated records with the same number of same-typed fields match once identifiers are folded and neither coupling them nor a cosmetic edit is a fix. Executable statements, object literals, class fields, enum bodies, and method bodies still count.
   - Files whose layer cannot be determined are compared only against each other.
 metadata:
   aliases:

package/detectors/bun_interlocking_coverage/checks/interlocking_production_runner.mjs

@@ -29,6 +29,7 @@ import {
   mk,
   writeReport,
 } from "../_shared/interlocking.mjs";
+import { assertedJourneyExecution } from "../../../lib/journey-chain.mjs";
 
 const RULE = "tester.bun.interlocking-production-runner-used";
 const roots = parseJsonEnv("ATDD_SCAN_ROOTS", []);
@@ -72,7 +73,9 @@ for (const scanRoot of roots) {
         }
       }
 
-      const semantic = hasProductionExecutionProof(text, file, croot) ||
+      // A journey test drives the runners through the production JourneyRunner: its asserted result counts
+      // when the journey-mediated chain is proven on the AST (lib/journey-chain.mjs), as for the Station Master.
+      const semantic = hasProductionExecutionProof(text, file, croot) || assertedJourneyExecution(raw, file, croot) ||
         records.some((rec) => rec.actions.some((action) => stationMasterExecutionProof(text, action))) ||
         (drivesStationMaster(text) && records.some((rec) => rec.actions.some((action) =>
           stationModuleExecutionProof(text, station.text, action, station.file, croot),

package/detectors/bun_ts_metrics_detector/ts_metrics.mjs

@@ -234,19 +234,50 @@ export const isTrivial = (n) => TRIVIAL.has(n);
 const DECLARATION = /^(import\b|export (type )?(\{|\*))/;
 const DECLARATION_END = /\bfrom "S"|^import "S"|\}/;
 
+// Property signatures inside a `type X = {` / `interface X {` body are not code either: once
+// identifiers are folded, two unrelated records with seven `readonly id: string;` members match
+// line for line, and neither coupling the records nor a cosmetic edit is a fix. A member line
+// (optional `readonly`, a name, optional `?`, `:` a type, ending `;` or `,`), a member that opens a
+// nested object type, and that nested type's closing line are left out of the windows. The body
+// is tracked by brace depth; anything else inside it (a method signature, say) still counts.
+const TYPE_BODY = /^(export )?(declare )?(type ID(<[^>]*>)? = \{|interface ID(<.*>)?( extends [^{]*)? \{)$/;
+const MEMBER = /^(readonly )?(ID|"S")\??: (.*[;,]|\{)$|^\}[;,]?$/;
+const braceDelta = (n) => (n.match(/\{/g) ?? []).length - (n.match(/\}/g) ?? []).length;
+// normalizeLine strips a block comment only when it closes on the same line, so a multi-line
+// comment's text (say a JSDoc ` * shape like { a`) would reach braceDelta and keep the body open
+// for the rest of the file. The body is tracked on the code part of each line only; whether the
+// line counts toward a window is unchanged.
+function codePart(n, inComment) {
+  let code = n;
+  if (inComment) {
+    const close = code.indexOf("*/");
+    if (close < 0) return { code: "", inComment: true };
+    code = code.slice(close + 2).trim();
+  }
+  const open = code.indexOf("/*");
+  return open < 0 ? { code, inComment: false } : { code: code.slice(0, open).trim(), inComment: true };
+}
+
 // A 16-hex-char digest of each `minLines` window of non-trivial normalized lines —
 // the same fingerprint shape the Python detector hashes with sha256[:16].
 export function fragments(source, minLines, hasher) {
   const nonTrivial = [];
   let inDeclaration = false;
+  let typeDepth = 0;
+  let inComment = false;
   source.split("\n").forEach((line, i) => {
     const n = normalizeLine(line);
+    const part = codePart(n, inComment);
+    inComment = part.inComment;
     if (!inDeclaration && DECLARATION.test(n)) inDeclaration = true;
     if (inDeclaration) {
       if (DECLARATION_END.test(n)) inDeclaration = false;
       return;
     }
-    if (!isTrivial(n)) nonTrivial.push([i + 1, n]);
+    const member = typeDepth > 0 && MEMBER.test(part.code);
+    if (typeDepth > 0) typeDepth = Math.max(0, typeDepth + braceDelta(part.code));
+    else if (TYPE_BODY.test(part.code)) typeDepth = 1;
+    if (!member && !isTrivial(n)) nonTrivial.push([i + 1, n]);
   });
   if (nonTrivial.length < minLines) return [];
   const out = [];

package/integrity.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.10.79",
+  "version": "0.10.81",
   "files": {
     "HOOK_AUDIT.md": "5329d840db37671b1918f688ead26865473b87db73dbc75f7c8b2a8bbe8d6d43",
     "PLANNER_PORT.md": "fb5935bac8b7ac18994de21e43ace3a5ef8cd55f85b0e3349fca261280054f11",
@@ -59,7 +59,7 @@
     "conventions/coder.bun/coder.bun.dto-mapper.convention.yaml": "c524b5f37db6ae4f7558fc3ec672aa1c5b764738a0f25a20062d736fed6bbcb3",
     "conventions/coder.bun/coder.bun.dto-placement.convention.yaml": "9525255f9e037ca0d939de20e70235fe348dcebf2136536055bc21433d7e9fb5",
     "conventions/coder.bun/coder.bun.dto-purity.convention.yaml": "4743199fb242a25f896425916e3873c2e8cf62f4285437f62b0f8f8139d6a58d",
-    "conventions/coder.bun/coder.bun.duplication-intra-layer.convention.yaml": "37c0b9da0d3b5a7c7229e0697ea283249bd42cea056b0f1d6345a408ab50a7ea",
+    "conventions/coder.bun/coder.bun.duplication-intra-layer.convention.yaml": "023310241a28e6a7aad5cf020bd1b9d4e05a887ddd92dbcd4c13b8a45e26ae6e",
     "conventions/coder.bun/coder.bun.error-response-bare-string.convention.yaml": "c2c0f859f6dd12702edf225c4148849e72b6c25e6d7cd28edd5d644ba277a23c",
     "conventions/coder.bun/coder.bun.error-response-code-format.convention.yaml": "3048fed00b92c2559f7c52f73cfcce07b583eb47b12d04f0851e237ae3646567",
     "conventions/coder.bun/coder.bun.green-header-order.convention.yaml": "2a42d67bedeec1de76fa1de844351983c5ba4bc5b61d5a5047298f6804664f67",
@@ -388,7 +388,7 @@
     "detectors/bun_interlocking_coverage/_shared/interlocking.mjs": "8a90490daaaa6eecf4c971fb569da38156b45969d48755dbcf355175dde0b079",
     "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": "d16329bae24d94b41498003fa0a9636e31363d983022c9938fdc1e574fdfd8af",
+    "detectors/bun_interlocking_coverage/checks/interlocking_production_runner.mjs": "97224d46f0c4c3259f15e41f90bb7f9f5a4e651d4facd41f1e037cac919be500",
     "detectors/bun_interlocking_coverage/checks/interlocking_route_coverage.mjs": "a2cff94a6bf9e11fe8e370332551742f9c7db317dcd57a88d08dc6c74f868f49",
     "detectors/bun_interlocking_coverage/checks/interlocking_smoke_coverage.mjs": "28e016e1a4cd394291640679876b16c7d6a725530c7fbfa4bd1da8a354ecff86",
     "detectors/bun_interlocking_coverage/checks/interlocking_trace_binds.mjs": "1cc3a11d50a075f3211a6d9cbf27aafcbf7e77b6a855ab040f765ec89dfe0eef",
@@ -741,7 +741,7 @@
     "detectors/bun_ts_metrics_detector/fixtures/dirty/long.ts": "b87149b1b550a00bc2de2b2b21a4d9925572c002221941fae8135e8fe0c27cd1",
     "detectors/bun_ts_metrics_detector/fixtures/dirty/orphan.ts": "0f7acd0dffe90902a0a43cc45771b8a473d079efc9693112b3b85645c191c23d",
     "detectors/bun_ts_metrics_detector/fixtures/dirty/typed.ts": "7c27ee1a674af7d5b2cce3a65bfec2111602d84a75817fd60f737c7d63fc9c83",
-    "detectors/bun_ts_metrics_detector/ts_metrics.mjs": "d5da8c768dd7fe1717cc7f29b4115f8b2573c945cf9fb2e6d7c2d76adc186417",
+    "detectors/bun_ts_metrics_detector/ts_metrics.mjs": "7ccfd393b38b0d0f45ab13bffaefdeeef782818af5194d8ff3d6fce5ae34ff44",
     "detectors/htmx_e2e_detector/atdd.implementation.yaml": "454bb123039d57c992d27d9274e20fa3452ac41a237eb55471be62a4bcfebf06",
     "detectors/htmx_e2e_detector/checks/_e2e.mjs": "efec6c8e3dc8b95bf3acd826397ecdedac64c06d367791a4017a272bc0660896",
     "detectors/htmx_e2e_detector/checks/_map.json": "94dec08ff4764cd6a3dba139f12a7c984292e95a9354b0cdaa0ce9d4180e2c89",
@@ -1034,7 +1034,7 @@
     "lib/frontend.mjs": "d6d9b29c3d7f2d162cda03bb34b20a3224a82887b6be3db7cab375510913c9a3",
     "lib/imports.mjs": "3db4979269488fa26f6e7aefded6ece9c646be6587a10e249821a5a208109962",
     "lib/interlocking.mjs": "d0803d080ac7d7477c51be70112df1e85213d339fd3c6b71f75f26145fa8accd",
-    "lib/journey-chain.mjs": "aaa0e6acdd73f1a8cfeea9a523a86c6d3133c020c37f97e7ec61db00f957ec6a",
+    "lib/journey-chain.mjs": "bdafc9cc3da4ade644aebacc6e1015e29285b764465588d764b7c581bade9025",
     "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

@@ -647,6 +647,81 @@ export function provenJourneyAction(stationText, stationFile, croot, name) {
     everyModule(modules, "JourneyRunner", journeyExecutes(croot));
 }
 
+// The tester assertion vocabulary (shared tester layer `assertsExpression`), positive and under `.not`.
+const MATCHERS = new Set(["toBe", "toBeDefined", "toEqual", "toStrictEqual", "toContain", "toContainEqual", "toMatchObject", "toMatch", "toBeTruthy"]);
+const NEGATED_MATCHERS = new Set([...MATCHERS].filter((name) => name !== "toBeTruthy"));
+
+// The journey declaration at `path` (relative to the consumer root, where its tests run) declares
+// `action` among its entrypoint actions.
+function declaresAction(croot, path, action) {
+  const file = resolve(croot, path);
+  if (!file.startsWith(resolve(croot) + sep) || !existsSync(file) || !statSync(file).isFile() || !globalThis.Bun?.YAML) return false;
+  try {
+    const actions = Bun.YAML.parse(readFileSync(file, "utf8"))?.entrypoint?.actions;
+    return Array.isArray(actions) && actions.includes(action);
+  } catch {
+    return false;
+  }
+}
+
+// A test module asserts a production JourneyRunner execution result, proven like provenJourneyAction:
+//   - a live `const` bound to `await <receiver>.execute("<action>", ...)`, the receiver being
+//     `new JourneyRunner("<journey declaration>")` or a const bound to one;
+//   - JourneyRunner binds to a local production import, and the declaration it is constructed from
+//     exists under the consumer root and declares that action;
+//   - the JourneyRunner module reaches InterlockingRunner -> TrainRunner (journeyExecutes);
+//   - a live `expect(<result or a member chain of it>).<matcher>(...)` whose argument binds to that
+//     const by checker symbol, not by spelling.
+// The override contract covers the test module and every local module it reaches.
+export function assertedJourneyExecution(testText, testFile, croot) {
+  if (!testText || !testFile || !croot) return false;
+  const ctx = analyze(testFile, testText);
+  if (tampered(ctx) || [...localImportClosure(testFile, croot)].some((module) => tampered(analyze(module)))) return false;
+  const results = 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 awaited = ts.isAwaitExpression(node.initializer) ? unwrap(node.initializer) : null;
+    const action = awaited && ts.isCallExpression(awaited) && awaited.arguments[0];
+    if (!action || !ts.isStringLiteralLike(action) || dead(node, ctx.source) || insideCatch(node, ctx.source)) return;
+    const fromDeclaration = (construction) => {
+      const path = construction.arguments?.[0];
+      return Boolean(path && ts.isStringLiteralLike(path) && declaresAction(croot, path.text, action.text));
+    };
+    const modules = new Set();
+    if (executesImported(ctx, "JourneyRunner", croot, modules, fromDeclaration)(awaited) &&
+      everyModule(modules, "JourneyRunner", journeyExecutes(croot))) results.add(symbolOf(ctx, node.name));
+  });
+  if (!results.size) return false;
+  const boundToResult = (node) => {
+    node = unwrap(node);
+    while (node && ts.isPropertyAccessExpression(node)) node = unwrap(node.expression);
+    return Boolean(node) && ts.isIdentifier(node) && results.has(symbolOf(ctx, node));
+  };
+  const isExpect = (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");
+  };
+  let asserted = false;
+  walk(ctx.source, (node) => {
+    if (asserted) return false;
+    if (!ts.isCallExpression(node) || !isExpect(node.expression) || !boundToResult(node.arguments[0]) || dead(node, ctx.source)) return;
+    let access = node.parent, matchers = MATCHERS;
+    if (!ts.isPropertyAccessExpression(access) || access.expression !== node) return;
+    if (access.name.text === "not") {
+      access = access.parent;
+      matchers = NEGATED_MATCHERS;
+    }
+    asserted = ts.isPropertyAccessExpression(access) && matchers.has(access.name.text) &&
+      ts.isCallExpression(access.parent) && access.parent.expression === access;
+  });
+  return asserted;
+}
+
 // Names of every exported Station Master action proven by provenJourneyAction.
 export function provenJourneyActions(stationText, stationFile, croot) {
   if (!stationText || !stationFile || !croot) return [];

package/package.json

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