@afokapu/atdd-bun 0.1.0

package/detectors/bun_tester_discipline_detector/checks/t_red_behavioral.mjs

@@ -0,0 +1,35 @@
+#!/usr/bin/env bun
+// Member check: tester.bun.red-behavioral-assertion  (tester discipline family)
+//
+// CONTRACT (v1.1): reads ATDD_SCAN_ROOTS / ATDD_SCAN_EXCLUDES, writes RAW
+// {rule_id,file,line,col,evidence,source_line} violations to ATDD_VIOLATIONS_REPORT,
+// exits 0 regardless of violation count. Scans TEST FILES ONLY. Shared parsing
+// lives in ../test_header.mjs.
+import { runCheck, testCases, caseBody } from "../test_header.mjs";
+
+const VACUOUS = /\bexpect\s*\([^)]*\)\s*\.\s*(?:not\s*\.\s*)?(toBeDefined|toBeTruthy|toBeFalsy|toBeNull|toBeUndefined)\s*\(/g;
+const ANY_EXPECT = /\bexpect\s*\(/;
+
+runCheck("tester.bun.red-behavioral-assertion", (H, file, text) => {
+  if (!H.phase || H.phase.value !== "RED") return null;
+  const out = [];
+  for (const c of testCases(text)) {
+    const body = caseBody(text, c.line);
+    if (!ANY_EXPECT.test(body)) {
+      out.push({ line: c.line,
+        evidence: "RED test case asserts nothing; it cannot fail first on behaviour that does not exist",
+        source_line: c.text });
+      continue;
+    }
+    // Every assertion is an existence check -> the test passes as soon as the
+    // symbol exists, which is precisely what RED must NOT do.
+    const vacuous = (body.match(VACUOUS) || []).length;
+    const total = (body.match(/\bexpect\s*\(/g) || []).length;
+    if (vacuous > 0 && vacuous === total) {
+      out.push({ line: c.line,
+        evidence: "RED test asserts only existence (toBeDefined/toBeTruthy/…); assert the BEHAVIOUR that must fail first",
+        source_line: c.text });
+    }
+  }
+  return out;
+});

package/detectors/bun_tester_discipline_detector/checks/t_red_fails_first.mjs

@@ -0,0 +1,30 @@
+#!/usr/bin/env bun
+// Member check: tester.bun.red-fails-first  (tester discipline family)
+//
+// CONTRACT (v1.1): reads ATDD_SCAN_ROOTS / ATDD_SCAN_EXCLUDES, writes RAW
+// {rule_id,file,line,col,evidence,source_line} violations to ATDD_VIOLATIONS_REPORT,
+// exits 0 regardless of count. Scans TEST FILES ONLY.
+import { runCheck, testCases, caseBody } from "../test_header.mjs";
+
+// CORE red.convention.yaml -> red_patterns.typescript, transcribed. Whether a RED
+// test ACTUALLY fails first is a RUNTIME property that no static detector can see;
+// core supplies a decidable STRUCTURAL proxy — a guaranteed-fail marker must be
+// present — and that proxy is what a per-stack detector checks. `test.failing(` is
+// bun:test's spelling of vitest's `it.fails(` and is accepted for the same reason.
+const RED_MARKERS = [
+  /throw\s+new\s+Error\s*\(\s*['"`][^'"`]*[Nn]ot\s+implemented/,
+  /throw\s+new\s+UnimplementedError\s*\(/,
+  /expect\s*\(\s*false\s*\)\s*\.\s*toBe\s*\(\s*true\s*\)/,
+  /expect\s*\(\s*true\s*\)\s*\.\s*toBe\s*\(\s*false\s*\)/,
+  /expect\s*\.\s*fail\s*\(/,
+  /return\s+Promise\s*\.\s*reject\s*\(/,
+  /\b(?:it|test)\s*\.\s*(?:fails|failing)\s*\(/,
+];
+
+runCheck("tester.bun.red-fails-first", (H, file, text) => {
+  if (!H.phase || H.phase.value !== "RED") return null;
+  if (RED_MARKERS.some((re) => re.test(text))) return null;
+  return { line: H.phase.no,
+    evidence: "RED test carries no guaranteed-fail marker, so nothing stops it passing before the implementation exists",
+    source_line: H.phase.raw };
+});

package/detectors/bun_tester_discipline_detector/checks/t_routing_runtime.mjs

@@ -0,0 +1,22 @@
+#!/usr/bin/env bun
+// Member check: tester.bun.routing-runtime-family  (tester discipline family)
+//
+// CONTRACT (v1.1): reads ATDD_SCAN_ROOTS / ATDD_SCAN_EXCLUDES, writes RAW
+// {rule_id,file,line,col,evidence,source_line} violations to ATDD_VIOLATIONS_REPORT,
+// exits 0 regardless of count. Scans TEST FILES ONLY.
+import { runCheck, testCases, caseBody } from "../test_header.mjs";
+
+// A test file in this stack is collected and executed by `bun test` — a JS/TS
+// runtime. So when it DECLARES a `// Runtime:`, that runtime must be in the JS/TS
+// family. A test claiming `python` is either mislabelled or filed in the wrong
+// suite; either way the gate attributes it to a runner that never ran it.
+const JS_FAMILY = new Set(["bun", "browser", "isomorphic", "typescript", "ts",
+  "node", "js", "javascript", "deno", "vite", "astro", "preact"]);
+
+runCheck("tester.bun.routing-runtime-family", (H) => {
+  if (!H.runtime) return null;   // declaring a runtime is optional for a test
+  if (JS_FAMILY.has(H.runtime.value.toLowerCase())) return null;
+  return { line: H.runtime.no,
+    evidence: `test declares Runtime "${H.runtime.value}", which is not in the JS/TS family this suite executes under`,
+    source_line: H.runtime.raw };
+});

package/detectors/bun_tester_discipline_detector/checks/t_security_auth.mjs

@@ -0,0 +1,26 @@
+#!/usr/bin/env bun
+// Member check: tester.bun.security-auth  (tester discipline family)
+//
+// CONTRACT (v1.1): reads ATDD_SCAN_ROOTS / ATDD_SCAN_EXCLUDES, writes RAW
+// {rule_id,file,line,col,evidence,source_line} violations to ATDD_VIOLATIONS_REPORT,
+// exits 0 regardless of count. Scans TEST FILES ONLY.
+import { runCheck, testCases, caseBody } from "../test_header.mjs";
+
+// A test that CLAIMS to cover security must actually assert on security. The test
+// is identified by its URN kind segment (SEC / RLS / AUTH); the assertion must tie
+// an expectation to an identity, permission or 401/403 signal.
+//
+// A "security" test that only walks the happy path is a SILENT GREEN GAP: it passes
+// CI, it is counted as covering the security acceptance, and it proves nothing about
+// the denial path — which is the only path that matters.
+const IS_SECURITY = /-(?:SEC|RLS|AUTH)-\d+/i;
+const AUTH_ASSERTION =
+  /expect[\s\S]{0,200}?(?:401|403|[Uu]nauthori[sz]ed|[Ff]orbidden|[Dd]enied|[Pp]ermission|\.rejects\b|toThrow)/;
+
+runCheck("tester.bun.security-auth", (H, file, text) => {
+  if (!H.urn || !IS_SECURITY.test(H.urn.value)) return null;
+  if (AUTH_ASSERTION.test(text)) return null;
+  return { line: H.urn.no,
+    evidence: "security test asserts no denial (401/403/unauthorized/forbidden/rejects/toThrow); a happy-path-only security test is a silent green gap",
+    source_line: H.urn.raw };
+});

package/detectors/bun_tester_discipline_detector/checks/t_security_input.mjs

@@ -0,0 +1,25 @@
+#!/usr/bin/env bun
+// Member check: tester.bun.security-input  (tester discipline family)
+//
+// CONTRACT (v1.1): reads ATDD_SCAN_ROOTS / ATDD_SCAN_EXCLUDES, writes RAW
+// {rule_id,file,line,col,evidence,source_line} violations to ATDD_VIOLATIONS_REPORT,
+// exits 0 regardless of count. Scans TEST FILES ONLY.
+import { runCheck, testCases, caseBody } from "../test_header.mjs";
+
+// An input-validation test must assert REJECTION. Identified by its URN kind
+// segment (INPUT / VALIDATION / VALIDATE).
+//
+// A test that submits a well-formed payload and checks it succeeds proves nothing
+// about how the endpoint handles malformed or adversarial input — which is the
+// entire obligation the acceptance claims to discharge.
+const IS_INPUT = /-(?:INPUT|VALIDATION|VALIDATE)-\d+/i;
+const REJECTION_ASSERTION =
+  /expect[\s\S]{0,200}?(?:\.rejects\b|toThrow|400|422|[Ii]nvalid|[Rr]eject|[Vv]alidationError|[Ee]rror)/;
+
+runCheck("tester.bun.security-input", (H, file, text) => {
+  if (!H.urn || !IS_INPUT.test(H.urn.value)) return null;
+  if (REJECTION_ASSERTION.test(text)) return null;
+  return { line: H.urn.no,
+    evidence: "input-validation test asserts no rejection (rejects/toThrow/400/422/invalid); it proves only the happy path",
+    source_line: H.urn.raw };
+});

package/detectors/bun_tester_discipline_detector/checks/t_smoke_no_substitution.mjs

@@ -0,0 +1,25 @@
+#!/usr/bin/env bun
+// Member check: tester.bun.smoke-no-collaborator-substitution  (tester discipline family)
+//
+// CONTRACT (v1.1): reads ATDD_SCAN_ROOTS / ATDD_SCAN_EXCLUDES, writes RAW
+// {rule_id,file,line,col,evidence,source_line} violations to ATDD_VIOLATIONS_REPORT,
+// exits 0 regardless of violation count. Scans TEST FILES ONLY. Shared parsing
+// lives in ../test_header.mjs.
+import { runCheck, testCases, caseBody } from "../test_header.mjs";
+
+const SUBSTITUTION = /\b(?:mock\s*\.\s*module|spyOn|jest\s*\.\s*(?:mock|spyOn)|vi\s*\.\s*(?:mock|spyOn)|mock\s*\.\s*restore)\s*\(/g;
+
+runCheck("tester.bun.smoke-no-collaborator-substitution", (H, file, text) => {
+  if (!H.phase || H.phase.value !== "SMOKE") return null;
+  const out = [];
+  const lines = text.split(/\r?\n/);
+  lines.forEach((line, i) => {
+    SUBSTITUTION.lastIndex = 0;
+    const m = SUBSTITUTION.exec(line);
+    if (!m) return;
+    out.push({ line: i + 1,
+      evidence: `SMOKE test substitutes a production collaborator (${m[0].replace(/\s*\($/, "").trim()}); that makes it a unit test passing under a SMOKE label`,
+      source_line: line.trim() });
+  });
+  return out;
+});

package/detectors/bun_tester_discipline_detector/checks/t_smoke_observable.mjs

@@ -0,0 +1,28 @@
+#!/usr/bin/env bun
+// Member check: tester.bun.smoke-observable-assertion  (tester discipline family)
+//
+// CONTRACT (v1.1): reads ATDD_SCAN_ROOTS / ATDD_SCAN_EXCLUDES, writes RAW
+// {rule_id,file,line,col,evidence,source_line} violations to ATDD_VIOLATIONS_REPORT,
+// exits 0 regardless of violation count. Scans TEST FILES ONLY. Shared parsing
+// lives in ../test_header.mjs.
+import { runCheck, testCases, caseBody } from "../test_header.mjs";
+
+// Operator-observable channels for a full-stack Bun + htmx app: the HTTP response,
+// the rendered markup, the process surface, or persisted state. NOT an intermediate
+// object the test constructed itself.
+const OBSERVABLE = /\b(?:res|response|resp)\s*\.\s*(?:status|statusText|headers|text|json|ok)\b|\.\s*text\s*\(\s*\)|\.\s*json\s*\(\s*\)|\bstdout\b|\bstderr\b|\bexitCode\b|\bdocument\b|innerHTML|outerHTML/;
+const ANY_EXPECT = /\bexpect\s*\(/;
+
+runCheck("tester.bun.smoke-observable-assertion", (H, file, text) => {
+  if (!H.phase || H.phase.value !== "SMOKE") return null;
+  const out = [];
+  for (const c of testCases(text)) {
+    const body = caseBody(text, c.line);
+    if (!ANY_EXPECT.test(body)) continue;   // owned by the RED/coverage rules
+    if (OBSERVABLE.test(body)) continue;
+    out.push({ line: c.line,
+      evidence: "SMOKE case asserts on no operator-observable channel (response status/body, rendered markup, stdout, exit code)",
+      source_line: c.text });
+  }
+  return out;
+});

package/detectors/bun_tester_discipline_detector/checks/t_telemetry_emit.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env bun
+// Member check: tester.bun.telemetry-emit  (tester discipline family)
+//
+// CONTRACT (v1.1): reads ATDD_SCAN_ROOTS / ATDD_SCAN_EXCLUDES, writes RAW
+// {rule_id,file,line,col,evidence,source_line} violations to ATDD_VIOLATIONS_REPORT,
+// exits 0 regardless of count. Scans TEST FILES ONLY.
+import { runCheck, testCases, caseBody } from "../test_header.mjs";
+
+// A telemetry test must assert EMISSION. Identified by its URN kind segment
+// (TELEMETRY / EVENT / METRIC) or by `*.telemetry.test.ts` colocation.
+//
+// A telemetry test that checks a return value proves the function worked, not that
+// the event was emitted — and the event is the whole point, because it is what the
+// dashboards and alerts downstream are built on.
+const IS_TELEMETRY = /-(?:TELEMETRY|EVENT|METRIC)-\d+/i;
+const EMISSION_ASSERTION =
+  /toHaveBeenCalled(?:With|Times)?\s*\(|expect[\s\S]{0,160}?\.\s*(?:emit|emitted|capture|track|record)\b/;
+
+runCheck("tester.bun.telemetry-emit", (H, file, text) => {
+  const byUrn = H.urn && IS_TELEMETRY.test(H.urn.value);
+  const byName = /\.telemetry\.(?:test|spec)\.[cm]?[jt]sx?$/.test(file);
+  if (!byUrn && !byName) return null;
+  if (EMISSION_ASSERTION.test(text)) return null;
+  return { line: H.urn ? H.urn.no : 1,
+    evidence: "telemetry test asserts no emission (toHaveBeenCalled / expect on .emit/.capture/.track); a return-value check proves the function ran, not that the event fired",
+    source_line: H.urn ? H.urn.raw : "" };
+});

package/detectors/bun_tester_discipline_detector/checks/t_test_imports_bun_test.mjs

@@ -0,0 +1,31 @@
+#!/usr/bin/env bun
+// Member check: tester.bun.test-imports-bun-test  (tester discipline family)
+//
+// MOVED from bun_fullstack_detector, where it was a `coder.bun.*` rule. It reads
+// TEST files, and `conformance/test_persona_scoping.py` proved that broke the
+// boundary this provider claims: coder families never open a test file. The rule's
+// own argument is about the coverage gate — a test bound to a harness the declared
+// runner never executes is coverage the gate believes in and that never ran — and
+// that is a tester obligation, not a source one.
+import { runCheck } from "../test_header.mjs";
+
+const RULE = "tester.bun.test-imports-bun-test";
+const FOREIGN_HARNESS_RE =
+  /\b(?:import|from|require\s*\()\s*['"](vitest|@jest\/globals|jest|mocha|chai)['"]/g;
+
+runCheck(RULE, (H, file, text) => {
+  // Mask line comments only: the harness name lives INSIDE the import's own string
+  // literal, so masking literals would blank the very thing being matched.
+  const masked = text.replace(/\/\/[^\n]*/g, (s) => " ".repeat(s.length));
+  const out = [];
+  for (const m of masked.matchAll(FOREIGN_HARNESS_RE)) {
+    const before = text.slice(0, m.index);
+    out.push({
+      line: before.split("\n").length,
+      col: m.index - (before.lastIndexOf("\n") + 1) + 1,
+      evidence: `test imports '${m[1]}' instead of 'bun:test'; the declared runner is bun, so this test is not run by the harness the gate reports`,
+      source_line: (text.split(/\r?\n/)[before.split("\n").length - 1] || "").trim(),
+    });
+  }
+  return out;
+});

package/detectors/bun_tester_discipline_detector/checks/t_test_no_self_skip.mjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env bun
+// Member check: tester.bun.test-no-self-skip  (tester discipline family)
+//
+// CONTRACT (v1.1): reads ATDD_SCAN_ROOTS / ATDD_SCAN_EXCLUDES, writes RAW
+// {rule_id,file,line,col,evidence,source_line} violations to ATDD_VIOLATIONS_REPORT,
+// exits 0 regardless of violation count. Scans TEST FILES ONLY. Shared parsing
+// lives in ../test_header.mjs.
+import { runCheck, testCases, caseBody } from "../test_header.mjs";
+
+// `.fails` / `.failing` are deliberately ABSENT here: core's RED marker vocabulary
+// lists `it.fails(` / `test.fails(` as an accepted guaranteed-fail marker, so flagging
+// them would refuse the very construct `red-fails-first` REQUIRES. Only genuine
+// disabling modifiers are self-skips.
+const SELF_SKIP = /\b(?:it|test|describe)\s*\.\s*(skip|todo)\s*\(/g;
+// A guarded bail-out: `if (!process.env.X) return;` at the top of a case is a skip
+// wearing a disguise — the suite reports green having exercised nothing.
+const GUARDED_BAIL = /if\s*\([^)]*process\.env[^)]*\)\s*\{?\s*return\b/g;
+
+runCheck("tester.bun.test-no-self-skip", (H, file, text) => {
+  const out = [];
+  text.split(/\r?\n/).forEach((line, i) => {
+    for (const re of [SELF_SKIP, GUARDED_BAIL]) {
+      re.lastIndex = 0;
+      const m = re.exec(line);
+      if (!m) continue;
+      out.push({ line: i + 1,
+        evidence: m[1]
+          ? `test disables itself with .${m[1]}(); a skipped acceptance is an unproven one that reports green`
+          : "test bails out on an environment check; the suite passes having exercised nothing",
+        source_line: line.trim() });
+    }
+  });
+  return out;
+});

package/detectors/bun_tester_discipline_detector/checks/t_test_phase_declared.mjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env bun
+// Member check: tester.bun.test-phase-declared  (tester discipline family)
+//
+// CONTRACT (v1.1): reads ATDD_SCAN_ROOTS / ATDD_SCAN_EXCLUDES, writes RAW
+// {rule_id,file,line,col,evidence,source_line} violations to ATDD_VIOLATIONS_REPORT,
+// exits 0 regardless of violation count. Scans TEST FILES ONLY — source files are
+// the coder extension's business. Shared parsing lives in ../test_header.mjs.
+import { runCheck } from "../test_header.mjs";
+
+import { PHASES } from "../test_header.mjs";
+
+runCheck("tester.bun.test-phase-declared", (H) => {
+  if (!H.urn) return null;
+  if (!H.phase) return { line: H.urn.no,
+    evidence: "test declares no `// Phase:`; the gate cannot tell a RED test from a SMOKE one",
+    source_line: H.urn.raw };
+  if (PHASES.has(H.phase.value)) return null;
+  return { line: H.phase.no,
+    evidence: `Phase "${H.phase.value}" is not one of ${[...PHASES].join("|")}`,
+    source_line: H.phase.raw };
+});

package/detectors/bun_tester_discipline_detector/checks/t_urn_identity.mjs

@@ -0,0 +1,18 @@
+#!/usr/bin/env bun
+// Member check: tester.bun.test-carries-urn-identity  (tester discipline family)
+//
+// CONTRACT (v1.1): reads ATDD_SCAN_ROOTS / ATDD_SCAN_EXCLUDES, writes RAW
+// {rule_id,file,line,col,evidence,source_line} violations to ATDD_VIOLATIONS_REPORT,
+// exits 0 regardless of violation count. Scans TEST FILES ONLY — source files are
+// the coder extension's business. Shared parsing lives in ../test_header.mjs.
+import { runCheck } from "../test_header.mjs";
+
+runCheck("tester.bun.test-carries-urn-identity", (H) => {
+  if (!H.urn) return { line: H.firstMeaningfulNo || 1,
+    evidence: "test file carries no `// URN: test:…` header, so nothing can identify what it proves",
+    source_line: H.firstMeaningfulText };
+  if (!/^test:/.test(H.urn.value)) return { line: H.urn.no,
+    evidence: `test URN "${H.urn.value}" does not start with the test: scheme`,
+    source_line: H.urn.raw };
+  return null;
+});

package/detectors/bun_tester_discipline_detector/detect.mjs

@@ -0,0 +1,46 @@
+#!/usr/bin/env bun
+// FAMILY validator: bun_tester_discipline_detector
+// Runs each member check (checks/*.mjs) VERBATIM as a subprocess and merges their
+// RAW v1.1 reports into one — ONE implementation realizing a family of rule_ids
+// (the Core pattern; see frontend.workspace.runtime's families).
+//
+// Members are spawned with `process.execPath`, which under this provider IS the
+// bun binary, so a member may be authored as .mjs OR .ts with no build step.
+// Files whose name begins with `_` are skipped: they are shared helpers, not
+// checks. (The node-runtime families have no such convention because each of
+// their checks re-implements its own walker; this provider factors the walk into
+// lib/scan.mjs instead.)
+import { execFileSync } from "node:child_process";
+import { readFileSync, writeFileSync, mkdtempSync, readdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const reportPath = process.env.ATDD_VIOLATIONS_REPORT;
+if (!reportPath) {
+  process.stderr.write("family: ATDD_VIOLATIONS_REPORT not set\n");
+  process.exit(2);
+}
+const checks = readdirSync(join(here, "checks"))
+  .filter((f) => (f.endsWith(".mjs") || f.endsWith(".ts")) && !f.startsWith("_"))
+  .sort();
+const td = mkdtempSync(join(tmpdir(), "atdd-bun-fam-"));
+const out = [];
+for (const c of checks) {
+  const rep = join(td, c + ".json");
+  try {
+    execFileSync(process.execPath, [join(here, "checks", c)], {
+      env: { ...process.env, ATDD_VIOLATIONS_REPORT: rep },
+      stdio: ["ignore", "ignore", "inherit"],
+    });
+  } catch {
+    /* a member may exit non-zero; still try to read its report */
+  }
+  try {
+    out.push(...JSON.parse(readFileSync(rep, "utf8")).violations);
+  } catch {}
+}
+writeFileSync(reportPath, JSON.stringify({ violations: out }, null, 2), "utf8");
+process.stderr.write("family bun_tester_discipline_detector: " + out.length + " violation(s)\n");
+process.exit(0);

package/detectors/bun_tester_discipline_detector/fixtures/clean/audit.sec.test.ts

@@ -0,0 +1,15 @@
+// URN: test:orders:checkout:E020-AUTH-001-denies-anonymous
+// Acceptance: acc:orders:E020-AUTH-001-denies-anonymous
+// Phase: SMOKE
+// Layer: integration
+// Runtime: bun
+import { describe, it, expect } from "bun:test";
+
+describe("orders auth", () => {
+  // @covers acc:orders:E020-AUTH-001-denies-anonymous
+  it("refuses an anonymous write", async () => {
+    const res = await fetch("http://localhost:3000/orders", { method: "POST" });
+    expect(res.status).toBe(403);
+    expect(await res.text()).toContain("FORBIDDEN");
+  });
+});

package/detectors/bun_tester_discipline_detector/fixtures/clean/checkout.red.test.ts

@@ -0,0 +1,16 @@
+// URN: test:orders:checkout:E002-RED-001-rejects-empty-cart
+// Acceptance: acc:orders:E002-RED-001-rejects-empty-cart
+// WMBT: wmbt:orders:E002
+// Phase: RED
+// Layer: domain
+import { describe, it, expect } from "bun:test";
+import { checkout } from "../src/checkout";
+
+describe("checkout", () => {
+  // @covers acc:orders:E002-RED-001-rejects-empty-cart
+  it("refuses an empty cart with a coded error", () => {
+    expect(() => checkout({ items: [] })).toThrow("CART_EMPTY");
+    // Guaranteed-fail RED marker: this test cannot pass before the behaviour exists.
+    expect.fail("checkout rejection not implemented yet");
+  });
+});

package/detectors/bun_tester_discipline_detector/fixtures/clean/emit.telemetry.test.ts

@@ -0,0 +1,15 @@
+// URN: test:orders:checkout:E022-TELEMETRY-001-emits-placed
+// Acceptance: acc:orders:E022-TELEMETRY-001-emits-placed
+// Phase: UNIT
+// Layer: application
+import { describe, it, expect, mock } from "bun:test";
+import { placeOrder } from "../src/place";
+
+describe("order telemetry", () => {
+  // @covers acc:orders:E022-TELEMETRY-001-emits-placed
+  it("emits order_placed", () => {
+    const emit = mock(() => {});
+    placeOrder({ sku: "x" }, { emit });
+    expect(emit).toHaveBeenCalledWith("order_placed", { sku: "x" });
+  });
+});

package/detectors/bun_tester_discipline_detector/fixtures/clean/marked.red.test.ts

@@ -0,0 +1,14 @@
+// URN: test:orders:checkout:E023-RED-001-refuses-zero-total
+// Acceptance: acc:orders:E023-RED-001-refuses-zero-total
+// Phase: RED
+// Layer: domain
+import { describe, it, expect } from "bun:test";
+import { total } from "../src/total";
+
+describe("total", () => {
+  // @covers acc:orders:E023-RED-001-refuses-zero-total
+  it("refuses a zero total", () => {
+    expect(() => total([])).toThrow("EMPTY_CART");
+    expect.fail("not implemented yet");
+  });
+});

package/detectors/bun_tester_discipline_detector/fixtures/clean/orders.smoke.test.ts

@@ -0,0 +1,16 @@
+// URN: test:orders:checkout:E001-SMOKE-001-renders-row
+// Acceptance: acc:orders:E001-SMOKE-001-renders-row
+// WMBT: wmbt:orders:E001
+// Phase: SMOKE
+// Layer: integration
+import { describe, it, expect } from "bun:test";
+
+describe("orders fragment", () => {
+  // @covers acc:orders:E001-SMOKE-001-renders-row
+  it("returns a swappable row carrying its id", async () => {
+    const res = await fetch("http://localhost:3000/orders/1");
+    expect(res.status).toBe(200);
+    const html = await res.text();
+    expect(html).toContain('id="order-1"');
+  });
+});

package/detectors/bun_tester_discipline_detector/fixtures/clean/payload.input.test.ts

@@ -0,0 +1,13 @@
+// URN: test:orders:checkout:E021-INPUT-001-rejects-malformed
+// Acceptance: acc:orders:E021-INPUT-001-rejects-malformed
+// Phase: UNIT
+// Layer: domain
+import { describe, it, expect } from "bun:test";
+import { parseOrder } from "../src/parse";
+
+describe("order payload", () => {
+  // @covers acc:orders:E021-INPUT-001-rejects-malformed
+  it("rejects a malformed payload", () => {
+    expect(() => parseOrder({ sku: null })).toThrow("INVALID_SKU");
+  });
+});

package/detectors/bun_tester_discipline_detector/fixtures/clean/plan/orders/E001.yaml

@@ -0,0 +1,9 @@
+urn: wmbt:orders:E001
+feature: feature:orders:checkout
+statement: minimize likelihood of an unattributed test for E001
+acceptances:
+  - identity:
+      urn: acc:orders:E001-SMOKE-001-renders-row
+      id: E001-SMOKE-001-renders-row
+      purpose: Declared so a test binding to it resolves
+      phase: SMOKE

package/detectors/bun_tester_discipline_detector/fixtures/clean/plan/orders/E002.yaml

@@ -0,0 +1,9 @@
+urn: wmbt:orders:E002
+feature: feature:orders:checkout
+statement: minimize likelihood of an unattributed test for E002
+acceptances:
+  - identity:
+      urn: acc:orders:E002-RED-001-rejects-empty-cart
+      id: E002-RED-001-rejects-empty-cart
+      purpose: Declared so a test binding to it resolves
+      phase: RED

package/detectors/bun_tester_discipline_detector/fixtures/clean/plan/orders/E020.yaml

@@ -0,0 +1,9 @@
+urn: wmbt:orders:E020
+feature: feature:orders:checkout
+statement: minimize likelihood of an unattributed test for E020
+acceptances:
+  - identity:
+      urn: acc:orders:E020-AUTH-001-denies-anonymous
+      id: E020-AUTH-001-denies-anonymous
+      purpose: Declared so a test binding to it resolves
+      phase: UNIT

package/detectors/bun_tester_discipline_detector/fixtures/clean/plan/orders/E021.yaml

@@ -0,0 +1,9 @@
+urn: wmbt:orders:E021
+feature: feature:orders:checkout
+statement: minimize likelihood of an unattributed test for E021
+acceptances:
+  - identity:
+      urn: acc:orders:E021-INPUT-001-rejects-malformed
+      id: E021-INPUT-001-rejects-malformed
+      purpose: Declared so a test binding to it resolves
+      phase: UNIT

package/detectors/bun_tester_discipline_detector/fixtures/clean/plan/orders/E022.yaml

@@ -0,0 +1,9 @@
+urn: wmbt:orders:E022
+feature: feature:orders:checkout
+statement: minimize likelihood of an unattributed test for E022
+acceptances:
+  - identity:
+      urn: acc:orders:E022-TELEMETRY-001-emits-placed
+      id: E022-TELEMETRY-001-emits-placed
+      purpose: Declared so a test binding to it resolves
+      phase: UNIT

package/detectors/bun_tester_discipline_detector/fixtures/clean/plan/orders/E023.yaml

@@ -0,0 +1,9 @@
+urn: wmbt:orders:E023
+feature: feature:orders:checkout
+statement: minimize likelihood of an unattributed test for E023
+acceptances:
+  - identity:
+      urn: acc:orders:E023-RED-001-refuses-zero-total
+      id: E023-RED-001-refuses-zero-total
+      purpose: Declared so a test binding to it resolves
+      phase: RED

package/detectors/bun_tester_discipline_detector/fixtures/dirty/badcovers.test.ts

@@ -0,0 +1,7 @@
+// URN: test:orders:checkout:E005-UNIT-001
+// Acceptance: acc:orders:E005-UNIT-001
+// Phase: UNIT
+// Layer: domain
+import { it, expect } from "bun:test";
+// @covers E005-UNIT-001
+it("adds", () => { expect(1 + 1).toBe(2); });

package/detectors/bun_tester_discipline_detector/fixtures/dirty/badphase.test.ts

@@ -0,0 +1,6 @@
+// URN: test:orders:checkout:E004-UNIT-001
+// Acceptance: acc:orders:E004-UNIT-001
+// Phase: INTEGRATION
+// Layer: domain
+import { it, expect } from "bun:test";
+it("adds", () => { expect(1 + 1).toBe(2); });

package/detectors/bun_tester_discipline_detector/fixtures/dirty/foreign_harness.test.ts

@@ -0,0 +1,6 @@
+// URN: test:orders:checkout:E030-UNIT-001
+// Acceptance: acc:orders:E030-UNIT-001
+// Phase: UNIT
+// Layer: domain
+import { describe, it, expect } from "vitest";
+describe("orders", () => { it("adds", () => { expect(1 + 1).toBe(2); }); });

package/detectors/bun_tester_discipline_detector/fixtures/dirty/happy.auth.test.ts

@@ -0,0 +1,9 @@
+// URN: test:orders:checkout:E026-AUTH-001
+// Acceptance: acc:orders:E026-AUTH-001
+// Phase: UNIT
+// Layer: integration
+import { it, expect } from "bun:test";
+it("lets a signed-in user through", async () => {
+  const order = await place({ user: "u1" });
+  expect(order.id).toBe("o1");
+});

package/detectors/bun_tester_discipline_detector/fixtures/dirty/happy.input.test.ts

@@ -0,0 +1,9 @@
+// URN: test:orders:checkout:E027-INPUT-001
+// Acceptance: acc:orders:E027-INPUT-001
+// Phase: UNIT
+// Layer: domain
+import { it, expect } from "bun:test";
+it("accepts a good payload", () => {
+  const parsed = parseOrder({ sku: "x" });
+  expect(parsed.sku).toBe("x");
+});

package/detectors/bun_tester_discipline_detector/fixtures/dirty/internal.smoke.test.ts

@@ -0,0 +1,10 @@
+// URN: test:orders:checkout:E007-SMOKE-001
+// Acceptance: acc:orders:E007-SMOKE-001
+// Phase: SMOKE
+// Layer: integration
+import { it, expect } from "bun:test";
+import { buildOrder } from "../src/build";
+it("builds an order", () => {
+  const order = buildOrder({ sku: "x" });
+  expect(order.sku).toBe("x");
+});

package/detectors/bun_tester_discipline_detector/fixtures/dirty/no_header.test.ts

@@ -0,0 +1,2 @@
+import { it, expect } from "bun:test";
+it("does a thing", () => { expect(1).toBe(1); });

package/detectors/bun_tester_discipline_detector/fixtures/dirty/plan/orders/E004.yaml

@@ -0,0 +1,9 @@
+urn: wmbt:orders:E004
+feature: feature:orders:checkout
+statement: minimize likelihood of an unattributed test for E004
+acceptances:
+  - identity:
+      urn: acc:orders:E004-UNIT-001
+      id: E004-UNIT-001
+      purpose: Declared so a test binding to it resolves
+      phase: UNIT

package/detectors/bun_tester_discipline_detector/fixtures/dirty/plan/orders/E005.yaml

@@ -0,0 +1,9 @@
+urn: wmbt:orders:E005
+feature: feature:orders:checkout
+statement: minimize likelihood of an unattributed test for E005
+acceptances:
+  - identity:
+      urn: acc:orders:E005-UNIT-001
+      id: E005-UNIT-001
+      purpose: Declared so a test binding to it resolves
+      phase: UNIT