♻️ refactor: own cross-runtime test infrastructure as @executablemd/test-support

AGENTS.md

@@ -59,7 +59,10 @@ covered without editing anything here:
     Shared production modules must not access host-specific APIs or detect the
     active runtime. Runtime-named entrypoints and adapters install
     host-specific behavior — `packages/cli/src/{deno,node,bun,compiled}.ts` are
-    the CLI's.
+    the CLI's. `packages/test-support` is the same boundary for tests: it
+    detects the active runtime to drive `@std/testing/bdd`, `node:test`, or
+    `bun:test` from one BDD surface, and is exempt from this rule. The Oxlint
+    rule tracked by issue #156 carries the same path exemption.
 
 ## Writing Guide
 

deno.json

@@ -6,8 +6,8 @@
     "@types/node": "npm:@types/node@^24.5.2",
     "@durable-streams/client": "npm:@durable-streams/client@^0.2.2",
     "@durable-streams/server": "npm:@durable-streams/server@^0.3.8",
-    "@effectionx/bdd/node": "./packages/test-support/bdd.ts",
-    "@effectionx/bdd/expect": "./packages/test-support/expect.ts",
+    "@executablemd/test-support/bdd": "./packages/test-support/bdd.ts",
+    "@executablemd/test-support/expect": "./packages/test-support/expect.ts",
     "@effectionx/test-adapter": "npm:@effectionx/test-adapter@0.7.4",
     "effection": "npm:effection@4.1.0-alpha.10",
     "effection/experimental": "npm:effection@4.1.0-alpha.10/experimental",

package.json

@@ -50,7 +50,7 @@
   },
   "devDependencies": {
     "@durable-streams/server": "^0.3.8",
-    "@effectionx/bdd": "workspace:*",
+    "@executablemd/test-support": "workspace:*",
     "oxlint": "^1",
     "oxfmt": "^0.41.0",
     "tsx": "^4.19.0",

packages/acp/tests/acceptance.test.ts

@@ -3,8 +3,8 @@
  * `rootProvider` seam drives the full Agent → session → prompt → teardown
  * lifecycle. Fake ACPX runtime, no subprocess.
  */
-import { describe, it } from "@effectionx/bdd/node";
-import { expect } from "@effectionx/bdd/expect";
+import { describe, it } from "@executablemd/test-support/bdd";
+import { expect } from "@executablemd/test-support/expect";
 import { ensure, scoped } from "effection";
 import { ensureDir, rm, writeTextFile } from "@effectionx/fs";
 import { randomUUID } from "node:crypto";

packages/acp/tests/permission-bridge.test.ts

@@ -5,8 +5,8 @@
  * aborts, and unknown option ids. Promise adaptation exists only at
  * the simulated ACPX callback boundary.
  */
-import { describe, it } from "@effectionx/bdd/node";
-import { expect } from "@effectionx/bdd/expect";
+import { describe, it } from "@executablemd/test-support/bdd";
+import { expect } from "@executablemd/test-support/expect";
 import {
   createScope,
   ensure,

packages/acp/tests/provider.test.ts

@@ -4,8 +4,8 @@
  * Drives the provider through its dependencies with a scriptable fake runtime:
  * no agent process ever starts.
  */
-import { describe, it } from "@effectionx/bdd/node";
-import { expect } from "@effectionx/bdd/expect";
+import { describe, it } from "@executablemd/test-support/bdd";
+import { expect } from "@executablemd/test-support/expect";
 import { scoped, sleep, spawn, until, withResolvers } from "effection";
 import type { Operation } from "effection";
 import { Agent, Config } from "@executablemd/core";

packages/acp/tests/serial-queue.test.ts

@@ -3,8 +3,8 @@
  * FIFO ordering, and that an active holder failing or halting still
  * advances the queue for both `slot()` and `withSlot()`.
  */
-import { describe, it } from "@effectionx/bdd/node";
-import { expect } from "@effectionx/bdd/expect";
+import { describe, it } from "@executablemd/test-support/bdd";
+import { expect } from "@executablemd/test-support/expect";
 import { scoped, sleep, spawn } from "effection";
 import { useSerialQueues } from "../src/serial-queue.ts";
 

packages/acp/tests/session-key.test.ts

@@ -1,8 +1,8 @@
 /**
  * Tier SK — session identity tests (specs/acp-client-spec.md §Session).
  */
-import { describe, it } from "@effectionx/bdd/node";
-import { expect } from "@effectionx/bdd/expect";
+import { describe, it } from "@executablemd/test-support/bdd";
+import { expect } from "@executablemd/test-support/expect";
 import { API } from "@executablemd/runtime";
 import type { Operation } from "effection";
 import {

packages/cli/tests/agent-cli.test.ts

@@ -8,8 +8,8 @@
  * commands — so availability fails fast and the failure text identifies
  * which value was selected.
  */
-import { describe, it } from "@effectionx/bdd/node";
-import { expect } from "@effectionx/bdd/expect";
+import { describe, it } from "@executablemd/test-support/bdd";
+import { expect } from "@executablemd/test-support/expect";
 import { timebox } from "@effectionx/timebox";
 import { ensure, scoped, spawn, each } from "effection";
 import type { Operation } from "effection";

packages/cli/tests/agent-config.test.ts

@@ -7,8 +7,8 @@
  * play. The environment fallback for the default agent is applied by the
  * CLI, not here.
  */
-import { describe, it } from "@effectionx/bdd/node";
-import { expect } from "@effectionx/bdd/expect";
+import { describe, it } from "@executablemd/test-support/bdd";
+import { expect } from "@executablemd/test-support/expect";
 import type { PermissionMode } from "@executablemd/core";
 import { resolveAgentConfig } from "../src/agent-config.ts";
 import type { AgentFlags } from "../src/agent-config.ts";

packages/cli/tests/cli-help.test.ts

@@ -7,8 +7,8 @@
  * never reached a trailing `--help`, so `xmd run --help` exited 1 with
  * `path: Invalid input: expected string, received undefined`.
  */
-import { describe, it } from "@effectionx/bdd/node";
-import { expect } from "@effectionx/bdd/expect";
+import { describe, it } from "@executablemd/test-support/bdd";
+import { expect } from "@executablemd/test-support/expect";
 import { exec, type Exec } from "@effectionx/process";
 import process from "node:process";
 import * as path from "node:path";

packages/cli/tests/command.test.ts

@@ -6,8 +6,8 @@
  * per-host argument order lives inside each entrypoint's own middleware and is
  * proven by that relaunch succeeding, not by inspecting an array.
  */
-import { describe, it } from "@effectionx/bdd/node";
-import { expect } from "@effectionx/bdd/expect";
+import { describe, it } from "@executablemd/test-support/bdd";
+import { expect } from "@executablemd/test-support/expect";
 import { ensure } from "effection";
 import { ensureDir, rm } from "@effectionx/fs";
 import { exec } from "@effectionx/process";

packages/cli/tests/props-cli.test.ts

@@ -6,8 +6,8 @@
  * asserted TTY-independently, and so environment sources are exercised
  * the way a user supplies them.
  */
-import { describe, it } from "@effectionx/bdd/node";
-import { expect } from "@effectionx/bdd/expect";
+import { describe, it } from "@executablemd/test-support/bdd";
+import { expect } from "@executablemd/test-support/expect";
 import { exec, type Exec } from "@effectionx/process";
 import { ensureDir, rm, writeTextFile } from "@effectionx/fs";
 import { ensure, scoped } from "effection";

packages/cli/tests/props-schema.test.ts

@@ -6,8 +6,8 @@
  * for whole-object validation; these compare the two only where the
  * adapter has to agree with it.
  */
-import { describe, it } from "@effectionx/bdd/node";
-import { expect } from "@effectionx/bdd/expect";
+import { describe, it } from "@executablemd/test-support/bdd";
+import { expect } from "@executablemd/test-support/expect";
 import { validateProps } from "@executablemd/core";
 import type { PropsSchema } from "@executablemd/core";
 import { z } from "zod";

packages/cli/tests/props-sources.test.ts

@@ -6,8 +6,8 @@
  * boundary: it stores whatever a Standard Schema returns, and it selects
  * the last valid source rather than the highest-priority supplied one.
  */
-import { describe, it } from "@effectionx/bdd/node";
-import { expect } from "@effectionx/bdd/expect";
+import { describe, it } from "@executablemd/test-support/bdd";
+import { expect } from "@executablemd/test-support/expect";
 import { buildBindings, extractPropsArgs, PropsError, resolveProps } from "../src/props.ts";
 import type { Binding } from "../src/props.ts";
 

packages/code-review-agent/tests/parse-diagnostics.test.ts

@@ -2,8 +2,8 @@
  * Tests for parseDiagnostics — Oxlint JSON output parser.
  * Covers PD1-PD8 from the oxlint-sensor-spec.
  */
-import { describe, it } from "@effectionx/bdd/node";
-import { expect } from "@effectionx/bdd/expect";
+import { describe, it } from "@executablemd/test-support/bdd";
+import { expect } from "@executablemd/test-support/expect";
 import { parseDiagnostics } from "../src/parse-diagnostics.ts";
 import type { DoctorResult, OxlintDiagnostic, PR } from "../src/types.ts";
 
@@ -55,149 +55,149 @@
 }
 
 describe("parseDiagnostics", () => {
   it("PD1: groups diagnostics by ruleId", function* () {
     const raw = JSON.stringify([
       makeDiag("no-unused-vars", "src/a.ts"),
       makeDiag("no-unused-vars", "src/b.ts"),
       makeDiag("no-console", "src/a.ts"),
     ]);
 
     const result = parseDiagnostics(raw, makePR(), makeDoctor());
 
     expect(result.groups).toHaveLength(2);
     const unused = result.groups.find((g) => g.ruleId === "no-unused-vars");
     expect(unused).toBeDefined();
     expect(unused!.count).toBe(2);
     expect(unused!.files).toEqual(["src/a.ts", "src/b.ts"]);
 
     const console = result.groups.find((g) => g.ruleId === "no-console");
     expect(console).toBeDefined();
     expect(console!.count).toBe(1);
   });
 
   it("PD2: computes density as total / additions", function* () {
     const raw = JSON.stringify([
       makeDiag("no-unused-vars", "src/a.ts"),
       makeDiag("no-unused-vars", "src/b.ts"),
       makeDiag("no-console", "src/a.ts"),
       makeDiag("no-console", "src/b.ts"),
       makeDiag("no-console", "src/c.ts"),
     ]);
 
     const result = parseDiagnostics(raw, makePR(50), makeDoctor());
 
     expect(result.total).toBe(5);
     expect(result.density).toBe(0.1);
   });
 
   it("PD2b: density is 0 when additions is 0", function* () {
     const raw = JSON.stringify([makeDiag("no-unused-vars", "src/a.ts")]);
 
     const result = parseDiagnostics(raw, makePR(0), makeDoctor());
 
     expect(result.density).toBe(0);
   });
 
   it("PD3: categorizes rules into structural, verbosity, typeAware", function* () {
     const raw = JSON.stringify([
       makeDiag("no-unused-vars", "src/a.ts"),
       makeDiag("no-console", "src/a.ts"),
       makeDiag("no-unnecessary-type-assertion", "src/a.ts"),
       makeDiag("no-inferrable-types", "src/b.ts"),
     ]);
 
     const result = parseDiagnostics(raw, makePR(), makeDoctor());
 
     expect(result.byCategory.structural.map((g) => g.ruleId)).toContain("no-unused-vars");
     expect(result.byCategory.structural.map((g) => g.ruleId)).toContain(
       "no-unnecessary-type-assertion",
     );
 
     expect(result.byCategory.verbosity.map((g) => g.ruleId)).toContain("no-console");
     expect(result.byCategory.verbosity.map((g) => g.ruleId)).toContain("no-inferrable-types");
 
     expect(result.byCategory.typeAware.map((g) => g.ruleId)).toContain(
       "no-unnecessary-type-assertion",
     );
   });
 
   it("PD4: filters import noise in type-aware-filtered mode", function* () {
     const raw = JSON.stringify([
       makeDiag("no-unused-vars", "src/a.ts"),
       makeDiag("import/no-unresolved", "src/b.ts", 1, 'Cannot find module "jsr:@std/assert"'),
       makeDiag("import/no-unresolved", "src/c.ts", 1, "cannot find module foo"),
     ]);
 
     const filtered = parseDiagnostics(
       raw,
       makePR(),
       makeDoctor({ recommendation: "type-aware-filtered" }),
     );
 
     expect(filtered.total).toBe(1);
     expect(filtered.groups).toHaveLength(1);
     expect(filtered.groups[0].ruleId).toBe("no-unused-vars");
   });
 
   it("PD4b: does NOT filter noise in type-aware mode", function* () {
     const raw = JSON.stringify([
       makeDiag("no-unused-vars", "src/a.ts"),
       makeDiag("import/no-unresolved", "src/b.ts", 1, 'Cannot find module "jsr:@std/assert"'),
     ]);
 
     const unfiltered = parseDiagnostics(
       raw,
       makePR(),
       makeDoctor({ recommendation: "type-aware" }),
     );
 
     expect(unfiltered.total).toBe(2);
   });
 
   it("PD5: annotates missing rules in summary", function* () {
     const raw = JSON.stringify([makeDiag("no-unused-vars", "src/a.ts")]);
 
     const result = parseDiagnostics(
       raw,
       makePR(),
       makeDoctor({
         bloatRulesMissing: ["no-unnecessary-type-assertion", "no-redundant-type-constituents"],
       }),
     );
 
     expect(result.summary).toContain("2 type-aware rules unavailable");
     expect(result.summary).toContain("Density may be understated");
   });
 
   it("PD6: annotates scheme specifiers in summary", function* () {
     const raw = JSON.stringify([makeDiag("no-unused-vars", "src/a.ts")]);
 
     const result = parseDiagnostics(
       raw,
       makePR(),
       makeDoctor({
         nativeSpecifiers: {
           count: 5,
           files: ["src/a.ts", "src/b.ts"],
           jsr: 3,
           npm: 2,
         },
       }),
     );
 
     expect(result.summary).toContain("5 source files use scheme specifiers");
     expect(result.summary).toContain("no-scheme-specifiers plugin");
   });
 
   it("PD7: empty input returns zero diagnostics", function* () {
     const result = parseDiagnostics("[]", makePR(), makeDoctor());
 
     expect(result.total).toBe(0);
     expect(result.density).toBe(0);
     expect(result.groups).toHaveLength(0);
     expect(result.fileCount).toBe(0);
     expect(result.ruleCount).toBe(0);
   });
 
   it("accepts oxlint object shape with diagnostics array", function* () {
     const raw = JSON.stringify({

packages/code-review-agent/tests/parse-diff.test.ts

@@ -1,8 +1,8 @@
 /**
  * Tests for parseDiff — unified diff parser.
  */
-import { describe, it } from "@effectionx/bdd/node";
-import { expect } from "@effectionx/bdd/expect";
+import { describe, it } from "@executablemd/test-support/bdd";
+import { expect } from "@executablemd/test-support/expect";
 import { parseDiff } from "../src/parse-diff.ts";
 
 const META = { title: "Test PR", body: "Test body", number: "42" };

packages/code-review-agent/tests/policy.test.ts

@@ -1,5 +1,5 @@
-import { describe, it } from "@effectionx/bdd/node";
-import { expect } from "@effectionx/bdd/expect";
+import { describe, it } from "@executablemd/test-support/bdd";
+import { expect } from "@executablemd/test-support/expect";
 import {
   buildCleanupAnalysis,
   buildPolicyInput,

packages/core/tests/agent-api.test.ts

@@ -9,8 +9,8 @@
  * operations need, so the message must not point at the registry or a CLI
  * flag.
  */
-import { describe, it } from "@effectionx/bdd/node";
-import { expect } from "@effectionx/bdd/expect";
+import { describe, it } from "@executablemd/test-support/bdd";
+import { expect } from "@executablemd/test-support/expect";
 import { Agent } from "../src/agent/agent-api.ts";
 import type { PermissionRequest } from "../src/agent/agent-api.ts";
 

packages/core/tests/agent-components.test.ts

@@ -7,8 +7,8 @@
  * `installAgentComponents`'s `rootProvider` seam — no real provider,
  * subprocess, or provider selection.
  */
-import { describe, it } from "@effectionx/bdd/node";
-import { expect } from "@effectionx/bdd/expect";
+import { describe, it } from "@executablemd/test-support/bdd";
+import { expect } from "@executablemd/test-support/expect";
 import { InMemoryStream } from "@executablemd/durable-streams";
 import { ensure, scoped } from "effection";
 import type { Operation, Result, Stream } from "effection";

packages/core/tests/agent-stack.test.ts

@@ -6,8 +6,8 @@
  * provider factories — no subprocess, no real provider. CLI precedence is
  * not established here; it is asserted at the CLI boundary.
  */
-import { describe, it } from "@effectionx/bdd/node";
-import { expect } from "@effectionx/bdd/expect";
+import { describe, it } from "@executablemd/test-support/bdd";
+import { expect } from "@executablemd/test-support/expect";
 import { ensure, scoped } from "effection";
 import type { Operation, Result } from "effection";
 import { InMemoryStream } from "@executablemd/durable-streams";

packages/core/tests/capture-errors.test.ts

@@ -1,5 +1,5 @@
-import { describe, it } from "@effectionx/bdd/node";
-import { expect } from "@effectionx/bdd/expect";
+import { describe, it } from "@executablemd/test-support/bdd";
+import { expect } from "@executablemd/test-support/expect";
 import { scoped } from "effection";
 import type { Operation } from "effection";
 import { ephemeral } from "@executablemd/durable-streams";

packages/core/tests/cli-journal.test.ts

@@ -7,8 +7,8 @@
  * Each test shells out to `deno run --allow-all packages/cli/src/deno.ts`
  * and uses timebox to prevent hangs from blocking the test suite.
  */
-import { describe, it } from "@effectionx/bdd/node";
-import { expect } from "@effectionx/bdd/expect";
+import { describe, it } from "@executablemd/test-support/bdd";
+import { expect } from "@executablemd/test-support/expect";
 import { timebox } from "@effectionx/timebox";
 import { exists, readTextFile, rm, writeTextFile } from "@effectionx/fs";
 import { ensure, spawn, each, type Operation } from "effection";

packages/core/tests/compiler-boundary.test.ts

@@ -6,8 +6,8 @@
  * no compiler, one with eval blocks says so plainly when none is installed,
  * and a compiler the caller installed is the one that runs.
  */
-import { describe, it } from "@effectionx/bdd/node";
-import { expect } from "@effectionx/bdd/expect";
+import { describe, it } from "@executablemd/test-support/bdd";
+import { expect } from "@executablemd/test-support/expect";
 import type { Operation } from "effection";
 import { InMemoryStream } from "@executablemd/durable-streams";
 import { useStubFs } from "@executablemd/runtime/test";

packages/core/tests/component-api.test.ts

@@ -2,8 +2,8 @@
  * Component Api tests — default operations, missing-provider diagnostics,
  * scoped middleware overrides, and nested provider precedence.
  */
-import { describe, it } from "@effectionx/bdd/node";
-import { expect } from "@effectionx/bdd/expect";
+import { describe, it } from "@executablemd/test-support/bdd";
+import { expect } from "@executablemd/test-support/expect";
 import { scoped } from "effection";
 import type { Operation } from "effection";
 import {

packages/core/tests/component-schema-conformance.test.ts

@@ -1,5 +1,5 @@
-import { describe, it } from "@effectionx/bdd/node";
-import { expect } from "@effectionx/bdd/expect";
+import { describe, it } from "@executablemd/test-support/bdd";
+import { expect } from "@executablemd/test-support/expect";
 import matter from "gray-matter";
 import { readTextFile, walk } from "@effectionx/fs";
 import { forEach } from "@effectionx/stream-helpers";

packages/core/tests/config-api.test.ts

@@ -6,8 +6,8 @@
  * no timeout of its own. Imported through @executablemd/core to exercise
  * the core re-export.
  */
-import { describe, it } from "@effectionx/bdd/node";
-import { expect } from "@effectionx/bdd/expect";
+import { describe, it } from "@executablemd/test-support/bdd";
+import { expect } from "@executablemd/test-support/expect";
 import { scoped } from "effection";
 import { Config, timeout } from "@executablemd/core";
 import { exec, fetch } from "@executablemd/runtime";

packages/core/tests/daemon-integration.test.ts

@@ -14,9 +14,9 @@
  * - output shape (empty output from daemon blocks)
  * - error propagation via component-scoped daemon + children
  */
-import { describe, it, beforeAll } from "@effectionx/bdd/node";
+import { describe, it, beforeAll } from "@executablemd/test-support/bdd";
 import { useTempFileCompiler } from "../src/temp-file-compiler.ts";
-import { expect } from "@effectionx/bdd/expect";
+import { expect } from "@executablemd/test-support/expect";
 import { race, sleep } from "effection";
 import { InMemoryStream } from "@executablemd/durable-streams";
 import { execute } from "../src/execute.ts";

packages/core/tests/daemon.test.ts

@@ -4,8 +4,8 @@
  * Verifies daemonFactory satisfies ModifierFactory, ignores next,
  * and composes correctly in the modifier chain.
  */
-import { describe, it } from "@effectionx/bdd/node";
-import { expect } from "@effectionx/bdd/expect";
+import { describe, it } from "@executablemd/test-support/bdd";
+import { expect } from "@executablemd/test-support/expect";
 import { scoped } from "effection";
 import { daemonFactory } from "../src/modifiers/daemon.ts";
 import { combine } from "@effectionx/middleware";

packages/core/tests/document-output-api.test.ts

@@ -6,8 +6,8 @@
  * scope.around semantics: first-installed runs first (outermost).
  * Its next() delegates to the second-installed, and so on to the core.
  */
-import { describe, it } from "@effectionx/bdd/node";
-import { expect } from "@effectionx/bdd/expect";
+import { describe, it } from "@executablemd/test-support/bdd";
+import { expect } from "@executablemd/test-support/expect";
 import { createChannel } from "effection";
 import { DocumentOutput } from "../src/api.ts";
 import { subscribe } from "../src/subscribe.ts";

packages/core/tests/each.test.ts

@@ -1,6 +1,6 @@
-import { describe, it, beforeAll } from "@effectionx/bdd/node";
+import { describe, it, beforeAll } from "@executablemd/test-support/bdd";
 import { useTempFileCompiler } from "../src/temp-file-compiler.ts";
-import { expect } from "@effectionx/bdd/expect";
+import { expect } from "@executablemd/test-support/expect";
 import { scoped } from "effection";
 import type { Operation } from "effection";
 import { expandSegments } from "../src/expand.ts";

packages/core/tests/eval-bindings.test.ts

@@ -4,9 +4,9 @@
  * Tests cross-block binding sharing, shadowing, empty blocks,
  * undeclared references, and syntax errors.
  */
-import { describe, it, beforeAll } from "@effectionx/bdd/node";
+import { describe, it, beforeAll } from "@executablemd/test-support/bdd";
 import { useTempFileCompiler } from "../src/temp-file-compiler.ts";
-import { expect } from "@effectionx/bdd/expect";
+import { expect } from "@executablemd/test-support/expect";
 import { InMemoryStream } from "@executablemd/durable-streams";
 import { useStubFs, useEchoExec } from "@executablemd/runtime/test";
 import { execute } from "../src/execute.ts";