@afokapu/atdd-bun 0.1.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,11 @@
+// URN: test:orders:checkout:E010-UNIT-001
+// Acceptance: acc:orders:E010-UNIT-001
+// Phase: UNIT
+// Layer: domain
+import { it, expect } from "bun:test";
+import { writeFileSync } from "node:fs";
+process.env.DATABASE_URL = "postgres://live";
+it("writes a report", () => {
+  writeFileSync("./reports/out.json", "{}");
+  expect(1).toBe(1);
+});

package/detectors/bun_tester_discipline_detector/fixtures/dirty/quiet.telemetry.test.ts

@@ -0,0 +1,9 @@
+// URN: test:orders:checkout:E028-TELEMETRY-001
+// Acceptance: acc:orders:E028-TELEMETRY-001
+// Phase: UNIT
+// Layer: application
+import { it, expect } from "bun:test";
+it("places the order", () => {
+  const out = placeOrder({ sku: "x" });
+  expect(out.ok).toBe(true);
+});

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

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

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

@@ -0,0 +1,13 @@
+// URN: test:orders:checkout:E008-SMOKE-001
+// Acceptance: acc:orders:E008-SMOKE-001
+// Phase: SMOKE
+// Layer: integration
+import { it, expect, mock, spyOn } from "bun:test";
+import * as repo from "../src/repo";
+it("saves the order", async () => {
+  spyOn(repo, "save");
+  const res = await fetch("http://localhost:3000/orders");
+  expect(res.status).toBe(200);
+  const html = await res.text();
+  expect(html).toContain("saved");
+});

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

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

package/detectors/bun_tester_discipline_detector/fixtures/dirty/unmarked.red.test.ts

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

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

@@ -0,0 +1,17 @@
+// URN: test:orders:checkout:E999-SMOKE-001-phantom
+// Acceptance: acc:orders:E999-NEVER-DECLARED
+// WMBT: wmbt:orders:E999
+// Phase: SMOKE
+// Layer: integration
+//
+// BUG: both bindings name artifacts the plan never declares. The sibling rule
+// tester.bun.acceptance-binding-declared is satisfied — the headers are PRESENT —
+// so before tester.bun.acceptance-resolves-to-declared nothing attributed this
+// suite to anything real.
+import { test, expect } from "bun:test";
+
+test("returns a swappable row carrying its id", async () => {
+  const response = new Response('<li id="order-1">confirmed</li>', { status: 200 });
+  expect(response.status).toBe(200);
+  expect(await response.text()).toContain('id="order-1"');
+});

package/detectors/bun_tester_discipline_detector/fixtures/dirty/vacuous.red.test.ts

@@ -0,0 +1,7 @@
+// URN: test:orders:checkout:E006-RED-001
+// Acceptance: acc:orders:E006-RED-001
+// Phase: RED
+// Layer: domain
+import { it, expect } from "bun:test";
+import { checkout } from "../src/checkout";
+it("has a checkout", () => { expect(checkout).toBeDefined(); });

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

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

package/detectors/bun_tester_discipline_detector/test_header.mjs

@@ -0,0 +1,160 @@
+// test_header.mjs — shared parser + walk + runCheck for the TESTER discipline
+// family. Lives at the implementation ROOT (imported by checks via
+// `../test_header.mjs`); the family runner only spawns `checks/*.mjs`.
+//
+// A TEST file's header is a different document from a SOURCE file's. Source
+// declares what it IS (URN / Tested-By / Runtime / Purpose — see urn_header.mjs);
+// a test declares what it PROVES:
+//
+//     // URN: test:{wagon}:{feature}:{ACCEPTANCE-ID}
+//     // Acceptance: acc:{wagon}:{ACCEPTANCE-ID}
+//     // WMBT: wmbt:{wagon}:{CODE}
+//     // Phase: RED | UNIT | SMOKE | E2E
+//     // Layer: domain | application | integration | presentation | assembly
+//
+// That is the shape core uses (1,057 `# Acceptance:` headers in the atdd repo
+// itself), transcribed to `//` for this stack. Core's own
+// `tester.filename.test-carries-urn-identity` is explicit that the HEADER, not the
+// filename, is authoritative — so this family never parses filenames for identity.
+//
+// PER-`it()` COVERAGE TAGS. The file header binds a file to its acceptances; a
+// `// @covers acc:…` comment above an individual `it()` binds at test-case
+// granularity. That two-level model is what issue #1783 argued for against a
+// per-file rename: one spec file is wagon-level and legitimately covers many
+// acceptances, so a one-acceptance-per-file naming rule would fragment a real
+// suite. Both levels are parsed here.
+import { readFileSync, statSync, readdirSync, writeFileSync } from "node:fs";
+import { join, extname, sep } from "node:path";
+
+export const DEFAULT_EXCLUDES = ["node_modules", "dist", "build", ".next", ".git", "_generated"];
+export const TEST_RE = /\.(test|spec)\.[cm]?[jt]sx?$/;
+export const PHASES = new Set(["RED", "UNIT", "SMOKE", "E2E"]);
+export const LAYERS = new Set(["domain", "application", "integration", "presentation", "assembly"]);
+
+export function parseJsonEnv(name, fallback) {
+  const raw = process.env[name];
+  if (!raw) return fallback;
+  try {
+    const v = JSON.parse(raw);
+    return Array.isArray(v) ? v : fallback;
+  } catch { return fallback; }
+}
+
+function isExcluded(path, excludes) {
+  const segs = path.split(sep);
+  return excludes.some((ex) => segs.includes(ex) || path.includes(ex));
+}
+
+// Walks TEST FILES ONLY. The tester persona governs the suite; source files are
+// the coder extension's business, and scanning them here would double-report.
+export function* walkTests(root, excludes) {
+  let st;
+  try { st = statSync(root); } catch { return; }
+  if (st.isFile()) { if (TEST_RE.test(root)) yield root; return; }
+  let names;
+  try { names = readdirSync(root); } catch { return; }
+  for (const name of names) {
+    const full = join(root, name);
+    if (isExcluded(full, excludes)) continue;
+    let cst;
+    try { cst = statSync(full); } catch { continue; }
+    if (cst.isDirectory()) yield* walkTests(full, excludes);
+    else if (TEST_RE.test(full)) yield full;
+  }
+}
+
+export function parseHeader(text) {
+  const lines = text.split(/\r?\n/);
+  let firstMeaningful = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const t = lines[i].trim();
+    if (t === "" || t.startsWith("#!")) continue;
+    firstMeaningful = i; break;
+  }
+  const H = {
+    lines,
+    firstMeaningfulNo: firstMeaningful >= 0 ? firstMeaningful + 1 : 0,
+    firstMeaningfulText: firstMeaningful >= 0 ? lines[firstMeaningful].trim() : "",
+    urn: null, acceptance: null, wmbt: null, train: null, phase: null, layer: null,
+    runtime: null,
+  };
+  const FIELDS = [["URN", "urn"], ["Acceptance", "acceptance"], ["WMBT", "wmbt"],
+                  ["Train", "train"], ["Phase", "phase"], ["Layer", "layer"],
+                  ["Runtime", "runtime"]];
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    const t = raw.trim();
+    if (t === "" || t.startsWith("#!")) continue;
+    if (!t.startsWith("//")) break;          // first real code line ends the header
+    const body = t.slice(2).trim();
+    for (const [label, key] of FIELDS) {
+      if (H[key]) continue;
+      const m = body.match(new RegExp(`^${label}:\\s*(\\S.*?)\\s*$`));
+      if (m) { H[key] = { no: i + 1, value: m[1], raw: t }; break; }
+    }
+  }
+  return H;
+}
+
+// Every `it(...)` / `test(...)` call, with the `// @covers …` tags attached in the
+// comment block immediately above it.
+export function testCases(text) {
+  const lines = text.split(/\r?\n/);
+  const cases = [];
+  const CASE_RE = /^\s*(?:it|test)(?:\.\w+)*\s*\(/;
+  for (let i = 0; i < lines.length; i++) {
+    if (!CASE_RE.test(lines[i])) continue;
+    const covers = [];
+    for (let j = i - 1; j >= 0; j--) {
+      const t = lines[j].trim();
+      if (t === "") continue;
+      if (!t.startsWith("//")) break;
+      const m = t.match(/^\/\/\s*@covers\s+(.*)$/);
+      if (m) covers.push(...m[1].split(/\s+/).filter(Boolean));
+    }
+    cases.push({ line: i + 1, text: lines[i].trim(), covers });
+  }
+  return cases;
+}
+
+// The body of the `it()` at `startLine`, by brace matching from its opening `{`.
+export function caseBody(text, startLine) {
+  const lines = text.split(/\r?\n/);
+  const offset = lines.slice(0, startLine - 1).join("\n").length + (startLine > 1 ? 1 : 0);
+  const open = text.indexOf("{", offset);
+  if (open === -1) return "";
+  let depth = 0;
+  for (let i = open; i < text.length; i++) {
+    if (text[i] === "{") depth++;
+    else if (text[i] === "}") { depth--; if (depth === 0) return text.slice(open, i + 1); }
+  }
+  return text.slice(open);
+}
+
+export function runCheck(ruleId, evaluate) {
+  const reportPath = process.env.ATDD_VIOLATIONS_REPORT;
+  if (!reportPath) {
+    process.stderr.write("tester-check: ATDD_VIOLATIONS_REPORT not set\n");
+    process.exit(2);
+  }
+  const roots = parseJsonEnv("ATDD_SCAN_ROOTS", []);
+  const excludes = [...DEFAULT_EXCLUDES, ...parseJsonEnv("ATDD_SCAN_EXCLUDES", [])];
+  const violations = [];
+  for (const root of roots) {
+    for (const file of walkTests(root, excludes)) {
+      let text;
+      try { text = readFileSync(file, "utf8"); } catch { continue; }
+      const found = evaluate(parseHeader(text), file, text) || [];
+      for (const r of (Array.isArray(found) ? found : [found])) {
+        if (!r) continue;
+        violations.push({
+          rule_id: ruleId, file, line: r.line, col: r.col ?? 1,
+          evidence: r.evidence, source_line: r.source_line ?? "",
+        });
+      }
+    }
+  }
+  writeFileSync(reportPath, JSON.stringify({ violations }, null, 2), "utf8");
+  process.stderr.write(`tester-check ${ruleId}: ${violations.length} violation(s)\n`);
+  process.exit(0);
+}

package/detectors/bun_ts_metrics_detector/atdd.implementation.yaml

@@ -0,0 +1,34 @@
+schema_version: 1.1.0
+kind: implementation
+subtype: validator
+implementation_id: bun_ts_metrics_detector
+targets_workspace: atdd.workspace.bun
+contract_version: 1.1.0
+# The native Bun realization of the seven TypeScript metric obligations that were
+# previously reachable only through atdd.workspace.python-pytest. Same thresholds,
+# same algorithms, verified to produce identical numbers — so a full-stack Bun repo
+# no longer needs a Python interpreter to enforce its own code quality.
+emits_rule_ids:
+- coder.bun.complexity-cyclomatic
+- coder.bun.complexity-length
+- coder.bun.complexity-nesting
+- coder.bun.dead-code-reachability
+- coder.bun.duplication-intra-layer
+- coder.bun.quality-comments
+- coder.bun.quality-mi
+entrypoint: detect.mjs
+report: detect.mjs
+realizes_convention:
+# Deliberately NEW rule ids rather than the existing `*-typescript` ones. Those are
+# owned by atdd.extension.coder and realized by the python-pytest detectors; a
+# second implementation claiming the same convention raises DuplicateConventionError
+# the moment a polyglot repo installs both providers. New ids carrying the SHARED
+# core aliases (COMPLEXITY-CYCLOMATIC-TS-001 and siblings) give the same lineage
+# without the collision — the pattern coder.vite.* already uses.
+- coder.bun.complexity-cyclomatic
+- coder.bun.complexity-length
+- coder.bun.complexity-nesting
+- coder.bun.dead-code-reachability
+- coder.bun.duplication-intra-layer
+- coder.bun.quality-comments
+- coder.bun.quality-mi

package/detectors/bun_ts_metrics_detector/checks/_map.json

@@ -0,0 +1,9 @@
+{
+  "ts_complexity_cyclomatic": "coder.bun.complexity-cyclomatic",
+  "ts_complexity_nesting": "coder.bun.complexity-nesting",
+  "ts_complexity_length": "coder.bun.complexity-length",
+  "ts_quality_mi": "coder.bun.quality-mi",
+  "ts_quality_comments": "coder.bun.quality-comments",
+  "ts_dead_code": "coder.bun.dead-code-reachability",
+  "ts_duplication": "coder.bun.duplication-intra-layer"
+}

package/detectors/bun_ts_metrics_detector/checks/ts_complexity_cyclomatic.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env bun
+// Member check: coder.bun.complexity-cyclomatic  (TypeScript metrics family — native Bun port)
+//
+// 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. Thresholds and algorithms are transcribed
+// from the python-pytest sibling — verified to produce identical numbers — so the
+// stack needs no Python to enforce its own metrics.
+import { walk, readRoots, readExcludes, readText, emit } from "../../../lib/scan.mjs";
+import * as M from "../ts_metrics.mjs";
+
+const RULE = "coder.bun.complexity-cyclomatic";
+const LIMIT = M.MAX_CYCLOMATIC;
+
+const violations = [];
+const excludes = readExcludes();
+for (const root of readRoots()) {
+  for (const file of walk(root, excludes, M.TS_EXT)) {
+    const text = readText(file);
+    if (!text) continue;
+    for (const f of M.extractFunctions(text)) {
+      // The Python detector skips functions under 3 code lines for every
+      // per-function metric — a two-line arrow is not a complexity problem.
+      if (M.countCodeLines(f.body) < 3) continue;
+      const value = M.cyclomatic(f.body);
+      if (value <= LIMIT) continue;
+      violations.push({
+        rule_id: RULE, file, line: f.line, col: 0,
+        evidence: `${f.name} complexity=${value} (>${LIMIT})`,
+        source_line: (f.body.split("\n")[0] || "").trim(),
+      });
+    }
+  }
+}
+process.stderr.write(`bun-metrics[cyclomatic]: ${violations.length} violation(s)\n`);
+emit(violations);

package/detectors/bun_ts_metrics_detector/checks/ts_complexity_length.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env bun
+// Member check: coder.bun.complexity-length  (TypeScript metrics family — native Bun port)
+//
+// 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. Thresholds and algorithms are transcribed
+// from the python-pytest sibling — verified to produce identical numbers — so the
+// stack needs no Python to enforce its own metrics.
+import { walk, readRoots, readExcludes, readText, emit } from "../../../lib/scan.mjs";
+import * as M from "../ts_metrics.mjs";
+
+const RULE = "coder.bun.complexity-length";
+const LIMIT = M.MAX_FUNCTION_LINES;
+
+const violations = [];
+const excludes = readExcludes();
+for (const root of readRoots()) {
+  for (const file of walk(root, excludes, M.TS_EXT)) {
+    const text = readText(file);
+    if (!text) continue;
+    for (const f of M.extractFunctions(text)) {
+      // The Python detector skips functions under 3 code lines for every
+      // per-function metric — a two-line arrow is not a complexity problem.
+      if (M.countCodeLines(f.body) < 3) continue;
+      const value = M.countCodeLines(f.body);
+      if (value <= LIMIT) continue;
+      violations.push({
+        rule_id: RULE, file, line: f.line, col: 0,
+        evidence: `${f.name} length=${value} (>${LIMIT})`,
+        source_line: (f.body.split("\n")[0] || "").trim(),
+      });
+    }
+  }
+}
+process.stderr.write(`bun-metrics[length]: ${violations.length} violation(s)\n`);
+emit(violations);

package/detectors/bun_ts_metrics_detector/checks/ts_complexity_nesting.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env bun
+// Member check: coder.bun.complexity-nesting  (TypeScript metrics family — native Bun port)
+//
+// 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. Thresholds and algorithms are transcribed
+// from the python-pytest sibling — verified to produce identical numbers — so the
+// stack needs no Python to enforce its own metrics.
+import { walk, readRoots, readExcludes, readText, emit } from "../../../lib/scan.mjs";
+import * as M from "../ts_metrics.mjs";
+
+const RULE = "coder.bun.complexity-nesting";
+const LIMIT = M.MAX_NESTING;
+
+const violations = [];
+const excludes = readExcludes();
+for (const root of readRoots()) {
+  for (const file of walk(root, excludes, M.TS_EXT)) {
+    const text = readText(file);
+    if (!text) continue;
+    for (const f of M.extractFunctions(text)) {
+      // The Python detector skips functions under 3 code lines for every
+      // per-function metric — a two-line arrow is not a complexity problem.
+      if (M.countCodeLines(f.body) < 3) continue;
+      const value = M.nestingDepth(f.body);
+      if (value <= LIMIT) continue;
+      violations.push({
+        rule_id: RULE, file, line: f.line, col: 0,
+        evidence: `${f.name} nesting depth=${value} (>${LIMIT})`,
+        source_line: (f.body.split("\n")[0] || "").trim(),
+      });
+    }
+  }
+}
+process.stderr.write(`bun-metrics[nesting]: ${violations.length} violation(s)\n`);
+emit(violations);

package/detectors/bun_ts_metrics_detector/checks/ts_dead_code.mjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env bun
+// Member check: coder.bun.dead-code-reachability  (TypeScript metrics family)
+//
+// Cross-file, unlike its siblings: it builds the module import graph, walks it
+// from the structural roots (index/wagon/composition/main/app), and reports files
+// reached by nothing in either direction.
+//
+// The import edges come from Bun's IN-PROCESS TypeScript parser rather than the
+// regex set the Python sibling must use, so `import type` — erased at compile time
+// and therefore not a runtime edge — no longer keeps a dead module alive. Same
+// obligation, measured correctly, and only possible because the runtime is Bun.
+import { walk, readRoots, readExcludes, readText, emit } from "../../../lib/scan.mjs";
+import * as M from "../ts_metrics.mjs";
+import { basename } from "node:path";
+
+const RULE = "coder.bun.dead-code-reachability";
+
+const violations = [];
+const excludes = readExcludes();
+for (const root of readRoots()) {
+  const files = [...walk(root, excludes, M.TS_EXT, true)];
+  if (!files.length) continue;
+  const all = new Set(files);
+
+  const graph = new Map();
+  const sources = new Map();
+  for (const f of files) {
+    const text = readText(f);
+    sources.set(f, text ?? "");
+    const targets = new Set();
+    for (const spec of M.moduleImports(text ?? "", f)) {
+      for (const c of M.resolveImport(spec, f, all, root)) targets.add(c);
+    }
+    graph.set(f, targets);
+  }
+
+  const roots = new Set(files.filter(M.isRootFile));
+  // No structural root means no anchor to measure reachability FROM; reporting
+  // every file as dead would be noise, not a finding. The Python sibling bails
+  // the same way.
+  if (!roots.size) continue;
+
+  const forward = M.reachableFrom(roots, graph);
+  const backward = M.reachableFrom(roots, M.reverseGraph(graph));
+
+  for (const f of files) {
+    if (forward.has(f) || backward.has(f)) continue;
+    if (M.STRUCTURAL.has(basename(f))) continue;  // index.ts is structural, like __init__.py
+    if (M.isTestFile(f)) continue;                // a test is an entrypoint, not dead code
+    violations.push({
+      rule_id: RULE, file: f, line: 1, col: 0,
+      evidence: `unreachable TypeScript file: ${basename(f)}`,
+      source_line: ((sources.get(f) || "").split("\n")[0] || "").trim(),
+    });
+  }
+}
+process.stderr.write(`bun-metrics[dead-code]: ${violations.length} violation(s)\n`);
+emit(violations);