@afokapu/atdd-bun 0.10.108 → 0.10.110

package/detectors/bun_interlocking_coverage/_shared/interlocking.mjs

@@ -558,6 +558,7 @@ function resolutionTrainExecution(after, resolution, aliases = [], base = 0) {
   return {
     execution: assigned?.[1] ?? null,
     alias: alias?.alias ?? null,
+    aliasTraceFields: alias?.traceFields ?? null,
     found: Boolean(assigned || alias || new RegExp(legacy).test(after) || new RegExp(declaration).test(bound)),
     returned: new RegExp(`${returns}${legacy}`).test(after) || returnsMatch(scope, declaration, bound.length) ||
       Boolean(assigned && new RegExp(`${returns}${escaped(assigned[1])}\\s*;?`).test(after)),
@@ -579,7 +580,9 @@ export function productionExecutionProofs(text, file, croot) {
     const proof = resolutionTrainExecution(text.slice(base), resolution,
       file ? transparentCallbackAliases(text, file, resolution) : [], base);
     if (proof.found) proofs.push({ resolution, execution: proof.execution });
-    if (proof.alias && proof.alias !== proof.execution) proofs.push({ resolution, execution: proof.alias });
+    if (proof.alias && proof.alias !== proof.execution) {
+      proofs.push({ resolution, execution: proof.alias, callbackTraceFields: proof.aliasTraceFields });
+    }
   }
   return proofs;
 }
@@ -634,16 +637,23 @@ export function routeHasProductionProof(route, text, interlockingId = null, file
 }
 
 export function traceHasProductionProvenance(text, file, croot) {
-  return productionExecutionProofs(text, file, croot).some(({ execution, direct }) => {
+  return productionExecutionProofs(text, file, croot).some(({ execution, direct, callbackTraceFields }) => {
     if (direct) return direct.traceBound && REQUIRED_TRACE_FIELDS.every(([field]) => direct.traceFields.includes(field));
     if (!execution) return false;
     const trace = boundTraceName(text, execution);
-    return Boolean(trace);
+    return Boolean(trace) || Boolean(callbackTraceFields?.size);
   });
 }
 
-export function assertedTraceFields(text, traceName = "trace") {
-  return REQUIRED_TRACE_FIELDS.filter(([field]) => !assertsExpression(text, `${escaped(traceName)}${MEMBER}${field}`)).map(([field]) => field);
+// Required trace fields not asserted. A field also counts as asserted when a transparent callback return
+// alias of a production execution compares `<alias>.trace` to an object literal carrying it (the proofs
+// come from productionExecutionProofs, so only an execution proven for this file qualifies).
+export function assertedTraceFields(text, traceName = "trace", file, croot) {
+  const comparedWhole = new Set(file
+    ? productionExecutionProofs(text, file, croot).flatMap(({ callbackTraceFields }) => [...(callbackTraceFields ?? [])])
+    : []);
+  const asserted = (field) => comparedWhole.has(field) || assertsExpression(text, `${escaped(traceName)}${MEMBER}${field}`);
+  return REQUIRED_TRACE_FIELDS.filter(([field]) => !asserted(field)).map(([field]) => field);
 }
 
 // A smoke path has a real Station Master call and observes that call's returned value; separately

package/detectors/bun_interlocking_coverage/checks/interlocking_trace_binds.mjs

@@ -44,7 +44,7 @@ for (const scanRoot of roots) {
       if (!isInterlockingTest(text, tokens)) continue;
       const m = TRACE_OBJECT.exec(text);
       if (!m) continue; // not a trace-binding test.
-      const missing = assertedTraceFields(text);
+      const missing = assertedTraceFields(text, "trace", file, croot);
       const provenance = traceHasProductionProvenance(text, file, croot);
       if (!missing.length && provenance) continue;
       const line = lineOfIndex(text, m.index);

package/integrity.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.10.108",
+  "version": "0.10.110",
   "files": {
     "HOOK_AUDIT.md": "5329d840db37671b1918f688ead26865473b87db73dbc75f7c8b2a8bbe8d6d43",
     "README.md": "8aefceaa24bee498f39081b2aaf4c0d5c54bc1ed9849c20e1d98d1427df56eab",
@@ -384,13 +384,13 @@
     "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": "f6a716c4ef612a0f1bf7b612587c4af94d8e6aaa89ecdb8acee7cc977609bf43",
+    "detectors/bun_interlocking_coverage/_shared/interlocking.mjs": "6660f3cf9f16116114c4985111fefdb3666cb11d4049afc2854e544374be8168",
     "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",
     "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",
+    "detectors/bun_interlocking_coverage/checks/interlocking_trace_binds.mjs": "929f7ff757be481d71d38141283a4ca8622ccc7b344b31da06161252e19e25a2",
     "detectors/bun_interlocking_coverage/checks/interlocking_train_sequence.mjs": "28d0dd186f91f7aeb2f6672180d289ba6a02552581abda9562e41cca04bc3485",
     "detectors/bun_interlocking_coverage/detect.mjs": "122b928bbb49affbf187c59cbf8e10d0190ca84cb5b98bc222bd2c1c1aac2f26",
     "detectors/bun_interlocking_coverage/fixtures/clean/interlocking_production_runner/convex/trains/interlocking.ts": "e97288c4ca6084391bfa72d1457de26e99e9fa0c9540be4361e27731c19aeb6f",
@@ -1033,7 +1033,7 @@
     "lib/frontend.mjs": "d6d9b29c3d7f2d162cda03bb34b20a3224a82887b6be3db7cab375510913c9a3",
     "lib/imports.mjs": "3db4979269488fa26f6e7aefded6ece9c646be6587a10e249821a5a208109962",
     "lib/interlocking.mjs": "d0803d080ac7d7477c51be70112df1e85213d339fd3c6b71f75f26145fa8accd",
-    "lib/journey-chain.mjs": "bede441e5d61ea950ed5b76bbb6357ef0d2057cb29053ed32df1faab33ad9ac1",
+    "lib/journey-chain.mjs": "8ba32f5ab52bec636eb87b97a532427dcca81f3481a588a093ff4b5e643f7c8f",
     "lib/scan.mjs": "b6973e411ecd14c548a055c871e01e948f002b772042136be8401f38d998e687",
     "planner-nodes/ENFORCEMENT_SCOPE.yaml": "47aa9c78a4bb1754c6b435f5e056038baa04a24cd48df2c205db2bc08a3a3cac",
     "planner-nodes/nodes/planner.acceptance.abstract-fields-required.convention.yaml": "bd565693f0ae861f0561ad2f7a91a8c55f9a209c3acd59c5750cfcffd96a85d8",
@@ -1269,7 +1269,7 @@
     "src/cli.ts": "395638ab87565bb10c2beb35988ff1acf686924d13515795156a2e8893b3da88",
     "src/docs-capability.ts": "bdeeb414649049b1cd4fa8008cada3a576318be51c43bec91bfa46a8e250c270",
     "src/enforce.ts": "c4811abe63efe4568f3cf26e21a152d1537e120cb3ce471daca32367cf6e2cda",
-    "src/hooks.ts": "7e3dd5518701d2f3399bee919a68e801588822b173a648ed738c05c4a57231f1",
+    "src/hooks.ts": "fce67a102fe61c15b4100daddf842ce7264d9e0d0e79ec89c4ed4a0b188967b7",
     "src/index.ts": "4081f8b08d1d3ee9e15a9964143e53d9cfb94a5616ab3e58a180d24cc16dc381",
     "src/integrity.ts": "f1ede7cb04924ae88e11917047277e264af6596b9759e381bd9c497cd34a797d",
     "src/journey-docs.ts": "994d229376244c84212cff951032823068a76565dd2fd427b9d44e341bd14853",

package/lib/journey-chain.mjs

@@ -804,9 +804,12 @@ function localFunction(ctx, identifier) {
 // A wrapper whose every return, on every path, IS the unchanged result of its callback parameter:
 // `return work()` / `return await work()`. Anything that replaces, conditions, copies or discards the
 // callback's value (spread, ternary, comma, a second return value, a returning catch) is not transparent.
+// The callback is the wrapper's LAST parameter, so a leading configuration parameter is allowed
+// (`withDeployment(env, work)`); a callback in any other position, or a rest/destructured parameter, is not.
 function transparentWrapper(ctx, fn) {
-  const param = fn.parameters[0];
-  if (!param || !ts.isIdentifier(param.name) || param.dotDotDotToken || fn.asteriskToken) return false;
+  if (fn.asteriskToken || !fn.parameters.length) return false;
+  const param = fn.parameters[fn.parameters.length - 1];
+  if (!ts.isIdentifier(param.name) || param.dotDotDotToken) return false;
   const symbol = symbolOf(ctx, param.name);
   if (!symbol) return false;
   const isWork = (expression) => {
@@ -820,9 +823,42 @@ function transparentWrapper(ctx, fn) {
   return !rebound;
 }
 
-// `const <alias> = await <wrapper>(<callback>)` where the local wrapper is transparent and every return of
-// the zero-parameter callback IS the production execution of `resolution` (the call itself, or a `const`
-// bound to it), so `<alias>` IS that execution. Returns [{ alias, start }] in source order.
+// The required trace fields asserted by a whole-object comparison of `<execution>.trace` (or `?.trace`):
+// `expect(<execution>?.trace).toEqual|toStrictEqual|toMatchObject({ <field>: "<literal>", ... })`. The
+// expected value must be an object literal without spread, computed or shorthand members, each field a
+// string literal; a negated assertion, another object, or a non-literal expected value asserts nothing.
+const TRACE_COMPARISONS = new Set(["toEqual", "toStrictEqual", "toMatchObject"]);
+
+// The plain `name: <value>` members of an object literal (identifier or string-literal names only), or
+// null when any member is a spread, shorthand, method, accessor or computed name.
+function plainMembers(literal) {
+  if (!literal || !ts.isObjectLiteralExpression(literal)) return null;
+  const plain = literal.properties.every((property) => ts.isPropertyAssignment(property) &&
+    (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)));
+  return plain ? literal.properties : null;
+}
+
+function wholeTraceFields(ctx, executionSymbol) {
+  const fields = new Set();
+  if (!executionSymbol) return fields;
+  walk(ctx.source, (node) => {
+    const assertion = expectAssertion(ctx, node);
+    if (!assertion || assertion.negated || !TRACE_COMPARISONS.has(assertion.matcher) ||
+      dead(node, ctx.source) || insideCatch(node, ctx.source)) return;
+    const path = pathFromSymbol(ctx, assertion.actual, executionSymbol);
+    if (path?.length !== 1 || path[0] !== "trace") return;
+    for (const property of plainMembers(assertion.expected && unwrap(assertion.expected)) ?? []) {
+      if (ts.isStringLiteralLike(property.initializer)) fields.add(property.name.text);
+    }
+  });
+  return fields;
+}
+
+// `const <alias> = await <wrapper>(<callback>)` or `await <wrapper>(<configuration>..., <callback>)` where
+// the local wrapper is transparent and every return of the zero-parameter callback IS the production
+// execution of `resolution` (the call itself, or a `const` bound to it), so `<alias>` IS that execution.
+// Returns [{ alias, start, traceFields }] in source order; `traceFields` are the trace fields the alias
+// asserts as a whole object (see wholeTraceFields).
 // Production forms: `new TrainRunner(<resolution>.trainId|selectedTrainId).execute(...)` and
 // `new TrainRunner(<resolution>.trainPath, ...).execute(<resolution>, ...)`.
 export function transparentCallbackAliases(text, file, resolution) {
@@ -862,14 +898,19 @@ export function transparentCallbackAliases(text, file, resolution) {
       !(ts.isVariableDeclarationList(node.parent) && node.parent.flags & ts.NodeFlags.Const) ||
       dead(node, ctx.source) || insideCatch(node, ctx.source)) return;
     const awaited = awaitedCall(node.initializer);
-    if (!awaited || !ts.isCallExpression(awaited) || !ts.isIdentifier(awaited.expression) || awaited.arguments.length !== 1) return;
-    const callback = unwrap(awaited.arguments[0]);
+    if (!awaited || !ts.isCallExpression(awaited) || !ts.isIdentifier(awaited.expression) || !awaited.arguments.length ||
+      awaited.arguments.some(ts.isSpreadElement)) return;
+    const callback = unwrap(awaited.arguments[awaited.arguments.length - 1]);
     if (!callback || !(ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) ||
       callback.parameters.length > 0 || callback.asteriskToken) return;
     const wrapper = localFunction(ctx, awaited.expression);
-    if (!wrapper || !transparentWrapper(ctx, wrapper)) return;
+    if (!wrapper || wrapper.parameters.length !== awaited.arguments.length || !transparentWrapper(ctx, wrapper)) return;
     if (!alwaysReturns(callback, (expression) => isIdentity(expression))) return;
-    aliases.push({ alias: node.name.text, start: node.getStart(ctx.source) });
+    aliases.push({
+      alias: node.name.text,
+      start: node.getStart(ctx.source),
+      traceFields: wholeTraceFields(ctx, symbolOf(ctx, node.name)),
+    });
   });
   return aliases;
 }

package/package.json

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

package/src/hooks.ts

@@ -345,7 +345,7 @@ type PrimaryPolicy = { policy: HookPolicy; source: { path: string; commit: strin
 async function primaryPolicy(root: string): Promise<PrimaryPolicy> { const found = await primaryRoot(await realpath(resolve(root))); if (!found) return { policy: defaultHookPolicy, source: null }; const primary = await realpath(found), revision = await git(primary, ["rev-parse", "--verify", "HEAD^{commit}"]); if (revision.code || !revision.out) return { policy: defaultHookPolicy, source: null }; const source = { path: primary, commit: revision.out }, committed = await git(primary, ["show", `${source.commit}:atdd-bun.yaml`]); return { policy: committed.code ? defaultHookPolicy : parsePolicy(committed.out), source }; }
 const disabledWorktreePolicy = (source: PrimaryPolicy["source"]) => bad(source ? `worktree policy is disabled in primary checkout ${source.path} at ${source.commit}; update the primary checkout and try again` : "worktree policy is disabled");
 export type WorktreeLayout = { primary: string; worktreeRoot: string; current: string; branch: string };
-async function layout(root: string, cfg: WorktreePolicy): Promise<WorktreeLayout | { error: string }> { const current = await realpath(resolve(root)), commonRoot = await primaryRoot(current); if (!commonRoot) return { error: "not inside a Git worktree" }; const primary = await realpath(commonRoot), expectedPrimary = cfg.primary_directory === "." ? primary : join(dirname(primary), cfg.primary_directory); if (primary !== expectedPrimary) return { error: `primary checkout must be ${expectedPrimary}, not ${primary}` }; const branch = (await git(primary, ["symbolic-ref", "--quiet", "--short", "HEAD"])).out; if (branch !== cfg.primary_branch) return { error: `primary checkout ${primary} must be on ${cfg.primary_branch}, not ${branch || "a detached HEAD"}` }; return { primary, worktreeRoot: resolve(primary, cfg.root.replaceAll("{repo}", basename(primary))), current, branch: (await git(current, ["symbolic-ref", "--quiet", "--short", "HEAD"])).out }; }
+async function layout(root: string, cfg: WorktreePolicy): Promise<WorktreeLayout | { error: string }> { const current = await realpath(resolve(root)), commonRoot = await primaryRoot(current); if (!commonRoot) return { error: "not inside a Git worktree" }; const primary = await realpath(commonRoot), expectedPrimary = cfg.primary_directory === "." ? primary : join(dirname(primary), cfg.primary_directory); if (primary !== expectedPrimary) return { error: `primary checkout must be ${expectedPrimary}, not ${primary}` }; const branch = (await git(primary, ["symbolic-ref", "--quiet", "--short", "HEAD"])).out; if (branch !== cfg.primary_branch && !(await jjPrimaryOnBranch(primary, cfg.primary_branch))) return { error: `primary checkout ${primary} must be on ${cfg.primary_branch}, not ${branch || "a detached HEAD"}` }; return { primary, worktreeRoot: resolve(primary, cfg.root.replaceAll("{repo}", basename(primary))), current, branch: (await git(current, ["symbolic-ref", "--quiet", "--short", "HEAD"])).out }; }
 async function worktreeCommitPolicy(root: string, cfg: WorktreePolicy): Promise<string | null> { if (!cfg.enabled || !cfg.require_linked_worktree) return null; const state = await layout(root, cfg); if ("error" in state) return state.error; if (state.current === state.primary) return `commits must use a linked worktree beneath ${state.worktreeRoot}; run: atdd-bun worktree start <branch>`; if (!inside(state.worktreeRoot, state.current)) return `linked worktree ${state.current} is outside required root ${state.worktreeRoot}`; if (!state.branch) return "commits require a named branch, not a detached HEAD"; return null; }
 
 export async function runHook(event: HookEvent, root = process.cwd(), args: string[] = [], stdin = "") {
@@ -421,6 +421,17 @@ async function branchForCommit(root: string, commit: string, protectedBranches:
     : { error: `current Jujutsu revision must have exactly one non-protected exported bookmark; found ${candidates.length}` };
 }
 
+// A JJ-colocated primary keeps Git HEAD detached at its working-copy parent, so JJ state decides:
+// the parent must be exactly one commit and it must be the primary branch or its origin bookmark.
+async function jjPrimaryOnBranch(primary: string, branch: string): Promise<boolean> {
+  if (!existsSync(join(primary, ".jj"))) return false;
+  const name = JSON.stringify(branch), lines = async (revset: string) => {
+    const result = await jj(primary, ["log", "--ignore-working-copy", "--no-graph", "-r", revset, "-T", 'commit_id ++ "\\n"']).catch(() => null);
+    return result && !result.code ? result.out.split("\n").filter(Boolean) : [];
+  };
+  return (await lines("@-")).length === 1 && (await lines(`@- & (bookmarks(exact:${name}) | remote_bookmarks(exact:${name}, exact:"origin"))`)).length === 1;
+}
+
 type Layout = { primary: string; worktreeRoot: string; current: string };
 async function jjLayout(root: string, cfg: HookPolicy): Promise<Layout | { error: string }> {
   const current = await realpath(resolve(root));