@afokapu/atdd-bun 0.1.0

package/detectors/bun_interlocking_infrastructure/fixtures/dirty/interlocking_delegates/src/match/wagon.ts

@@ -0,0 +1,6 @@
+// match wagon — CLEAN fixture. A wagon transforms artifacts. It reads and returns a data map and
+// does NOT import interlocking code (Cargo boundary, core afokapu/atdd#1251).
+export function runMatch(cargo: Map<string, unknown>): Map<string, unknown> {
+  cargo.set("match", { result: { validForRanked: true } });
+  return cargo;
+}

package/detectors/bun_interlocking_infrastructure/fixtures/dirty/interlocking_delegates/src/trains/interlocking.ts

@@ -0,0 +1,49 @@
+// DIRTY fixture — coder.bun.interlocking-delegates-to-trainrunner.
+// The InterlockingRunner module imports a wagon directly, calls runTrain(...), and loops over
+// train.sequence as a step executor — competing with TrainRunner instead of delegating.
+// Expected: >=1 violation (interlocking-direct-wagon-execution).
+import { runMatch } from "../match/wagon";
+
+export interface InterlockingResolution {
+  interlockingId: string;
+  routeId: string;
+  trainId: string;
+  trainPath: string;
+  category: string;
+  resolutionStrategy: string;
+  guardId: string;
+  reason: string;
+}
+
+export class InterlockingRunner {
+  constructor(private readonly path: string) {}
+
+  resolveTrain(action: string, inputs: Record<string, unknown>): InterlockingResolution {
+    return {
+      interlockingId: "interlocking:match-resolution",
+      routeId: "nominal-all-voted",
+      trainId: "train:match:solo-match-complete",
+      trainPath: "plan/_trains/train:match:solo-match-complete.yaml",
+      category: "nominal",
+      resolutionStrategy: "first_priority",
+      guardId: "all-voted",
+      reason: "all participants voted",
+    };
+  }
+
+  execute(action: string, inputs: Record<string, unknown>) {
+    const resolution = this.resolveTrain(action, inputs);
+    const train = { sequence: ["match"] };
+    let acc: Record<string, unknown> = inputs;
+    // BUG: interlocking duplicates the TrainRunner step loop and executes wagons itself.
+    for (const step of train.sequence) {
+      acc = runTrain(step, acc);
+    }
+    return { selectedTrainId: resolution.trainId, artifacts: acc };
+  }
+}
+
+function runTrain(step: string, acc: Record<string, unknown>): Record<string, unknown> {
+  if (step === "match") return runMatch(new Map()) as unknown as Record<string, unknown>;
+  return acc;
+}

package/detectors/bun_interlocking_infrastructure/fixtures/dirty/interlocking_delegates/src/trains/runner.ts

@@ -0,0 +1,28 @@
+// TrainRunner — CLEAN fixture. The production linear train executor: the ONLY component that runs
+// wagons and carries Cargo between them. Legitimate execution; not scanned by the interlocking
+// detector (only InterlockingRunner-defining modules are scanned for direct wagon execution).
+import { runMatch } from "../match/wagon";
+
+export class Cargo extends Map<string, unknown> {}
+
+export class TrainRunner {
+  constructor(private readonly trainPath: string) {}
+
+  execute(trainId: string, inputs: Record<string, unknown>) {
+    let cargo: Cargo = new Cargo(Object.entries(inputs));
+    const train = loadTrain(this.trainPath);
+    for (const step of train.sequence) {
+      cargo = runTrain(step, cargo);
+    }
+    return { selectedTrainId: trainId, artifacts: Object.fromEntries(cargo) };
+  }
+}
+
+function runTrain(step: string, cargo: Cargo): Cargo {
+  if (step === "match") return runMatch(cargo) as Cargo;
+  return cargo;
+}
+
+function loadTrain(_path: string) {
+  return { sequence: ["match"] };
+}

package/detectors/bun_interlocking_infrastructure/fixtures/dirty/interlocking_no_cargo/server.ts

@@ -0,0 +1,22 @@
+// Station Master composition root — CLEAN fixture. Routes both a direct trainId mapping and an
+// interlocking route object, references the InterlockingRunner route-control layer, and ultimately
+// delegates execution to TrainRunner (core afokapu/atdd#1251).
+import { InterlockingRunner } from "./src/trains/interlocking";
+import { TrainRunner } from "./src/trains/runner";
+
+export const JOURNEY_MAP: Record<string, string | { interlockingId: string; path: string }> = {
+  start_match: "train:match:solo-match-complete",
+  resolve_match: {
+    interlockingId: "interlocking:match-resolution",
+    path: "plan/_trains/_interlockings/match-resolution.yaml",
+  },
+};
+
+export function dispatch(action: string, inputs: Record<string, unknown>, state?: unknown) {
+  const mapping = JOURNEY_MAP[action];
+  if (typeof mapping === "string") {
+    return new TrainRunner(`plan/_trains/${mapping}.yaml`).execute(mapping, inputs);
+  }
+  const runner = new InterlockingRunner(mapping.path);
+  return runner.execute(action, inputs, state);
+}

package/detectors/bun_interlocking_infrastructure/fixtures/dirty/interlocking_no_cargo/src/match/wagon.ts

@@ -0,0 +1,11 @@
+// DIRTY fixture — coder.bun.interlocking-does-not-carry-cargo (wagon side).
+// A wagon MUST NOT import interlocking code — that couples the artifact plane to route control.
+// Expected: >=1 violation (wagon-imports-interlocking).
+import { InterlockingRunner } from "../src/trains/interlocking";
+
+export function runMatch(cargo: Map<string, unknown>): Map<string, unknown> {
+  // BUG: wagon reaches into the route-control layer.
+  const _runner = InterlockingRunner;
+  cargo.set("match", { result: { validForRanked: true } });
+  return cargo;
+}

package/detectors/bun_interlocking_infrastructure/fixtures/dirty/interlocking_no_cargo/src/trains/interlocking.ts

@@ -0,0 +1,42 @@
+// DIRTY fixture — coder.bun.interlocking-does-not-carry-cargo.
+// The InterlockingRunner module references the Cargo data plane and stores an artifact_urn value,
+// bleeding the artifact plane into the route-control layer.
+// Expected: >=1 violation (interlocking-cargo-mutation).
+import { TrainRunner } from "./runner";
+import { Cargo } from "./runner";
+
+export interface InterlockingResolution {
+  interlockingId: string;
+  routeId: string;
+  trainId: string;
+  trainPath: string;
+  category: string;
+  resolutionStrategy: string;
+  guardId: string;
+  reason: string;
+}
+
+export class InterlockingRunner {
+  constructor(private readonly path: string) {}
+
+  resolveTrain(action: string, inputs: Record<string, unknown>): InterlockingResolution {
+    // BUG: the interlocking reads/mutates Cargo and stores an artifact_urn value mid-resolution.
+    const cargo = new Cargo();
+    cargo["artifact_urn"] = "urn:artifact:match:result";
+    return {
+      interlockingId: "interlocking:match-resolution",
+      routeId: "nominal-all-voted",
+      trainId: "train:match:solo-match-complete",
+      trainPath: "plan/_trains/train:match:solo-match-complete.yaml",
+      category: "nominal",
+      resolutionStrategy: "first_priority",
+      guardId: "all-voted",
+      reason: "all participants voted",
+    };
+  }
+
+  execute(action: string, inputs: Record<string, unknown>) {
+    const resolution = this.resolveTrain(action, inputs);
+    return new TrainRunner(resolution.trainPath).execute(resolution.trainId, inputs);
+  }
+}

package/detectors/bun_interlocking_infrastructure/fixtures/dirty/interlocking_no_cargo/src/trains/runner.ts

@@ -0,0 +1,28 @@
+// TrainRunner — CLEAN fixture. The production linear train executor: the ONLY component that runs
+// wagons and carries Cargo between them. Legitimate execution; not scanned by the interlocking
+// detector (only InterlockingRunner-defining modules are scanned for direct wagon execution).
+import { runMatch } from "../match/wagon";
+
+export class Cargo extends Map<string, unknown> {}
+
+export class TrainRunner {
+  constructor(private readonly trainPath: string) {}
+
+  execute(trainId: string, inputs: Record<string, unknown>) {
+    let cargo: Cargo = new Cargo(Object.entries(inputs));
+    const train = loadTrain(this.trainPath);
+    for (const step of train.sequence) {
+      cargo = runTrain(step, cargo);
+    }
+    return { selectedTrainId: trainId, artifacts: Object.fromEntries(cargo) };
+  }
+}
+
+function runTrain(step: string, cargo: Cargo): Cargo {
+  if (step === "match") return runMatch(cargo) as Cargo;
+  return cargo;
+}
+
+function loadTrain(_path: string) {
+  return { sequence: ["match"] };
+}

package/detectors/bun_interlocking_infrastructure/fixtures/dirty/interlocking_resolution_model/server.ts

@@ -0,0 +1,22 @@
+// Station Master composition root — CLEAN fixture. Routes both a direct trainId mapping and an
+// interlocking route object, references the InterlockingRunner route-control layer, and ultimately
+// delegates execution to TrainRunner (core afokapu/atdd#1251).
+import { InterlockingRunner } from "./src/trains/interlocking";
+import { TrainRunner } from "./src/trains/runner";
+
+export const JOURNEY_MAP: Record<string, string | { interlockingId: string; path: string }> = {
+  start_match: "train:match:solo-match-complete",
+  resolve_match: {
+    interlockingId: "interlocking:match-resolution",
+    path: "plan/_trains/_interlockings/match-resolution.yaml",
+  },
+};
+
+export function dispatch(action: string, inputs: Record<string, unknown>, state?: unknown) {
+  const mapping = JOURNEY_MAP[action];
+  if (typeof mapping === "string") {
+    return new TrainRunner(`plan/_trains/${mapping}.yaml`).execute(mapping, inputs);
+  }
+  const runner = new InterlockingRunner(mapping.path);
+  return runner.execute(action, inputs, state);
+}

package/detectors/bun_interlocking_infrastructure/fixtures/dirty/interlocking_resolution_model/src/match/wagon.ts

@@ -0,0 +1,6 @@
+// match wagon — CLEAN fixture. A wagon transforms artifacts. It reads and returns a data map and
+// does NOT import interlocking code (Cargo boundary, core afokapu/atdd#1251).
+export function runMatch(cargo: Map<string, unknown>): Map<string, unknown> {
+  cargo.set("match", { result: { validForRanked: true } });
+  return cargo;
+}

package/detectors/bun_interlocking_infrastructure/fixtures/dirty/interlocking_resolution_model/src/trains/interlocking.ts

@@ -0,0 +1,21 @@
+// DIRTY fixture — coder.bun.interlocking-resolution-model-exists.
+// resolveTrain resolves a BARE trainId string; there is no structured InterlockingResolution model
+// carrying routeId/guardId/category/... Expected: >=1 violation (bare-train-id-resolution).
+import { TrainRunner } from "./runner";
+
+export class InterlockingRunner {
+  private readonly path: string;
+  constructor(interlockingYamlPath: string) {
+    this.path = interlockingYamlPath;
+  }
+
+  // BUG: returns a bare trainId string — loses routeId, guardId, category, resolutionStrategy, reason, ...
+  resolveTrain(action: string, inputs: Record<string, unknown>): string {
+    return "train:match:solo-match-complete";
+  }
+
+  execute(action: string, inputs: Record<string, unknown>) {
+    const trainId = this.resolveTrain(action, inputs);
+    return new TrainRunner(`plan/_trains/${trainId}.yaml`).execute(trainId, inputs);
+  }
+}

package/detectors/bun_interlocking_infrastructure/fixtures/dirty/interlocking_resolution_model/src/trains/runner.ts

@@ -0,0 +1,28 @@
+// TrainRunner — CLEAN fixture. The production linear train executor: the ONLY component that runs
+// wagons and carries Cargo between them. Legitimate execution; not scanned by the interlocking
+// detector (only InterlockingRunner-defining modules are scanned for direct wagon execution).
+import { runMatch } from "../match/wagon";
+
+export class Cargo extends Map<string, unknown> {}
+
+export class TrainRunner {
+  constructor(private readonly trainPath: string) {}
+
+  execute(trainId: string, inputs: Record<string, unknown>) {
+    let cargo: Cargo = new Cargo(Object.entries(inputs));
+    const train = loadTrain(this.trainPath);
+    for (const step of train.sequence) {
+      cargo = runTrain(step, cargo);
+    }
+    return { selectedTrainId: trainId, artifacts: Object.fromEntries(cargo) };
+  }
+}
+
+function runTrain(step: string, cargo: Cargo): Cargo {
+  if (step === "match") return runMatch(cargo) as Cargo;
+  return cargo;
+}
+
+function loadTrain(_path: string) {
+  return { sequence: ["match"] };
+}

package/detectors/bun_interlocking_infrastructure/fixtures/dirty/interlocking_runner_exists/server.ts

@@ -0,0 +1,22 @@
+// Station Master composition root — CLEAN fixture. Routes both a direct trainId mapping and an
+// interlocking route object, references the InterlockingRunner route-control layer, and ultimately
+// delegates execution to TrainRunner (core afokapu/atdd#1251).
+import { InterlockingRunner } from "./src/trains/interlocking";
+import { TrainRunner } from "./src/trains/runner";
+
+export const JOURNEY_MAP: Record<string, string | { interlockingId: string; path: string }> = {
+  start_match: "train:match:solo-match-complete",
+  resolve_match: {
+    interlockingId: "interlocking:match-resolution",
+    path: "plan/_trains/_interlockings/match-resolution.yaml",
+  },
+};
+
+export function dispatch(action: string, inputs: Record<string, unknown>, state?: unknown) {
+  const mapping = JOURNEY_MAP[action];
+  if (typeof mapping === "string") {
+    return new TrainRunner(`plan/_trains/${mapping}.yaml`).execute(mapping, inputs);
+  }
+  const runner = new InterlockingRunner(mapping.path);
+  return runner.execute(action, inputs, state);
+}

package/detectors/bun_interlocking_infrastructure/fixtures/dirty/interlocking_runner_exists/src/match/wagon.ts

@@ -0,0 +1,6 @@
+// match wagon — CLEAN fixture. A wagon transforms artifacts. It reads and returns a data map and
+// does NOT import interlocking code (Cargo boundary, core afokapu/atdd#1251).
+export function runMatch(cargo: Map<string, unknown>): Map<string, unknown> {
+  cargo.set("match", { result: { validForRanked: true } });
+  return cargo;
+}

package/detectors/bun_interlocking_infrastructure/fixtures/dirty/interlocking_runner_exists/src/trains/interlocking.ts

@@ -0,0 +1,16 @@
+// DIRTY fixture — coder.bun.interlocking-runner-exists.
+// The InterlockingRunner class exists but ships NO resolveTrain(...) entry point, so a consumer
+// declaring interlocking routes has no route-control entry. Expected: >=1 violation (missing-resolve-train).
+import { TrainRunner } from "./runner";
+
+export class InterlockingRunner {
+  private readonly path: string;
+  constructor(interlockingYamlPath: string) {
+    this.path = interlockingYamlPath;
+  }
+
+  // BUG: no resolveTrain(...) — there is no route-control entry point at all.
+  execute(action: string, inputs: Record<string, unknown>) {
+    return new TrainRunner("plan/_trains/train:match:solo-match-complete.yaml").execute("train:match:solo-match-complete", inputs);
+  }
+}

package/detectors/bun_interlocking_infrastructure/fixtures/dirty/interlocking_runner_exists/src/trains/runner.ts

@@ -0,0 +1,28 @@
+// TrainRunner — CLEAN fixture. The production linear train executor: the ONLY component that runs
+// wagons and carries Cargo between them. Legitimate execution; not scanned by the interlocking
+// detector (only InterlockingRunner-defining modules are scanned for direct wagon execution).
+import { runMatch } from "../match/wagon";
+
+export class Cargo extends Map<string, unknown> {}
+
+export class TrainRunner {
+  constructor(private readonly trainPath: string) {}
+
+  execute(trainId: string, inputs: Record<string, unknown>) {
+    let cargo: Cargo = new Cargo(Object.entries(inputs));
+    const train = loadTrain(this.trainPath);
+    for (const step of train.sequence) {
+      cargo = runTrain(step, cargo);
+    }
+    return { selectedTrainId: trainId, artifacts: Object.fromEntries(cargo) };
+  }
+}
+
+function runTrain(step: string, cargo: Cargo): Cargo {
+  if (step === "match") return runMatch(cargo) as Cargo;
+  return cargo;
+}
+
+function loadTrain(_path: string) {
+  return { sequence: ["match"] };
+}

package/detectors/bun_interlocking_infrastructure/fixtures/dirty/interlocking_station_routing/server.ts

@@ -0,0 +1,19 @@
+// DIRTY fixture — coder.bun.station-master-interlocking-routing.
+// JOURNEY_MAP declares an interlocking route object but the Station Master never references
+// TrainRunner, so the selected train is never delegated for execution.
+// Expected: >=1 violation (station-master-no-trainrunner-delegation).
+import { InterlockingRunner } from "./src/trains/interlocking";
+
+export const JOURNEY_MAP: Record<string, string | { interlockingId: string; path: string }> = {
+  resolve_match: {
+    interlockingId: "interlocking:match-resolution",
+    path: "plan/_trains/_interlockings/match-resolution.yaml",
+  },
+};
+
+export function dispatch(action: string, inputs: Record<string, unknown>, state?: unknown) {
+  const mapping = JOURNEY_MAP[action] as { interlockingId: string; path: string };
+  // BUG: builds the runner but never delegates through TrainRunner.
+  const runner = new InterlockingRunner(mapping.path);
+  return runner;
+}

package/detectors/bun_interlocking_infrastructure/fixtures/dirty/interlocking_station_routing/src/match/wagon.ts

@@ -0,0 +1,6 @@
+// match wagon — CLEAN fixture. A wagon transforms artifacts. It reads and returns a data map and
+// does NOT import interlocking code (Cargo boundary, core afokapu/atdd#1251).
+export function runMatch(cargo: Map<string, unknown>): Map<string, unknown> {
+  cargo.set("match", { result: { validForRanked: true } });
+  return cargo;
+}

package/detectors/bun_interlocking_infrastructure/fixtures/dirty/interlocking_station_routing/src/trains/interlocking.ts

@@ -0,0 +1,41 @@
+// InterlockingRunner route-control layer — CLEAN fixture (Bun/TS).
+// Resolves exactly one admissible train into a structured InterlockingResolution and delegates
+// linear execution to TrainRunner. It never imports a wagon, calls runTrain, loops over
+// train.sequence, or touches Cargo (core afokapu/atdd#1251).
+import { TrainRunner } from "./runner";
+
+export interface InterlockingResolution {
+  interlockingId: string;
+  routeId: string;
+  trainId: string;
+  trainPath: string;
+  category: string;
+  resolutionStrategy: string;
+  guardId: string;
+  reason: string;
+}
+
+export class InterlockingRunner {
+  private readonly path: string;
+  constructor(interlockingYamlPath: string) {
+    this.path = interlockingYamlPath;
+  }
+
+  resolveTrain(action: string, inputs: Record<string, unknown>, state?: unknown): InterlockingResolution {
+    return {
+      interlockingId: "interlocking:match-resolution",
+      routeId: "nominal-all-voted",
+      trainId: "train:match:solo-match-complete",
+      trainPath: "plan/_trains/train:match:solo-match-complete.yaml",
+      category: "nominal",
+      resolutionStrategy: "first_priority",
+      guardId: "all-voted",
+      reason: "all participants voted",
+    };
+  }
+
+  execute(action: string, inputs: Record<string, unknown>, state?: unknown) {
+    const resolution = this.resolveTrain(action, inputs, state);
+    return new TrainRunner(resolution.trainPath).execute(resolution.trainId, inputs);
+  }
+}

package/detectors/bun_interlocking_infrastructure/fixtures/dirty/interlocking_station_routing/src/trains/runner.ts

@@ -0,0 +1,28 @@
+// TrainRunner — CLEAN fixture. The production linear train executor: the ONLY component that runs
+// wagons and carries Cargo between them. Legitimate execution; not scanned by the interlocking
+// detector (only InterlockingRunner-defining modules are scanned for direct wagon execution).
+import { runMatch } from "../match/wagon";
+
+export class Cargo extends Map<string, unknown> {}
+
+export class TrainRunner {
+  constructor(private readonly trainPath: string) {}
+
+  execute(trainId: string, inputs: Record<string, unknown>) {
+    let cargo: Cargo = new Cargo(Object.entries(inputs));
+    const train = loadTrain(this.trainPath);
+    for (const step of train.sequence) {
+      cargo = runTrain(step, cargo);
+    }
+    return { selectedTrainId: trainId, artifacts: Object.fromEntries(cargo) };
+  }
+}
+
+function runTrain(step: string, cargo: Cargo): Cargo {
+  if (step === "match") return runMatch(cargo) as Cargo;
+  return cargo;
+}
+
+function loadTrain(_path: string) {
+  return { sequence: ["match"] };
+}

package/detectors/bun_interlocking_infrastructure/fixtures/dirty/journey_runner_boundary/plan/_journeys/example.yaml

@@ -0,0 +1,16 @@
+schema_version: 1.0.0
+journey_id: journey:example
+title: Example journey
+status: checked
+entrypoint:
+  interlocking_id: interlocking:first
+  exposed: false
+  actions: []
+  reason: internal-transition-only
+  surfaces: [backend]
+continuations: []
+terminals:
+  - from:
+      interlocking_id: interlocking:first
+      route_id: done
+    outcome: completed

package/detectors/bun_interlocking_infrastructure/fixtures/dirty/journey_runner_boundary/src/trains/journey.ts

@@ -0,0 +1,14 @@
+import { TrainRunner } from "./runner";
+import { runOrder } from "../orders/wagon";
+
+class Cargo extends Map<string, unknown> {}
+
+export class JourneyRunner {
+  execute(train: { sequence: string[] }, inputs: Record<string, unknown>) {
+    const cargo = new Cargo(Object.entries(inputs));
+    for (const step of train.sequence) {
+      runOrder(cargo);
+    }
+    return new TrainRunner("plan/_trains/direct.yaml").execute("train:direct:run", inputs);
+  }
+}

package/detectors/bun_interlocking_infrastructure/fixtures/dirty/journey_station_routing/plan/_journeys/public.yaml

@@ -0,0 +1,16 @@
+schema_version: 1.0.0
+journey_id: journey:public
+title: Public journey
+status: checked
+entrypoint:
+  interlocking_id: interlocking:first
+  exposed: true
+  actions: [start_journey]
+  reason: null
+  surfaces: [backend]
+continuations: []
+terminals:
+  - from:
+      interlocking_id: interlocking:first
+      route_id: done
+    outcome: completed

package/detectors/bun_interlocking_infrastructure/fixtures/dirty/journey_station_routing/server.ts

@@ -0,0 +1,10 @@
+export const JOURNEY_MAP = {
+  start_journey: {
+    journeyId: "journey:other",
+    path: "plan/_journeys/other.yaml",
+  },
+};
+
+export function dispatch(action: string) {
+  return JOURNEY_MAP[action as keyof typeof JOURNEY_MAP];
+}

package/detectors/bun_interlocking_infrastructure/fixtures/dirty/journey_station_routing/src/trains/journey.ts

@@ -0,0 +1,14 @@
+import { InterlockingRunner } from "@app/interlocking-runtime";
+
+export class JourneyRunner {
+  constructor(private readonly journeyYamlPath: string) {}
+
+  async execute(action: string, inputs: Record<string, unknown>, state?: unknown) {
+    const declaration = Bun.YAML.parse(await Bun.file(this.journeyYamlPath).text()) as {
+      entrypoint: { interlocking_id: string };
+    };
+    const id = declaration.entrypoint.interlocking_id.replace("interlocking:", "");
+    const path = `plan/_trains/_interlockings/${id}.yaml`;
+    return new InterlockingRunner(path).execute(action, inputs, state);
+  }
+}

package/detectors/bun_interlocking_infrastructure/fixtures/dirty/wagon_contract_honoured/plan/orders/_orders.yaml

@@ -0,0 +1,17 @@
+wagon: confirm-order
+urn: wagon:orders
+description: Take a customer order from basket to confirmed checkout
+subject: customer:active
+context: in-checkout, basket-priced
+action: confirms the priced basket
+goal: advance the order to a confirmed state
+outcome: order confirmed and its row fragment rendered
+produce:
+  - name: orders:confirmed-order
+    contract: contract:orders:confirmed-order-v1
+    telemetry: telemetry:orders:order-confirmed
+consume:
+  - name: orders:priced-basket
+    from: wagon:pricing
+wmbt:
+  - wmbt:orders:E001

package/detectors/bun_interlocking_infrastructure/fixtures/dirty/wagon_contract_honoured/src/orders/wagon.ts

@@ -0,0 +1,13 @@
+// BUG: the plan declares produce "orders:confirmed-order" and consume
+// "orders:priced-basket"; this wagon moves Cargo under ad-hoc keys instead, so the
+// declared contract describes artifacts the code never touches.
+export class Cargo {
+  private a: Record<string, unknown> = {};
+  put(artifactUrn: string, v: unknown) { this.a[artifactUrn] = v; }
+  get(artifactUrn: string) { return this.a[artifactUrn]; }
+}
+
+export function runWagon(cargo: Cargo): void {
+  const basket = cargo.get("basket");
+  cargo.put("done", { confirmed: true, basket });
+}

package/detectors/bun_security_hygiene_detector/atdd.implementation.yaml

@@ -0,0 +1,33 @@
+schema_version: 1.1.0
+kind: implementation
+subtype: validator
+implementation_id: bun_security_hygiene_detector
+targets_workspace: atdd.workspace.bun
+contract_version: 1.1.0
+# Security, logging and error-response obligations for the Bun + htmx stack.
+#
+# Only TWO of these seven are ports: `hardcoded-secret` (the secret regexes are
+# language-neutral) and `error-response-code-format` (the payload shape is JSON).
+# The other five are RE-REALIZATIONS — the python-pytest siblings walk a Python AST
+# for FastAPI decorators, `Depends()`, `print()`, `logger.info(extra=)` and
+# `HTTPException(detail=)`, none of which exist in this stack. Same obligations,
+# different detectors, which is why a stack extension is a package rather than a
+# translation of another package.
+emits_rule_ids:
+- coder.bun.error-response-bare-string
+- coder.bun.error-response-code-format
+- coder.bun.logging-console
+- coder.bun.logging-structured
+- coder.bun.security-hardcoded-secret
+- coder.bun.security-missing-auth
+- coder.bun.security-sql-injection
+entrypoint: detect.mjs
+report: detect.mjs
+realizes_convention:
+- coder.bun.error-response-bare-string
+- coder.bun.error-response-code-format
+- coder.bun.logging-console
+- coder.bun.logging-structured
+- coder.bun.security-hardcoded-secret
+- coder.bun.security-missing-auth
+- coder.bun.security-sql-injection

package/detectors/bun_security_hygiene_detector/checks/_map.json

@@ -0,0 +1,9 @@
+{
+  "sec_hardcoded_secret": "coder.bun.security-hardcoded-secret",
+  "sec_sql_injection": "coder.bun.security-sql-injection",
+  "sec_missing_auth": "coder.bun.security-missing-auth",
+  "log_console": "coder.bun.logging-console",
+  "log_structured": "coder.bun.logging-structured",
+  "err_bare_string": "coder.bun.error-response-bare-string",
+  "err_code_format": "coder.bun.error-response-code-format"
+}

package/detectors/bun_security_hygiene_detector/checks/err_bare_string.mjs

@@ -0,0 +1,38 @@
+#!/usr/bin/env bun
+// Member check: coder.bun.error-response-bare-string  (security/hygiene family)
+//
+// RE-REALIZED. The python-pytest sibling matches FastAPI's
+// `HTTPException(detail="...")`. Bun has no exception-to-response machinery: an
+// error IS a `Response` with a 4xx/5xx status, so the equivalent fault is
+// `new Response("something went wrong", { status: 400 })` — a bare human string
+// where a structured, coded payload belongs.
+//
+// This matters more in an htmx app than in a JSON API, and that is worth being
+// explicit about: htmx swaps the response body into the DOM, so a bare error
+// string is not merely unstructured — it is rendered to the user verbatim,
+// including whatever internal detail it happens to carry.
+import { walk, readRoots, readExcludes, readText, emit, locate, SOURCE_EXT } from "../../../lib/scan.mjs";
+
+const RULE = "coder.bun.error-response-bare-string";
+
+// `new Response(<string literal>, { ... status: 4xx|5xx ... })` — the status may
+// precede or follow other options, so the options object is matched loosely.
+const BARE_ERROR_RESPONSE_RE =
+  /new\s+Response\s*\(\s*(['"`])((?:[^'"`\\]|\\.)*)\1\s*,\s*\{[^}]*\bstatus\s*:\s*([45]\d{2})/g;
+
+const violations = [];
+const excludes = readExcludes();
+for (const root of readRoots()) {
+  for (const file of walk(root, excludes, SOURCE_EXT)) {
+    const text = readText(file);
+    if (!text) continue;
+    for (const m of text.matchAll(BARE_ERROR_RESPONSE_RE)) {
+      violations.push({
+        rule_id: RULE, file, ...locate(text, m.index),
+        evidence: `HTTP ${m[3]} returns the bare string "${m[2].slice(0, 40)}"; return a structured payload carrying an error_code`,
+      });
+    }
+  }
+}
+process.stderr.write(`bun-security[error-bare-string]: ${violations.length} violation(s)\n`);
+emit(violations);