@crewhaus/single-binary-cli 0.1.3 → 0.1.5

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -0,0 +1,50 @@
+/**
+ * `bun run build:binary` entry point. Builds the requested target, or
+ * the full BUILD_MATRIX when no target flag is passed.
+ *
+ * Examples:
+ *   bun run build:binary --target macos-arm64
+ *   bun run build:binary --version 1.0.0   # builds every entry in BUILD_MATRIX
+ */
+import { ARCHES, BUILD_MATRIX, PLATFORMS, buildBinary, formatTarget, } from "./index";
+function parseFlag(name, argv) {
+    const idx = argv.findIndex((a) => a === `--${name}`);
+    return idx >= 0 ? argv[idx + 1] : undefined;
+}
+function parseTarget(value) {
+    const [platform, arch] = value.split("-");
+    if (!platform || !arch)
+        return undefined;
+    if (!PLATFORMS.includes(platform))
+        return undefined;
+    if (!ARCHES.includes(arch))
+        return undefined;
+    return { platform: platform, arch: arch };
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    const version = parseFlag("version", argv) ?? "";
+    const targetArg = parseFlag("target", argv);
+    const targets = targetArg
+        ? (() => {
+            const t = parseTarget(targetArg);
+            if (!t) {
+                console.error(`unknown target: ${targetArg}`);
+                process.exit(2);
+            }
+            return [t];
+        })()
+        : BUILD_MATRIX;
+    for (const t of targets) {
+        process.stdout.write(`building crewhaus-${formatTarget(t)}...\n`);
+        try {
+            const result = await buildBinary({ target: t, version });
+            process.stdout.write(`  → ${result.outPath}\n`);
+        }
+        catch (err) {
+            console.error(`  ✗ ${formatTarget(t)} failed: ${err.message}`);
+            process.exit(1);
+        }
+    }
+}
+main();

package/dist/index.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Section 32 — `@crewhaus/single-binary-cli`
+ *
+ * `bun build --compile` wrapper that produces self-contained
+ * `dist/crewhaus-{linux,macos,windows}-{x64,arm64}` binaries for the
+ * `crewhaus` CLI. Each binary is ~80 MB; no Bun/Node prereq on the
+ * target host.
+ *
+ * Bun 1.2's `--compile` cross-compile matrix:
+ *   - linux-x64        ✅
+ *   - linux-arm64      ✅
+ *   - macos-x64        ✅
+ *   - macos-arm64      ✅
+ *   - windows-x64      ✅ (named "bun-windows-x64" target)
+ *   - windows-arm64    ❌ (Bun does not produce windows-arm64; documented
+ *                          gap — use linux-arm64 in WSL or skip)
+ *
+ * The auto-generated package manifests (Homebrew formula, Debian
+ * control, Scoop manifest, Winget manifest) live under
+ * `packaging/` and are templated against the binaries this package
+ * builds. `renderHomebrewFormula({version, sha256ByPlatform})` etc.
+ * regenerate them deterministically on every release.
+ */
+import { CrewhausError } from "@crewhaus/errors";
+export declare class SingleBinaryError extends CrewhausError {
+    readonly name = "SingleBinaryError";
+    constructor(message: string, cause?: unknown);
+}
+export declare const PLATFORMS: readonly ["linux", "macos", "windows"];
+export declare const ARCHES: readonly ["x64", "arm64"];
+export type Platform = (typeof PLATFORMS)[number];
+export type Arch = (typeof ARCHES)[number];
+/**
+ * The (platform, arch) pairs Bun --compile actually produces. The
+ * `windows-arm64` slot is intentionally absent because Bun has no
+ * `bun-windows-arm64` target as of Bun 1.2.
+ */
+export type BuildTarget = {
+    readonly platform: Platform;
+    readonly arch: Arch;
+};
+export declare const BUILD_MATRIX: readonly BuildTarget[];
+/** Bun's --target string for a given (platform, arch) pair. */
+export declare function bunCompileTarget(t: BuildTarget): string;
+/**
+ * Output filename of a built binary. Adds `.exe` on windows.
+ */
+export declare function binaryName(t: BuildTarget, version: string): string;
+export type BuildBinaryRunner = (argv: readonly string[], cwd: string) => Promise<{
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}>;
+export type BuildBinaryOptions = {
+    readonly target: BuildTarget;
+    readonly version?: string;
+    readonly outDir?: string;
+    /** Test injection point. Defaults to spawning bun via node:child_process. */
+    readonly runner?: BuildBinaryRunner;
+};
+export type BuildBinaryResult = {
+    readonly target: BuildTarget;
+    readonly outPath: string;
+    readonly buildArgv: readonly string[];
+};
+export declare function buildBinary(opts: BuildBinaryOptions): Promise<BuildBinaryResult>;
+export declare function isBuildTarget(t: BuildTarget): boolean;
+export declare function formatTarget(t: BuildTarget): string;
+export type ShaByTarget = Readonly<Partial<Record<string, string>>>;
+export type ManifestInputs = {
+    readonly version: string;
+    readonly homepage: string;
+    readonly downloadBaseUrl: string;
+    readonly sha256: ShaByTarget;
+};
+export declare function renderHomebrewFormula(inputs: ManifestInputs): string;
+export declare function renderDebianControl(inputs: ManifestInputs): string;
+export declare function renderScoopManifest(inputs: ManifestInputs): unknown;
+export declare function renderWingetManifest(inputs: ManifestInputs): string;
+export declare function packagingDir(): string;
+export declare function writeAllManifests(inputs: ManifestInputs, root?: string): {
+    homebrew: string;
+    debian: string;
+    scoop: string;
+    winget: string;
+};
+/** Read a file's sha256 — used by release tooling to populate manifests. */
+export declare function sha256OfFile(path: string): Promise<string>;

package/dist/index.js

@@ -0,0 +1,256 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+/**
+ * Section 32 — `@crewhaus/single-binary-cli`
+ *
+ * `bun build --compile` wrapper that produces self-contained
+ * `dist/crewhaus-{linux,macos,windows}-{x64,arm64}` binaries for the
+ * `crewhaus` CLI. Each binary is ~80 MB; no Bun/Node prereq on the
+ * target host.
+ *
+ * Bun 1.2's `--compile` cross-compile matrix:
+ *   - linux-x64        ✅
+ *   - linux-arm64      ✅
+ *   - macos-x64        ✅
+ *   - macos-arm64      ✅
+ *   - windows-x64      ✅ (named "bun-windows-x64" target)
+ *   - windows-arm64    ❌ (Bun does not produce windows-arm64; documented
+ *                          gap — use linux-arm64 in WSL or skip)
+ *
+ * The auto-generated package manifests (Homebrew formula, Debian
+ * control, Scoop manifest, Winget manifest) live under
+ * `packaging/` and are templated against the binaries this package
+ * builds. `renderHomebrewFormula({version, sha256ByPlatform})` etc.
+ * regenerate them deterministically on every release.
+ */
+import { CrewhausError } from "@crewhaus/errors";
+export class SingleBinaryError extends CrewhausError {
+    name = "SingleBinaryError";
+    constructor(message, cause) {
+        super("config", message, cause);
+    }
+}
+export const PLATFORMS = ["linux", "macos", "windows"];
+export const ARCHES = ["x64", "arm64"];
+export const BUILD_MATRIX = [
+    { platform: "linux", arch: "x64" },
+    { platform: "linux", arch: "arm64" },
+    { platform: "macos", arch: "x64" },
+    { platform: "macos", arch: "arm64" },
+    { platform: "windows", arch: "x64" },
+];
+/** Bun's --target string for a given (platform, arch) pair. */
+export function bunCompileTarget(t) {
+    return `bun-${t.platform}-${t.arch}`;
+}
+/**
+ * Output filename of a built binary. Adds `.exe` on windows.
+ */
+export function binaryName(t, version) {
+    const base = `crewhaus-${t.platform}-${t.arch}`;
+    const versioned = version ? `${base}-${version}` : base;
+    return t.platform === "windows" ? `${versioned}.exe` : versioned;
+}
+const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const REPO_ROOT = resolve(PACKAGE_ROOT, "..", "..");
+const CLI_ENTRYPOINT_REL = "apps/cli/src/index.ts";
+export async function buildBinary(opts) {
+    const t = opts.target;
+    if (!isBuildTarget(t)) {
+        throw new SingleBinaryError(`unsupported build target: ${t.platform}-${t.arch} (allowed: ${BUILD_MATRIX.map(formatTarget).join(", ")})`);
+    }
+    const outDir = opts.outDir ?? join(REPO_ROOT, "dist");
+    const version = (opts.version ?? "").trim();
+    const outPath = join(outDir, binaryName(t, version));
+    const argv = [
+        "bun",
+        "build",
+        "--compile",
+        "--target",
+        bunCompileTarget(t),
+        // Embed the version: inside a compiled binary import.meta.url points
+        // into the virtual /$bunfs tree, so the CLI's runtime ../package.json
+        // read cannot work — `crewhaus --version` uses this constant instead.
+        ...(version ? ["--define", `CREWHAUS_EMBEDDED_VERSION=${JSON.stringify(version)}`] : []),
+        CLI_ENTRYPOINT_REL,
+        "--outfile",
+        outPath,
+    ];
+    const runner = opts.runner ?? defaultRunner;
+    const { exitCode, stderr } = await runner(argv, REPO_ROOT);
+    if (exitCode !== 0) {
+        throw new SingleBinaryError(`bun build --compile (${formatTarget(t)}) exited with ${exitCode}: ${stderr.slice(0, 1024)}`);
+    }
+    return { target: t, outPath, buildArgv: argv };
+}
+export function isBuildTarget(t) {
+    return BUILD_MATRIX.some((m) => m.platform === t.platform && m.arch === t.arch);
+}
+export function formatTarget(t) {
+    return `${t.platform}-${t.arch}`;
+}
+const defaultRunner = async (argv, cwd) => {
+    const { spawn } = await import("node:child_process");
+    return new Promise((resolve_) => {
+        const head = argv[0] ?? "bun";
+        const child = spawn(head, argv.slice(1), { cwd, stdio: ["ignore", "pipe", "pipe"] });
+        const out = [];
+        const err = [];
+        child.stdout.on("data", (b) => out.push(b));
+        child.stderr.on("data", (b) => err.push(b));
+        child.on("error", (e) => resolve_({ exitCode: 1, stdout: "", stderr: String(e.message) }));
+        child.on("close", (code) => resolve_({
+            exitCode: code ?? 1,
+            stdout: Buffer.concat(out).toString("utf8"),
+            stderr: Buffer.concat(err).toString("utf8"),
+        }));
+    });
+};
+export function renderHomebrewFormula(inputs) {
+    const { version, homepage, downloadBaseUrl, sha256 } = inputs;
+    if (!/^\d+\.\d+\.\d+/.test(version)) {
+        throw new SingleBinaryError(`homebrew version must be semver-shaped: ${version}`);
+    }
+    const macosArm64 = requireSha(sha256, "macos-arm64");
+    const macosX64 = requireSha(sha256, "macos-x64");
+    const linuxArm64 = requireSha(sha256, "linux-arm64");
+    const linuxX64 = requireSha(sha256, "linux-x64");
+    return `class Crewhaus < Formula
+  desc "Modular meta-harness — compile a single spec into multiple agent runtimes"
+  homepage "${homepage}"
+  version "${version}"
+  license "Apache-2.0"
+
+  on_macos do
+    on_arm do
+      url "${downloadBaseUrl}/crewhaus-macos-arm64-${version}"
+      sha256 "${macosArm64}"
+    end
+    on_intel do
+      url "${downloadBaseUrl}/crewhaus-macos-x64-${version}"
+      sha256 "${macosX64}"
+    end
+  end
+
+  on_linux do
+    on_arm do
+      url "${downloadBaseUrl}/crewhaus-linux-arm64-${version}"
+      sha256 "${linuxArm64}"
+    end
+    on_intel do
+      url "${downloadBaseUrl}/crewhaus-linux-x64-${version}"
+      sha256 "${linuxX64}"
+    end
+  end
+
+  def install
+    bin.install Dir["*"].first => "crewhaus"
+  end
+
+  test do
+    system "#{bin}/crewhaus", "--version"
+  end
+end
+`;
+}
+export function renderDebianControl(inputs) {
+    const { version } = inputs;
+    return `Package: crewhaus
+Version: ${version}
+Section: utils
+Priority: optional
+Architecture: any
+Maintainer: CrewHaus Maintainers <maintainers@crewhaus.ai>
+Depends: libc6 (>= 2.31)
+Description: Modular meta-harness — compile a single spec into multiple agent runtimes
+ CrewHaus compiles a single high-level harness spec into multiple
+ runtime targets (graph, workflow, channel bot, eval, batch worker,
+ voice service, browser-driver, research-runner). The binary is a
+ self-contained Bun bundle requiring no Node/Bun on the target host.
+`;
+}
+export function renderScoopManifest(inputs) {
+    const { version, homepage, downloadBaseUrl, sha256 } = inputs;
+    const winX64 = requireSha(sha256, "windows-x64");
+    return {
+        version,
+        description: "Modular meta-harness — compile a single spec into multiple agent runtimes",
+        homepage,
+        license: "Apache-2.0",
+        architecture: {
+            "64bit": {
+                url: `${downloadBaseUrl}/crewhaus-windows-x64-${version}.exe`,
+                hash: winX64,
+            },
+        },
+        bin: "crewhaus.exe",
+    };
+}
+export function renderWingetManifest(inputs) {
+    const { version, homepage, downloadBaseUrl, sha256 } = inputs;
+    const winX64 = requireSha(sha256, "windows-x64");
+    return `# yaml-language-server: $schema=https://aka.ms/winget-manifest.installer.1.4.0.schema.json
+PackageIdentifier: CrewHaus.CLI
+PackageVersion: ${version}
+Publisher: CrewHaus
+Author: CrewHaus
+PackageName: crewhaus
+PackageUrl: ${homepage}
+License: Apache-2.0
+ShortDescription: Modular meta-harness — compile a single spec into multiple agent runtimes
+Description: |
+  CrewHaus compiles a single high-level harness spec into multiple runtime targets.
+Tags:
+  - cli
+  - llm
+  - agent-framework
+Installers:
+  - Architecture: x64
+    InstallerType: portable
+    InstallerUrl: ${downloadBaseUrl}/crewhaus-windows-x64-${version}.exe
+    InstallerSha256: ${winX64.toUpperCase()}
+ManifestType: installer
+ManifestVersion: 1.4.0
+`;
+}
+function requireSha(map, target) {
+    const sha = map[target];
+    if (!sha) {
+        throw new SingleBinaryError(`missing sha256 for ${target} in package manifest inputs`);
+    }
+    if (!/^[0-9a-f]{64}$/i.test(sha)) {
+        throw new SingleBinaryError(`malformed sha256 for ${target}: ${sha}`);
+    }
+    return sha;
+}
+// ─── on-disk manifest writers ────────────────────────────────────────────────
+export function packagingDir() {
+    return join(PACKAGE_ROOT, "packaging");
+}
+export function writeAllManifests(inputs, root = packagingDir()) {
+    mkdirSync(join(root, "Formula"), { recursive: true });
+    mkdirSync(join(root, "debian"), { recursive: true });
+    const homebrew = join(root, "Formula", "crewhaus.rb");
+    const debian = join(root, "debian", "control");
+    const scoop = join(root, "scoop.json");
+    const winget = join(root, "winget.yaml");
+    writeFileSync(homebrew, renderHomebrewFormula(inputs), { mode: 0o644 });
+    writeFileSync(debian, renderDebianControl(inputs), { mode: 0o644 });
+    writeFileSync(scoop, `${JSON.stringify(renderScoopManifest(inputs), null, 2)}\n`, {
+        mode: 0o644,
+    });
+    writeFileSync(winget, renderWingetManifest(inputs), { mode: 0o644 });
+    return { homebrew, debian, scoop, winget };
+}
+// ─── helpers consumed by the binary CLI ─────────────────────────────────────
+/** Read a file's sha256 — used by release tooling to populate manifests. */
+export async function sha256OfFile(path) {
+    if (!existsSync(path)) {
+        throw new SingleBinaryError(`file not found: ${path}`);
+    }
+    const { createHash } = await import("node:crypto");
+    const hash = createHash("sha256");
+    hash.update(readFileSync(path));
+    return hash.digest("hex");
+}

package/dist/manifests.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/dist/manifests.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env bun
+/**
+ * Generate the Homebrew / apt / Scoop / Winget package manifests from the
+ * binaries already built into `dist/` by `build:binary`. Run AFTER the build.
+ * Used by the release workflow (.github/workflows/release.yml) so the manifest
+ * generation is a single, unit-tested command rather than inline YAML.
+ *
+ *   bun src/manifests.ts --version 1.2.3 \
+ *     --download-base-url https://github.com/crewhaus/factory/releases/download/v1.2.3 \
+ *     --dist <repo>/dist --out <repo>/packaging
+ *
+ * Prints a JSON summary ({version, downloadBaseUrl, sha256, written}) to stdout
+ * so CI can capture the sha map and the written paths.
+ */
+import { join, resolve } from "node:path";
+import { BUILD_MATRIX, binaryName, formatTarget, packagingDir, sha256OfFile, writeAllManifests, } from "./index";
+function flag(name, argv) {
+    const i = argv.indexOf(`--${name}`);
+    return i >= 0 ? argv[i + 1] : undefined;
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    const version = flag("version", argv);
+    if (!version) {
+        console.error("✗ --version is required (e.g. --version 1.2.3)");
+        process.exit(1);
+    }
+    const homepage = flag("homepage", argv) ?? "https://github.com/crewhaus/factory";
+    const downloadBaseUrl = flag("download-base-url", argv) ??
+        `https://github.com/crewhaus/factory/releases/download/v${version}`;
+    const distDir = resolve(flag("dist", argv) ?? join(import.meta.dir, "..", "..", "..", "dist"));
+    const outArg = flag("out", argv);
+    const outDir = outArg ? resolve(outArg) : packagingDir();
+    // sha256 every built binary. A missing file is a hard error — the manifests
+    // must never reference an asset that was not actually built and uploaded.
+    const sha256 = {};
+    for (const t of BUILD_MATRIX) {
+        const file = join(distDir, binaryName(t, version));
+        sha256[formatTarget(t)] = await sha256OfFile(file);
+    }
+    const inputs = { version, homepage, downloadBaseUrl, sha256: sha256 };
+    const written = writeAllManifests(inputs, outDir);
+    console.log(JSON.stringify({ version, downloadBaseUrl, sha256, written }, null, 2));
+}
+main().catch((err) => {
+    console.error(`✗ manifest generation failed: ${err.message}`);
+    process.exit(1);
+});

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@crewhaus/single-binary-cli",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "type": "module",
   "description": "bun build --compile wrapper producing self-contained crewhaus binaries for linux/macos/windows × x64/arm64; auto-generated Homebrew/apt/Scoop/Winget manifests (Section 32)",
-  "main": "src/index.ts",
-  "types": "src/index.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "exports": {
-    ".": "./src/index.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
   },
   "scripts": {
     "test": "bun test src",
@@ -14,7 +17,7 @@
     "manifests": "bun src/manifests.ts"
   },
   "dependencies": {
-    "@crewhaus/errors": "0.1.3"
+    "@crewhaus/errors": "0.1.5"
   },
   "license": "Apache-2.0",
   "author": {
@@ -34,5 +37,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "files": ["src", "README.md", "LICENSE", "NOTICE"]
+  "files": ["dist", "README.md", "LICENSE", "NOTICE"]
 }

package/src/cli.ts

@@ -1,60 +0,0 @@
-/**
- * `bun run build:binary` entry point. Builds the requested target, or
- * the full BUILD_MATRIX when no target flag is passed.
- *
- * Examples:
- *   bun run build:binary --target macos-arm64
- *   bun run build:binary --version 1.0.0   # builds every entry in BUILD_MATRIX
- */
-import {
-  ARCHES,
-  type Arch,
-  BUILD_MATRIX,
-  type BuildTarget,
-  PLATFORMS,
-  type Platform,
-  buildBinary,
-  formatTarget,
-} from "./index";
-
-function parseFlag(name: string, argv: string[]): string | undefined {
-  const idx = argv.findIndex((a) => a === `--${name}`);
-  return idx >= 0 ? argv[idx + 1] : undefined;
-}
-
-function parseTarget(value: string): BuildTarget | undefined {
-  const [platform, arch] = value.split("-") as [string, string | undefined];
-  if (!platform || !arch) return undefined;
-  if (!(PLATFORMS as readonly string[]).includes(platform)) return undefined;
-  if (!(ARCHES as readonly string[]).includes(arch)) return undefined;
-  return { platform: platform as Platform, arch: arch as Arch };
-}
-
-async function main() {
-  const argv = process.argv.slice(2);
-  const version = parseFlag("version", argv) ?? "";
-  const targetArg = parseFlag("target", argv);
-  const targets: readonly BuildTarget[] = targetArg
-    ? (() => {
-        const t = parseTarget(targetArg);
-        if (!t) {
-          console.error(`unknown target: ${targetArg}`);
-          process.exit(2);
-        }
-        return [t];
-      })()
-    : BUILD_MATRIX;
-
-  for (const t of targets) {
-    process.stdout.write(`building crewhaus-${formatTarget(t)}...\n`);
-    try {
-      const result = await buildBinary({ target: t, version });
-      process.stdout.write(`  → ${result.outPath}\n`);
-    } catch (err) {
-      console.error(`  ✗ ${formatTarget(t)} failed: ${(err as Error).message}`);
-      process.exit(1);
-    }
-  }
-}
-
-main();

package/src/index.test.ts

@@ -1,246 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { mkdtempSync, readFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import {
-  ARCHES,
-  BUILD_MATRIX,
-  type BuildBinaryRunner,
-  type BuildTarget,
-  PLATFORMS,
-  SingleBinaryError,
-  binaryName,
-  buildBinary,
-  bunCompileTarget,
-  formatTarget,
-  isBuildTarget,
-  packagingDir,
-  renderDebianControl,
-  renderHomebrewFormula,
-  renderScoopManifest,
-  renderWingetManifest,
-  sha256OfFile,
-  writeAllManifests,
-} from "./index";
-
-describe("BUILD_MATRIX shape", () => {
-  test("has 5 entries (windows-arm64 intentionally absent)", () => {
-    expect(BUILD_MATRIX.length).toBe(5);
-    expect(
-      BUILD_MATRIX.find((m) => m.platform === "windows" && m.arch === "arm64"),
-    ).toBeUndefined();
-  });
-
-  test("PLATFORMS and ARCHES are tightly typed enums", () => {
-    expect(PLATFORMS).toEqual(["linux", "macos", "windows"]);
-    expect(ARCHES).toEqual(["x64", "arm64"]);
-  });
-});
-
-describe("bunCompileTarget", () => {
-  test.each(BUILD_MATRIX.map((t): [BuildTarget, string] => [t, `bun-${t.platform}-${t.arch}`]))(
-    "%j → %s",
-    (t, expected) => {
-      expect(bunCompileTarget(t)).toBe(expected);
-    },
-  );
-});
-
-describe("binaryName", () => {
-  test("appends version + .exe on windows", () => {
-    expect(binaryName({ platform: "windows", arch: "x64" }, "1.0.0")).toBe(
-      "crewhaus-windows-x64-1.0.0.exe",
-    );
-  });
-
-  test("no .exe on linux/macos", () => {
-    expect(binaryName({ platform: "linux", arch: "x64" }, "1.0.0")).toBe(
-      "crewhaus-linux-x64-1.0.0",
-    );
-    expect(binaryName({ platform: "macos", arch: "arm64" }, "0.0.1")).toBe(
-      "crewhaus-macos-arm64-0.0.1",
-    );
-  });
-
-  test("empty version → no trailing dash", () => {
-    expect(binaryName({ platform: "linux", arch: "x64" }, "")).toBe("crewhaus-linux-x64");
-  });
-});
-
-describe("isBuildTarget guard", () => {
-  test("accepts every entry in BUILD_MATRIX", () => {
-    for (const t of BUILD_MATRIX) {
-      expect(isBuildTarget(t)).toBe(true);
-    }
-  });
-
-  test("rejects windows-arm64 (not supported by Bun)", () => {
-    expect(isBuildTarget({ platform: "windows", arch: "arm64" })).toBe(false);
-  });
-});
-
-describe("buildBinary() (T2 dry-run)", () => {
-  test("happy path — argv is bun build --compile --target=<platform>-<arch> ...", async () => {
-    let captured: readonly string[] = [];
-    const runner: BuildBinaryRunner = async (argv) => {
-      captured = argv;
-      return { exitCode: 0, stdout: "", stderr: "" };
-    };
-    const result = await buildBinary({
-      target: { platform: "linux", arch: "x64" },
-      version: "1.2.3",
-      outDir: "/tmp/dist",
-      runner,
-    });
-    expect(captured[0]).toBe("bun");
-    expect(captured).toContain("build");
-    expect(captured).toContain("--compile");
-    expect(captured).toContain("--target");
-    expect(captured).toContain("bun-linux-x64");
-    expect(captured).toContain("--outfile");
-    expect(captured).toContain("/tmp/dist/crewhaus-linux-x64-1.2.3");
-    expect(captured).toContain("--define");
-    expect(captured).toContain('CREWHAUS_EMBEDDED_VERSION="1.2.3"');
-    expect(result.outPath).toBe("/tmp/dist/crewhaus-linux-x64-1.2.3");
-  });
-
-  test("no version → no --define (the CLI falls back to its package.json read)", async () => {
-    let captured: readonly string[] = [];
-    const runner: BuildBinaryRunner = async (argv) => {
-      captured = argv;
-      return { exitCode: 0, stdout: "", stderr: "" };
-    };
-    await buildBinary({
-      target: { platform: "linux", arch: "x64" },
-      outDir: "/tmp/dist",
-      runner,
-    });
-    expect(captured).not.toContain("--define");
-  });
-
-  test("rejects unsupported target windows-arm64", async () => {
-    await expect(
-      buildBinary({
-        target: { platform: "windows", arch: "arm64" },
-        runner: async () => ({ exitCode: 0, stdout: "", stderr: "" }),
-      }),
-    ).rejects.toThrow(/unsupported build target/);
-  });
-
-  test("non-zero exit → SingleBinaryError with stderr", async () => {
-    await expect(
-      buildBinary({
-        target: { platform: "linux", arch: "x64" },
-        runner: async () => ({ exitCode: 2, stdout: "", stderr: "bun not found" }),
-      }),
-    ).rejects.toThrow(/bun not found/);
-  });
-
-  test("formatTarget round-trip", () => {
-    expect(formatTarget({ platform: "linux", arch: "arm64" })).toBe("linux-arm64");
-  });
-});
-
-describe("manifest rendering (T1)", () => {
-  const sha256 = {
-    "macos-arm64": "a".repeat(64),
-    "macos-x64": "b".repeat(64),
-    "linux-arm64": "c".repeat(64),
-    "linux-x64": "d".repeat(64),
-    "windows-x64": "e".repeat(64),
-  } as const;
-
-  const inputs = {
-    version: "1.0.0",
-    homepage: "https://github.com/crewhaus/factory",
-    downloadBaseUrl: "https://github.com/crewhaus/factory/releases/download/v1.0.0",
-    sha256,
-  };
-
-  test("Homebrew formula has on_macos / on_linux blocks with correct shas", () => {
-    const formula = renderHomebrewFormula(inputs);
-    expect(formula).toContain("class Crewhaus < Formula");
-    expect(formula).toContain('version "1.0.0"');
-    expect(formula).toContain("on_macos");
-    expect(formula).toContain("on_linux");
-    expect(formula).toContain('license "Apache-2.0"');
-    expect(formula).toContain(sha256["macos-arm64"]);
-    expect(formula).toContain(sha256["macos-x64"]);
-    expect(formula).toContain(sha256["linux-arm64"]);
-    expect(formula).toContain(sha256["linux-x64"]);
-  });
-
-  test("Homebrew rejects non-semver versions", () => {
-    expect(() => renderHomebrewFormula({ ...inputs, version: "v1" })).toThrow();
-  });
-
-  test("Debian control has correct Architecture/Description", () => {
-    const ctl = renderDebianControl(inputs);
-    expect(ctl).toContain("Package: crewhaus");
-    expect(ctl).toContain("Version: 1.0.0");
-    expect(ctl).toContain("Architecture: any");
-  });
-
-  test("Scoop manifest exposes 64bit url + hash", () => {
-    const scoop = renderScoopManifest(inputs) as {
-      version: string;
-      license: string;
-      architecture: { "64bit": { url: string; hash: string } };
-    };
-    expect(scoop.version).toBe("1.0.0");
-    expect(scoop.license).toBe("Apache-2.0");
-    expect(scoop.architecture["64bit"].hash).toBe(sha256["windows-x64"]);
-    expect(scoop.architecture["64bit"].url).toContain("crewhaus-windows-x64-1.0.0.exe");
-  });
-
-  test("Winget manifest is valid YAML-shaped text with InstallerSha256 uppercase", () => {
-    const winget = renderWingetManifest(inputs);
-    expect(winget).toContain("PackageIdentifier: CrewHaus.CLI");
-    expect(winget).toContain("PackageVersion: 1.0.0");
-    expect(winget).toContain("License: Apache-2.0");
-    expect(winget).toContain(sha256["windows-x64"].toUpperCase());
-  });
-
-  test("manifest rendering refuses missing/short shas", () => {
-    expect(() =>
-      renderHomebrewFormula({ ...inputs, sha256: { "macos-arm64": sha256["macos-arm64"] } }),
-    ).toThrow(/missing sha256/);
-    expect(() => renderScoopManifest({ ...inputs, sha256: { "windows-x64": "short" } })).toThrow(
-      /malformed sha256/,
-    );
-  });
-
-  test("writeAllManifests writes deterministic files", () => {
-    const dir = mkdtempSync(join(tmpdir(), "crewhaus-pkg-"));
-    const out = writeAllManifests(inputs, dir);
-    const formulaText = readFileSync(out.homebrew, "utf8");
-    const scoopText = readFileSync(out.scoop, "utf8");
-    expect(formulaText).toContain('version "1.0.0"');
-    expect(scoopText).toContain(
-      '"hash": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"',
-    );
-  });
-
-  test("packagingDir() points at the package's packaging/ directory (default root)", () => {
-    // The default on-disk root used by writeAllManifests when no dir is given.
-    expect(packagingDir()).toMatch(/single-binary-cli[/\\]packaging$/);
-  });
-});
-
-describe("sha256OfFile", () => {
-  test("rejects missing files", async () => {
-    await expect(sha256OfFile("/nonexistent/path/to/file")).rejects.toThrow(SingleBinaryError);
-  });
-
-  test("hashes a real file deterministically", async () => {
-    const dir = mkdtempSync(join(tmpdir(), "crewhaus-sha-"));
-    const path = join(dir, "test.bin");
-    const { writeFileSync } = await import("node:fs");
-    writeFileSync(path, "deterministic test bytes");
-    const a = await sha256OfFile(path);
-    const b = await sha256OfFile(path);
-    expect(a).toBe(b);
-    expect(a).toMatch(/^[0-9a-f]{64}$/);
-  });
-});

package/src/index.ts

@@ -1,331 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-/**
- * Section 32 — `@crewhaus/single-binary-cli`
- *
- * `bun build --compile` wrapper that produces self-contained
- * `dist/crewhaus-{linux,macos,windows}-{x64,arm64}` binaries for the
- * `crewhaus` CLI. Each binary is ~80 MB; no Bun/Node prereq on the
- * target host.
- *
- * Bun 1.2's `--compile` cross-compile matrix:
- *   - linux-x64        ✅
- *   - linux-arm64      ✅
- *   - macos-x64        ✅
- *   - macos-arm64      ✅
- *   - windows-x64      ✅ (named "bun-windows-x64" target)
- *   - windows-arm64    ❌ (Bun does not produce windows-arm64; documented
- *                          gap — use linux-arm64 in WSL or skip)
- *
- * The auto-generated package manifests (Homebrew formula, Debian
- * control, Scoop manifest, Winget manifest) live under
- * `packaging/` and are templated against the binaries this package
- * builds. `renderHomebrewFormula({version, sha256ByPlatform})` etc.
- * regenerate them deterministically on every release.
- */
-import { CrewhausError } from "@crewhaus/errors";
-
-export class SingleBinaryError extends CrewhausError {
-  override readonly name = "SingleBinaryError";
-  constructor(message: string, cause?: unknown) {
-    super("config", message, cause);
-  }
-}
-
-export const PLATFORMS = ["linux", "macos", "windows"] as const;
-export const ARCHES = ["x64", "arm64"] as const;
-export type Platform = (typeof PLATFORMS)[number];
-export type Arch = (typeof ARCHES)[number];
-
-/**
- * The (platform, arch) pairs Bun --compile actually produces. The
- * `windows-arm64` slot is intentionally absent because Bun has no
- * `bun-windows-arm64` target as of Bun 1.2.
- */
-export type BuildTarget = { readonly platform: Platform; readonly arch: Arch };
-export const BUILD_MATRIX: readonly BuildTarget[] = [
-  { platform: "linux", arch: "x64" },
-  { platform: "linux", arch: "arm64" },
-  { platform: "macos", arch: "x64" },
-  { platform: "macos", arch: "arm64" },
-  { platform: "windows", arch: "x64" },
-];
-
-/** Bun's --target string for a given (platform, arch) pair. */
-export function bunCompileTarget(t: BuildTarget): string {
-  return `bun-${t.platform}-${t.arch}`;
-}
-
-/**
- * Output filename of a built binary. Adds `.exe` on windows.
- */
-export function binaryName(t: BuildTarget, version: string): string {
-  const base = `crewhaus-${t.platform}-${t.arch}`;
-  const versioned = version ? `${base}-${version}` : base;
-  return t.platform === "windows" ? `${versioned}.exe` : versioned;
-}
-
-const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
-const REPO_ROOT = resolve(PACKAGE_ROOT, "..", "..");
-const CLI_ENTRYPOINT_REL = "apps/cli/src/index.ts";
-
-export type BuildBinaryRunner = (
-  argv: readonly string[],
-  cwd: string,
-) => Promise<{ exitCode: number; stdout: string; stderr: string }>;
-
-export type BuildBinaryOptions = {
-  readonly target: BuildTarget;
-  readonly version?: string;
-  readonly outDir?: string;
-  /** Test injection point. Defaults to spawning bun via node:child_process. */
-  readonly runner?: BuildBinaryRunner;
-};
-
-export type BuildBinaryResult = {
-  readonly target: BuildTarget;
-  readonly outPath: string;
-  readonly buildArgv: readonly string[];
-};
-
-export async function buildBinary(opts: BuildBinaryOptions): Promise<BuildBinaryResult> {
-  const t = opts.target;
-  if (!isBuildTarget(t)) {
-    throw new SingleBinaryError(
-      `unsupported build target: ${t.platform}-${t.arch} (allowed: ${BUILD_MATRIX.map(formatTarget).join(", ")})`,
-    );
-  }
-  const outDir = opts.outDir ?? join(REPO_ROOT, "dist");
-  const version = (opts.version ?? "").trim();
-  const outPath = join(outDir, binaryName(t, version));
-  const argv: string[] = [
-    "bun",
-    "build",
-    "--compile",
-    "--target",
-    bunCompileTarget(t),
-    // Embed the version: inside a compiled binary import.meta.url points
-    // into the virtual /$bunfs tree, so the CLI's runtime ../package.json
-    // read cannot work — `crewhaus --version` uses this constant instead.
-    ...(version ? ["--define", `CREWHAUS_EMBEDDED_VERSION=${JSON.stringify(version)}`] : []),
-    CLI_ENTRYPOINT_REL,
-    "--outfile",
-    outPath,
-  ];
-
-  const runner = opts.runner ?? defaultRunner;
-  const { exitCode, stderr } = await runner(argv, REPO_ROOT);
-  if (exitCode !== 0) {
-    throw new SingleBinaryError(
-      `bun build --compile (${formatTarget(t)}) exited with ${exitCode}: ${stderr.slice(0, 1024)}`,
-    );
-  }
-  return { target: t, outPath, buildArgv: argv };
-}
-
-export function isBuildTarget(t: BuildTarget): boolean {
-  return BUILD_MATRIX.some((m) => m.platform === t.platform && m.arch === t.arch);
-}
-
-export function formatTarget(t: BuildTarget): string {
-  return `${t.platform}-${t.arch}`;
-}
-
-const defaultRunner: BuildBinaryRunner = async (argv, cwd) => {
-  const { spawn } = await import("node:child_process");
-  return new Promise((resolve_) => {
-    const head = argv[0] ?? "bun";
-    const child = spawn(head, argv.slice(1), { cwd, stdio: ["ignore", "pipe", "pipe"] });
-    const out: Buffer[] = [];
-    const err: Buffer[] = [];
-    child.stdout.on("data", (b) => out.push(b));
-    child.stderr.on("data", (b) => err.push(b));
-    child.on("error", (e) =>
-      resolve_({ exitCode: 1, stdout: "", stderr: String((e as Error).message) }),
-    );
-    child.on("close", (code) =>
-      resolve_({
-        exitCode: code ?? 1,
-        stdout: Buffer.concat(out).toString("utf8"),
-        stderr: Buffer.concat(err).toString("utf8"),
-      }),
-    );
-  });
-};
-
-// ─── package manifest generation ─────────────────────────────────────────────
-
-export type ShaByTarget = Readonly<Partial<Record<string, string>>>;
-
-export type ManifestInputs = {
-  readonly version: string;
-  readonly homepage: string;
-  readonly downloadBaseUrl: string;
-  readonly sha256: ShaByTarget;
-};
-
-export function renderHomebrewFormula(inputs: ManifestInputs): string {
-  const { version, homepage, downloadBaseUrl, sha256 } = inputs;
-  if (!/^\d+\.\d+\.\d+/.test(version)) {
-    throw new SingleBinaryError(`homebrew version must be semver-shaped: ${version}`);
-  }
-  const macosArm64 = requireSha(sha256, "macos-arm64");
-  const macosX64 = requireSha(sha256, "macos-x64");
-  const linuxArm64 = requireSha(sha256, "linux-arm64");
-  const linuxX64 = requireSha(sha256, "linux-x64");
-  return `class Crewhaus < Formula
-  desc "Modular meta-harness — compile a single spec into multiple agent runtimes"
-  homepage "${homepage}"
-  version "${version}"
-  license "Apache-2.0"
-
-  on_macos do
-    on_arm do
-      url "${downloadBaseUrl}/crewhaus-macos-arm64-${version}"
-      sha256 "${macosArm64}"
-    end
-    on_intel do
-      url "${downloadBaseUrl}/crewhaus-macos-x64-${version}"
-      sha256 "${macosX64}"
-    end
-  end
-
-  on_linux do
-    on_arm do
-      url "${downloadBaseUrl}/crewhaus-linux-arm64-${version}"
-      sha256 "${linuxArm64}"
-    end
-    on_intel do
-      url "${downloadBaseUrl}/crewhaus-linux-x64-${version}"
-      sha256 "${linuxX64}"
-    end
-  end
-
-  def install
-    bin.install Dir["*"].first => "crewhaus"
-  end
-
-  test do
-    system "#{bin}/crewhaus", "--version"
-  end
-end
-`;
-}
-
-export function renderDebianControl(inputs: ManifestInputs): string {
-  const { version } = inputs;
-  return `Package: crewhaus
-Version: ${version}
-Section: utils
-Priority: optional
-Architecture: any
-Maintainer: CrewHaus Maintainers <maintainers@crewhaus.ai>
-Depends: libc6 (>= 2.31)
-Description: Modular meta-harness — compile a single spec into multiple agent runtimes
- CrewHaus compiles a single high-level harness spec into multiple
- runtime targets (graph, workflow, channel bot, eval, batch worker,
- voice service, browser-driver, research-runner). The binary is a
- self-contained Bun bundle requiring no Node/Bun on the target host.
-`;
-}
-
-export function renderScoopManifest(inputs: ManifestInputs): unknown {
-  const { version, homepage, downloadBaseUrl, sha256 } = inputs;
-  const winX64 = requireSha(sha256, "windows-x64");
-  return {
-    version,
-    description: "Modular meta-harness — compile a single spec into multiple agent runtimes",
-    homepage,
-    license: "Apache-2.0",
-    architecture: {
-      "64bit": {
-        url: `${downloadBaseUrl}/crewhaus-windows-x64-${version}.exe`,
-        hash: winX64,
-      },
-    },
-    bin: "crewhaus.exe",
-  };
-}
-
-export function renderWingetManifest(inputs: ManifestInputs): string {
-  const { version, homepage, downloadBaseUrl, sha256 } = inputs;
-  const winX64 = requireSha(sha256, "windows-x64");
-  return `# yaml-language-server: $schema=https://aka.ms/winget-manifest.installer.1.4.0.schema.json
-PackageIdentifier: CrewHaus.CLI
-PackageVersion: ${version}
-Publisher: CrewHaus
-Author: CrewHaus
-PackageName: crewhaus
-PackageUrl: ${homepage}
-License: Apache-2.0
-ShortDescription: Modular meta-harness — compile a single spec into multiple agent runtimes
-Description: |
-  CrewHaus compiles a single high-level harness spec into multiple runtime targets.
-Tags:
-  - cli
-  - llm
-  - agent-framework
-Installers:
-  - Architecture: x64
-    InstallerType: portable
-    InstallerUrl: ${downloadBaseUrl}/crewhaus-windows-x64-${version}.exe
-    InstallerSha256: ${winX64.toUpperCase()}
-ManifestType: installer
-ManifestVersion: 1.4.0
-`;
-}
-
-function requireSha(map: ShaByTarget, target: string): string {
-  const sha = map[target];
-  if (!sha) {
-    throw new SingleBinaryError(`missing sha256 for ${target} in package manifest inputs`);
-  }
-  if (!/^[0-9a-f]{64}$/i.test(sha)) {
-    throw new SingleBinaryError(`malformed sha256 for ${target}: ${sha}`);
-  }
-  return sha;
-}
-
-// ─── on-disk manifest writers ────────────────────────────────────────────────
-
-export function packagingDir(): string {
-  return join(PACKAGE_ROOT, "packaging");
-}
-
-export function writeAllManifests(
-  inputs: ManifestInputs,
-  root: string = packagingDir(),
-): {
-  homebrew: string;
-  debian: string;
-  scoop: string;
-  winget: string;
-} {
-  mkdirSync(join(root, "Formula"), { recursive: true });
-  mkdirSync(join(root, "debian"), { recursive: true });
-  const homebrew = join(root, "Formula", "crewhaus.rb");
-  const debian = join(root, "debian", "control");
-  const scoop = join(root, "scoop.json");
-  const winget = join(root, "winget.yaml");
-  writeFileSync(homebrew, renderHomebrewFormula(inputs), { mode: 0o644 });
-  writeFileSync(debian, renderDebianControl(inputs), { mode: 0o644 });
-  writeFileSync(scoop, `${JSON.stringify(renderScoopManifest(inputs), null, 2)}\n`, {
-    mode: 0o644,
-  });
-  writeFileSync(winget, renderWingetManifest(inputs), { mode: 0o644 });
-  return { homebrew, debian, scoop, winget };
-}
-
-// ─── helpers consumed by the binary CLI ─────────────────────────────────────
-
-/** Read a file's sha256 — used by release tooling to populate manifests. */
-export async function sha256OfFile(path: string): Promise<string> {
-  if (!existsSync(path)) {
-    throw new SingleBinaryError(`file not found: ${path}`);
-  }
-  const { createHash } = await import("node:crypto");
-  const hash = createHash("sha256");
-  hash.update(readFileSync(path));
-  return hash.digest("hex");
-}

package/src/manifests.ts

@@ -1,63 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Generate the Homebrew / apt / Scoop / Winget package manifests from the
- * binaries already built into `dist/` by `build:binary`. Run AFTER the build.
- * Used by the release workflow (.github/workflows/release.yml) so the manifest
- * generation is a single, unit-tested command rather than inline YAML.
- *
- *   bun src/manifests.ts --version 1.2.3 \
- *     --download-base-url https://github.com/crewhaus/factory/releases/download/v1.2.3 \
- *     --dist <repo>/dist --out <repo>/packaging
- *
- * Prints a JSON summary ({version, downloadBaseUrl, sha256, written}) to stdout
- * so CI can capture the sha map and the written paths.
- */
-import { join, resolve } from "node:path";
-import {
-  BUILD_MATRIX,
-  type ShaByTarget,
-  binaryName,
-  formatTarget,
-  packagingDir,
-  sha256OfFile,
-  writeAllManifests,
-} from "./index";
-
-function flag(name: string, argv: string[]): string | undefined {
-  const i = argv.indexOf(`--${name}`);
-  return i >= 0 ? argv[i + 1] : undefined;
-}
-
-async function main() {
-  const argv = process.argv.slice(2);
-  const version = flag("version", argv);
-  if (!version) {
-    console.error("✗ --version is required (e.g. --version 1.2.3)");
-    process.exit(1);
-  }
-  const homepage = flag("homepage", argv) ?? "https://github.com/crewhaus/factory";
-  const downloadBaseUrl =
-    flag("download-base-url", argv) ??
-    `https://github.com/crewhaus/factory/releases/download/v${version}`;
-  const distDir = resolve(flag("dist", argv) ?? join(import.meta.dir, "..", "..", "..", "dist"));
-  const outArg = flag("out", argv);
-  const outDir = outArg ? resolve(outArg) : packagingDir();
-
-  // sha256 every built binary. A missing file is a hard error — the manifests
-  // must never reference an asset that was not actually built and uploaded.
-  const sha256: Record<string, string> = {};
-  for (const t of BUILD_MATRIX) {
-    const file = join(distDir, binaryName(t, version));
-    sha256[formatTarget(t)] = await sha256OfFile(file);
-  }
-
-  const inputs = { version, homepage, downloadBaseUrl, sha256: sha256 as ShaByTarget };
-  const written = writeAllManifests(inputs, outDir);
-
-  console.log(JSON.stringify({ version, downloadBaseUrl, sha256, written }, null, 2));
-}
-
-main().catch((err) => {
-  console.error(`✗ manifest generation failed: ${(err as Error).message}`);
-  process.exit(1);
-});

package/src/runner.test.ts

@@ -1,142 +0,0 @@
-/**
- * Coverage for the default `child_process`-backed build runner.
- *
- * Every other test injects a fake `runner`, so the real `defaultRunner`
- * (which spawns `bun build --compile`) is never exercised. Here we drive it
- * by calling `buildBinary` WITHOUT a runner and mocking `node:child_process`
- * so `spawn` returns a fake child emitter — no real process, no real timers.
- *
- * The fake child fires its stdout/stderr/close|error listeners on a
- * microtask (queueMicrotask), which is deterministic and needs no fake clock.
- * NOTE: `mock.restore()` does NOT undo `mock.module`, and Bun shares one
- * module registry across all test files (nondeterministic order) — the
- * `afterAll` below reinstalls the real `node:child_process` so the per-test
- * spawn fakes can't leak into the sibling suite.
- */
-import { afterAll, afterEach, describe, expect, mock, test } from "bun:test";
-import { EventEmitter } from "node:events";
-import { resolve } from "node:path";
-import { SingleBinaryError, buildBinary } from "./index";
-
-// Mirror REPO_ROOT from ./index — two levels above the package root,
-// whatever the checkout or worktree happens to be named. (`tsc -b` also
-// runs this file from dist/, hence the src|dist strip.)
-const REPO_ROOT = resolve(import.meta.dir.replace(/[/\\](src|dist)$/, ""), "..", "..");
-
-// Captured before any mock.module call so afterAll can reinstall the real module.
-const realChildProcess = require("node:child_process") as typeof import("node:child_process");
-
-afterAll(() => {
-  mock.module("node:child_process", () => realChildProcess);
-});
-
-type FakeOpts = {
-  readonly stdout?: string;
-  readonly stderr?: string;
-  readonly code?: number | null;
-  readonly emitError?: Error;
-};
-
-function fakeChild(opts: FakeOpts): EventEmitter & { stdout: EventEmitter; stderr: EventEmitter } {
-  const child = new EventEmitter() as EventEmitter & {
-    stdout: EventEmitter;
-    stderr: EventEmitter;
-  };
-  child.stdout = new EventEmitter();
-  child.stderr = new EventEmitter();
-  // Emit after the caller has attached its listeners (next microtask).
-  queueMicrotask(() => {
-    if (opts.stdout) child.stdout.emit("data", Buffer.from(opts.stdout, "utf8"));
-    if (opts.stderr) child.stderr.emit("data", Buffer.from(opts.stderr, "utf8"));
-    if (opts.emitError) {
-      child.emit("error", opts.emitError);
-    } else {
-      // Emit the code verbatim — including an explicit `null` — so the
-      // `code ?? 1` branch in defaultRunner is exercised, not masked here.
-      child.emit("close", opts.code === undefined ? 0 : opts.code);
-    }
-  });
-  return child;
-}
-
-describe("defaultRunner (real child_process path, mocked spawn)", () => {
-  afterEach(() => mock.restore());
-
-  test("spawns `bun` with the compile argv and resolves on clean exit", async () => {
-    let captured: { head?: string; rest?: string[]; cwd?: string } = {};
-    mock.module("node:child_process", () => ({
-      spawn: (head: string, rest: string[], optsArg: { cwd: string }) => {
-        captured = { head, rest, cwd: optsArg.cwd };
-        return fakeChild({ stdout: "compiled ok", code: 0 });
-      },
-    }));
-
-    const result = await buildBinary({
-      target: { platform: "linux", arch: "x64" },
-      version: "9.9.9",
-      outDir: "/tmp/sbc-runner-dist",
-    });
-
-    expect(captured.head).toBe("bun");
-    expect(captured.rest).toContain("build");
-    expect(captured.rest).toContain("--compile");
-    expect(captured.rest).toContain("bun-linux-x64");
-    // cwd is REPO_ROOT (two levels above the package).
-    expect(captured.cwd).toBe(REPO_ROOT);
-    expect(result.outPath).toBe("/tmp/sbc-runner-dist/crewhaus-linux-x64-9.9.9");
-    expect(result.buildArgv[0]).toBe("bun");
-  });
-
-  test("accumulates multiple stdout/stderr chunks before close", async () => {
-    mock.module("node:child_process", () => ({
-      spawn: () => {
-        const child = new EventEmitter() as EventEmitter & {
-          stdout: EventEmitter;
-          stderr: EventEmitter;
-        };
-        child.stdout = new EventEmitter();
-        child.stderr = new EventEmitter();
-        queueMicrotask(() => {
-          child.stdout.emit("data", Buffer.from("part1-", "utf8"));
-          child.stdout.emit("data", Buffer.from("part2", "utf8"));
-          child.stderr.emit("data", Buffer.from("warn", "utf8"));
-          child.emit("close", 0);
-        });
-        return child;
-      },
-    }));
-    // exit 0 → resolves; the multi-chunk buffers exercise the data handlers.
-    const result = await buildBinary({
-      target: { platform: "macos", arch: "x64" },
-      outDir: "/tmp/sbc-runner-dist",
-    });
-    expect(result.target.platform).toBe("macos");
-  });
-
-  test("non-zero exit code surfaces stderr in a SingleBinaryError", async () => {
-    mock.module("node:child_process", () => ({
-      spawn: () => fakeChild({ stderr: "bun: compile failed", code: 7 }),
-    }));
-    await expect(
-      buildBinary({ target: { platform: "macos", arch: "arm64" }, outDir: "/tmp/sbc-runner-dist" }),
-    ).rejects.toThrow(/exited with 7: bun: compile failed/);
-  });
-
-  test("a null exit code is treated as failure (exitCode 1)", async () => {
-    mock.module("node:child_process", () => ({
-      spawn: () => fakeChild({ stderr: "killed", code: null }),
-    }));
-    await expect(
-      buildBinary({ target: { platform: "windows", arch: "x64" }, outDir: "/tmp/sbc-runner-dist" }),
-    ).rejects.toBeInstanceOf(SingleBinaryError);
-  });
-
-  test("a spawn `error` event resolves to exitCode 1 → SingleBinaryError", async () => {
-    mock.module("node:child_process", () => ({
-      spawn: () => fakeChild({ emitError: new Error("spawn ENOENT: bun not on PATH") }),
-    }));
-    await expect(
-      buildBinary({ target: { platform: "linux", arch: "arm64" }, outDir: "/tmp/sbc-runner-dist" }),
-    ).rejects.toThrow(/spawn ENOENT: bun not on PATH/);
-  });
-});