@akanjs/devkit 3.0.0-beta.18 → 3.0.0-beta.19

package/frontendBuild/frontendBuild.test.ts

@@ -333,13 +333,14 @@ describe("RoutesManifestArtifactSerializer", () => {
 describe("HmrChangeClassifier", () => {
   test("classifies code, css, config, and ignored files", () => {
     const classifier = new HmrChangeClassifier();
-    expect(classifier.classify("/repo/apps/demo/page/_index.tsx")).toBe("code");
-    expect(classifier.classify("/repo/apps/demo/page/styles.css")).toBe("css");
-    expect(classifier.classify("/repo/apps/demo/akan.config.ts")).toBe("config");
-    expect(classifier.classify("/repo/apps/demo/.DS_Store")).toBe("ignore");
-    expect(classifier.classify(`/repo/apps/demo/node_modules/pkg/index.ts`)).toBe("ignore");
-    expect(classifier.classify(`/repo/apps/demo/.akan/generated/page.tsx`)).toBe("ignore");
-    expect(classifier.classify("/repo/apps/demo/public/logo.png")).toBe("ignore");
+    const app = path.resolve("/repo/apps/demo");
+    expect(classifier.classify(path.join(app, "page/_index.tsx"))).toBe("code");
+    expect(classifier.classify(path.join(app, "page/styles.css"))).toBe("css");
+    expect(classifier.classify(path.join(app, "akan.config.ts"))).toBe("config");
+    expect(classifier.classify(path.join(app, ".DS_Store"))).toBe("ignore");
+    expect(classifier.classify(path.join(app, "node_modules/pkg/index.ts"))).toBe("ignore");
+    expect(classifier.classify(path.join(app, ".akan/generated/page.tsx"))).toBe("ignore");
+    expect(classifier.classify(path.join(app, "public/logo.png"))).toBe("ignore");
   });
 });
 
@@ -394,16 +395,16 @@ describe("DevGeneratedIndexSync", () => {
 
 describe("DevChangePlanner", () => {
   test("classifies server, client, shared, and generated barrel changes", () => {
-    const root = "/repo";
+    const root = path.resolve("/repo");
     const planner = new DevChangePlanner({ workspaceRoot: root });
-    const generatedIndex = `${root}/libs/shared/common/index.ts`;
+    const generatedIndex = path.join(root, "libs/shared/common/index.ts");
     const plan = planner.plan({
       generation: 7,
       files: [
-        `${root}/libs/shared/lib/admin/admin.service.ts`,
-        `${root}/libs/shared/lib/admin/Admin.Template.tsx`,
-        `${root}/libs/shared/lib/admin/admin.constant.ts`,
-        `${root}/libs/shared/common/foo.ts`,
+        path.join(root, "libs/shared/lib/admin/admin.service.ts"),
+        path.join(root, "libs/shared/lib/admin/Admin.Template.tsx"),
+        path.join(root, "libs/shared/lib/admin/admin.constant.ts"),
+        path.join(root, "libs/shared/common/foo.ts"),
       ],
       kinds: ["code"],
       generatedFiles: [generatedIndex],
@@ -429,21 +430,22 @@ describe("DevChangePlanner", () => {
   });
 
   test("recycles builder for macro-backed dictionary and signal metadata changes", () => {
-    const root = "/repo";
+    const root = path.resolve("/repo");
     const planner = new DevChangePlanner({ workspaceRoot: root });
+    const dictionaryFile = path.join(root, "apps/demo/lib/_demo/demo.dictionary.ts");
     const dictionaryPlan = planner.plan({
       generation: 3,
-      files: [`${root}/apps/demo/lib/_demo/demo.dictionary.ts`],
+      files: [dictionaryFile],
       kinds: ["code"],
     });
     const signalPlan = planner.plan({
       generation: 4,
-      files: [`${root}/libs/shared/lib/admin/admin.signal.ts`],
+      files: [path.join(root, "libs/shared/lib/admin/admin.signal.ts")],
       kinds: ["code"],
     });
 
     expect(dictionaryPlan.actions).toEqual(["rebuild-client", "restart-backend", "restart-builder"]);
-    expect(dictionaryPlan.reasonByFile[`${root}/apps/demo/lib/_demo/demo.dictionary.ts`]).toContain("runtime-metadata");
+    expect(dictionaryPlan.reasonByFile[dictionaryFile]).toContain("runtime-metadata");
     expect(signalPlan.actions).toContain("restart-builder");
   });
 });

package/frontendBuild/hmrWatcher.test.ts

@@ -161,7 +161,7 @@ describe("HmrWatcher", () => {
     TEST_TIMEOUT_MS,
   );
 
-  test.skipIf(process.getuid?.() === 0)(
+  test.skipIf(process.getuid?.() === 0 || process.platform === "win32")(
     "warns at startup when part of the tree cannot be read",
     async () => {
       const root = await makeRoot();

package/frontendBuild/routeClientBuilder.ts

@@ -28,6 +28,15 @@ const SSR_CLIENT_ALIAS_EXTERNALS = [
 export interface BuildRouteClientOptions {
   app: App;
   seeds: string[];
+  /**
+   * Seeds of every route, so a build that has to run at all bundles the whole app's client entries.
+   *
+   * A page loads entries first built for other routes, and entries from two `Bun.build` runs each carry
+   * their own copy of every app and lib module — one page evaluated a lib's module-scope registration
+   * twice. The whole app costs about what one route did, since every entry already imports the client
+   * barrel, and content-hashed chunk names keep unchanged chunks at the URLs the browser already holds.
+   */
+  graphSeeds?: string[];
   artifact: BaseBuildArtifact;
   knownEntries?: Set<string>;
   routeId?: string;
@@ -39,13 +48,13 @@ export interface BuildRouteClientOptions {
    * `AllRoutesBuilder` passes every route's entries at once so they share one `Bun.build`. Chunk
    * splitting is scoped to a single invocation, so a dependency reachable from entries spread across
    * several invocations is emitted once per invocation — mermaid landed in `apps/akan` four times that
-   * way. Dev keeps one build per route and leaves this unset.
+   * way. Dev passes `graphSeeds` instead, for the same reason.
    */
   entries?: string[];
 }
 
 export interface BuildRouteClientResult {
-  /** Newly-emitted manifest rows keyed by `${absEntry}#${exportName}`. */
+  /** Newly-emitted manifest rows keyed by `${absEntry}#${exportName}`, for every entry this build bundled. */
   manifestDelta: ClientManifest;
   /** Newly-emitted ssrManifest rows keyed by entry URL. */
   ssrManifestDelta: SsrManifest;
@@ -53,7 +62,7 @@ export interface BuildRouteClientResult {
   newEntries: string[];
   /** Absolute paths of all `"use client"` leaves discovered from this route's seeds. */
   discoveredEntries?: string[];
-  /** Absolute source files included in the browser bundles for new entries. */
+  /** Absolute source files included in the browser bundles for this route's bundled entries. */
   clientDeps: string[];
   /** Absolute source files included in the browser bundle, grouped by original client entry. */
   clientDepsByEntry?: Record<string, string[]>;
@@ -67,6 +76,7 @@ interface BootstrapEntries {
 export class RouteClientBuilder {
   #app: App;
   #seeds: string[];
+  #graphSeeds?: string[];
   #knownEntries: Set<string>;
   #command: "build" | "start";
   #discovery?: ClientEntryDiscovery;
@@ -75,6 +85,7 @@ export class RouteClientBuilder {
   constructor(options: BuildRouteClientOptions) {
     this.#app = options.app;
     this.#seeds = options.seeds;
+    this.#graphSeeds = options.graphSeeds;
     this.#knownEntries = options.knownEntries ?? new Set<string>();
     this.#command = options.command ?? "start";
     this.#discovery = options.discovery;
@@ -82,17 +93,18 @@ export class RouteClientBuilder {
   }
 
   async build(): Promise<BuildRouteClientResult> {
-    const discovered =
-      this.#entries ??
-      (await (this.#discovery ?? (await GraphClientEntryDiscovery.create(this.#app))).discover(this.#seeds));
-    const entries = discovered.filter((e) => !this.#knownEntries.has(e));
-    if (entries.length === 0) return this.#emptyResult(discovered);
+    const discovered = this.#entries ?? (await (await this.#getDiscovery()).discover(this.#seeds));
+    if (discovered.every((e) => this.#knownEntries.has(e))) return this.#emptyResult(discovered);
+    const entries = this.#graphSeeds
+      ? [...new Set([...discovered, ...(await (await this.#getDiscovery()).discover(this.#graphSeeds))])].sort()
+      : discovered.filter((e) => !this.#knownEntries.has(e));
 
     const bootstrapEntries = await this.#createBootstrapEntries(entries);
     const browserBundle = await this.#buildBrowserBundle(bootstrapEntries);
     const ssrBundle = await this.#buildSsrBundle(bootstrapEntries);
 
     const acceptedEntries = new Set(entries);
+    const routeEntries = new Set(discovered);
     const manifestDelta: ClientManifest = {};
     const ssrModuleMap: SsrManifest["moduleMap"] = {};
     const clientDeps = new Set<string>();
@@ -122,19 +134,24 @@ export class RouteClientBuilder {
       for (const dep of browserBundle.entryDepsByAbsPath.get(buildEntry) ?? []) deps.add(path.resolve(dep));
       const sortedDeps = [...deps].sort();
       clientDepsByEntry[originalEntry] = sortedDeps;
-      for (const dep of sortedDeps) clientDeps.add(dep);
+      if (routeEntries.has(originalEntry)) for (const dep of sortedDeps) clientDeps.add(dep);
     }
 
     return {
       manifestDelta,
       ssrManifestDelta: { moduleLoading: null, moduleMap: ssrModuleMap },
-      newEntries: entries,
+      newEntries: entries.filter((e) => !this.#knownEntries.has(e)),
       discoveredEntries: discovered,
       clientDeps: [...clientDeps].sort(),
       clientDepsByEntry,
     };
   }
 
+  async #getDiscovery(): Promise<ClientEntryDiscovery> {
+    this.#discovery ??= await GraphClientEntryDiscovery.create(this.#app);
+    return this.#discovery;
+  }
+
   #emptyResult(discoveredEntries: string[] = []): BuildRouteClientResult {
     return {
       manifestDelta: {},

package/frontendBuild/sourceMtimeIndex.test.ts

@@ -249,11 +249,12 @@ describe("SourceMtimeIndex", () => {
   describe("a directory it cannot read", () => {
     /**
      * `chmod 000` does not stop root, so these would assert the opposite of what they mean when the suite
-     * runs as root (CI containers commonly do).
+     * runs as root (CI containers commonly do). On Windows it only sets the read-only attribute, which leaves
+     * a directory listable.
      */
-    const asRoot = process.getuid?.() === 0;
+    const cannotLock = process.getuid?.() === 0 || process.platform === "win32";
 
-    test.skipIf(asRoot)("is reported as a gap instead of silently skipped", async () => {
+    test.skipIf(cannotLock)("is reported as a gap instead of silently skipped", async () => {
       const root = await makeRoot();
       await seed(root, "open/a.ts");
       const hidden = await seed(root, "locked/b.ts");
@@ -269,7 +270,7 @@ describe("SourceMtimeIndex", () => {
       expect(index.coverageGaps).toEqual([{ path: path.dirname(hidden), code: "EACCES" }]);
     });
 
-    test.skipIf(asRoot)("becomes visible again once it is readable, and clears the gap", async () => {
+    test.skipIf(cannotLock)("becomes visible again once it is readable, and clears the gap", async () => {
       const root = await makeRoot();
       const hidden = await seed(root, "locked/b.ts");
       const locked = path.dirname(hidden);
@@ -287,7 +288,7 @@ describe("SourceMtimeIndex", () => {
       expect(await index.collectChanges()).toEqual([hidden]);
     });
 
-    test.skipIf(asRoot)("does not report the files under it as deleted while it is unreadable", async () => {
+    test.skipIf(cannotLock)("does not report the files under it as deleted while it is unreadable", async () => {
       const root = await makeRoot();
       const abs = await seed(root, "locked/b.ts");
       const locked = path.dirname(abs);

package/getDirname.test.ts

@@ -1,12 +1,14 @@
 import { describe, expect, test } from "bun:test";
 import path from "node:path";
+import { pathToFileURL } from "node:url";
 import { getDirname } from "./getDirname";
 
 describe("getDirname", () => {
   test("converts file URLs to filesystem paths", () => {
-    const dirname = getDirname("file:///tmp/akan%20workspace/index.ts");
+    const filePath = path.resolve("/tmp/akan workspace/index.ts");
+    const dirname = getDirname(pathToFileURL(filePath).href);
 
-    expect(dirname).toBe(path.join("/tmp", "akan workspace"));
+    expect(dirname).toBe(path.dirname(filePath));
   });
 
   test("keeps Windows drive paths valid when running on Windows", () => {

package/incrementalBuilder/devWatchBatch.test.ts

@@ -1,12 +1,13 @@
 import { describe, expect, test } from "bun:test";
+import path from "node:path";
 import { DevChangePlanner } from "../frontendBuild";
 import { prepareDevWatchBatch } from "./devWatchBatch";
 
 describe("prepareDevWatchBatch", () => {
   test("includes generated indexes in the same invalidate generation", () => {
-    const root = "/repo";
-    const changedFile = `${root}/libs/shared/common/foo.ts`;
-    const generatedIndex = `${root}/libs/shared/common/index.ts`;
+    const root = path.resolve("/repo");
+    const changedFile = path.join(root, "libs/shared/common/foo.ts");
+    const generatedIndex = path.join(root, "libs/shared/common/index.ts");
     const prepared = prepareDevWatchBatch({
       generation: 12,
       batch: { files: [changedFile], kinds: new Set(["code"]) },
@@ -25,9 +26,9 @@ describe("prepareDevWatchBatch", () => {
   test.each(["common", "srvkit", "ui", "webkit"])(
     "keeps %s facet add/delete generated index in the same generation",
     (facet) => {
-      const root = "/repo";
-      const changedFile = `${root}/libs/shared/${facet}/tmpExample.ts`;
-      const generatedIndex = `${root}/libs/shared/${facet}/index.ts`;
+      const root = path.resolve("/repo");
+      const changedFile = path.join(root, "libs/shared", facet, "tmpExample.ts");
+      const generatedIndex = path.join(root, "libs/shared", facet, "index.ts");
       const prepared = prepareDevWatchBatch({
         generation: 20,
         batch: { files: [changedFile], kinds: new Set(["code"]) },

package/incrementalBuilder/incrementalBuilder.proc.ts

@@ -100,6 +100,7 @@ class IncrementalBuilder {
         app: this.#app,
         routeId: msg.routeId,
         seeds: msg.seeds,
+        graphSeeds: msg.graphSeeds,
         artifact: this.#artifact,
         knownEntries: new Set<string>(msg.knownEntries),
         discovery: this.#discovery,

package/integration/devStabilityHarness.test.ts

@@ -42,8 +42,13 @@ describe("dev stability harness port allocation", () => {
 
     expect(new Set(ports).size).toBe(ports.length);
     // Forward-only, so a harness cannot be handed a port a previous host in this process may still be
-    // holding while it shuts down — which is the collision the random offset kept producing.
-    expect(ports).toEqual([...ports].sort((a, b) => a - b));
+    // holding while it shuts down — which is the collision the random offset kept producing. The cursor starts
+    // at a pid-seeded slot and wraps at the end of the band, so forward is measured around the band, and a step
+    // back would read as most of a lap.
+    const band = DevStabilityHarness.portOffsetMax - DevStabilityHarness.portOffsetMin;
+    const steps = ports.slice(1).map((port, idx) => (port - ports[idx] + band) % band);
+    expect(steps.every((step) => step > 0 && step % DevStabilityHarness.portOffsetStride === 0)).toBe(true);
+    expect(steps.reduce((sum, step) => sum + step, 0)).toBeLessThan(band);
   });
 
   test("returns the same port on every call instead of re-deriving it", async () => {

package/lint/gritRules.test.ts

@@ -4,6 +4,7 @@ import { existsSync } from "node:fs";
 import { mkdir, mkdtemp, readdir, readFile, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { Linter } from "../linter";
 
 /**
  * Fixture tests for the GritQL plugins in this folder.
@@ -21,7 +22,7 @@ import path from "node:path";
 const lintDir = import.meta.dir;
 const fixturesDir = path.join(lintDir, "__fixtures__");
 const workspaceRoot = path.resolve(lintDir, "../../../..");
-const biomeBin = path.join(workspaceRoot, "node_modules/.bin/biome");
+const biomeBin = path.join(workspaceRoot, "node_modules", ".bin", Linter.biomeBinName);
 
 interface BiomeDiagnostic {
   severity: string;

package/lint/no-deep-internal-import.grit

@@ -15,7 +15,7 @@ or {
   JsModuleSource() as $source where {
     $source <: within JsImport(),
     not $filename <: r".*\.(?:test|spec)\.tsx?",
-    $filename <: r".*(?:apps|libs)/[^/]+/lib/[^/]+/[^/]+\.(?:ts|tsx)",
+    $filename <: r".*(?:apps|libs)[/\\][^/\\]+[/\\]lib[/\\][^/\\]+[/\\][^/\\]+\.(?:ts|tsx)",
     $source <: r"\"\.\./\.\./.*\"",
     register_diagnostic(
       span = $source,
@@ -25,7 +25,7 @@ or {
   JsModuleSource() as $source where {
     $source <: within JsImport(),
     not $filename <: r".*\.(?:test|spec)\.tsx?",
-    $filename <: r".*/lib/.+\.tsx",
+    $filename <: r".*[/\\]lib[/\\].+\.tsx",
     $source <: r"\"\.\./.*\"",
     register_diagnostic(
       span = $source,

package/lint/no-redeclare-predefined-endpoint.grit

@@ -14,7 +14,8 @@ language js(typescript, jsx)
     $base <: contains `endpoint`,
     $className <: r"([A-Z][a-zA-Z0-9]*)Endpoint"($Cap)
   },
-  $filename <: r".*/([a-z][a-zA-Z0-9]*)\.signal\.ts"($model),
+  // `$filename` carries backslashes on Windows, so a separator here must accept both.
+  $filename <: r".*[/\\]([a-z][a-zA-Z0-9]*)\.signal\.ts"($model),
   or {
     $key <: $model,
     $key <: r"(?:light|create|update|remove|view|edit|merge)([A-Z][a-zA-Z0-9]*)"($keyCap) where {

package/linter.ts

@@ -112,6 +112,9 @@ const asBiomeReport = (candidate: string): BiomeReport | null => {
 const BIOME_CONFIG_FILES = ["biome.json", "biome.jsonc"] as const;
 
 export class Linter {
+  //? Bun links a package bin as `<name>.exe` (plus a `.bunx` stub) on Windows, and a bare `<name>` elsewhere.
+  static readonly biomeBinName = process.platform === "win32" ? "biome.exe" : "biome";
+
   lintRoot: string;
   configPath: string;
   #biomeBin: string;
@@ -119,7 +122,7 @@ export class Linter {
   constructor(cwdPath: string) {
     this.lintRoot = this.#findBiomeRootPath(cwdPath);
     this.configPath = Linter.#configPathIn(this.lintRoot) ?? path.join(this.lintRoot, "biome.json");
-    const localBiomeBin = path.join(this.lintRoot, "node_modules/.bin/biome");
+    const localBiomeBin = path.join(this.lintRoot, "node_modules", ".bin", Linter.biomeBinName);
     this.#biomeBin = existsSync(localBiomeBin) ? localBiomeBin : "biome";
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/devkit",
-  "version": "3.0.0-beta.18",
+  "version": "3.0.0-beta.19",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {
@@ -48,7 +48,7 @@
     "@inquirer/prompts": "^8.4.3",
     "@tailwindcss/node": "^4.3.0",
     "@trapezedev/project": "^7.1.4",
-    "akanjs": "3.0.0-beta.18",
+    "akanjs": "3.0.0-beta.19",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "dayjs": "^1.11.20",

package/platformTest/BunTestReport.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, test } from "bun:test";
+import { BunTestReport } from "./BunTestReport";
+
+describe("BunTestReport", () => {
+  test("reads the final summary and attributes each failure to the file header above it", () => {
+    const report = new BunTestReport(
+      [
+        "bun test v1.4.2 (744846f84)",
+        "",
+        "server\\artifact\\routeSeedIndex.test.ts:",
+        "(pass) route seed index > keeps seeds [0.40ms]",
+        "(fail) route seed index > restores relative seed paths [1.20ms]",
+        "",
+        "lib/linter.test.ts:",
+        "\u001b[31m(fail) Linter > finds biome [3.00ms]\u001b[0m",
+        "",
+        "2 tests failed:",
+        "(fail) route seed index > restores relative seed paths [1.20ms]",
+        "(fail) Linter > finds biome [3.00ms]",
+        "",
+        " 1 pass",
+        " 3 skip",
+        " 2 fail",
+        " 1 error",
+        "Ran 6 tests across 2 files. [120.00ms]",
+      ].join("\r\n"),
+    );
+
+    expect(report.hasSummary).toBe(true);
+    expect([report.pass, report.fail, report.skip, report.errors, report.files]).toEqual([1, 2, 3, 1, 2]);
+    expect(report.failures).toEqual([
+      { file: "server/artifact/routeSeedIndex.test.ts", name: "route seed index > restores relative seed paths" },
+      { file: "lib/linter.test.ts", name: "Linter > finds biome" },
+    ]);
+    expect(report.passed).toBe(false);
+  });
+
+  test("a run with no summary is not passed, and counts what it saw before it stopped", () => {
+    const report = new BunTestReport(
+      [
+        "server/akanApp.test.ts:",
+        "(pass) AkanApp > boots [1ms]",
+        "(pass) AkanApp > relays [2ms]",
+        "panic(main thread)",
+      ].join("\n"),
+    );
+
+    expect(report.hasSummary).toBe(false);
+    expect(report.passed).toBe(false);
+    expect(report.pass).toBe(2);
+    expect(report.lastFile).toBe("server/akanApp.test.ts");
+  });
+
+  test("a clean summary passes", () => {
+    const report = new BunTestReport(" 4 pass\n 0 fail\nRan 4 tests across 1 file. [12.00ms]\n");
+
+    expect(report.passed).toBe(true);
+    expect(report.files).toBe(1);
+  });
+});

package/platformTest/BunTestReport.ts

@@ -0,0 +1,65 @@
+import { stripVTControlCharacters } from "node:util";
+
+export interface BunTestFailure {
+  file: string | null;
+  name: string;
+}
+
+export class BunTestReport {
+  static readonly #fileHeaderPattern = /^(\S+\.(?:test|spec)\.[cm]?[jt]sx?):$/;
+  //? After the last file, bun repeats every failure under an "N tests failed:" line — those belong to no header.
+  static readonly #relistPattern = /^\d+ tests? failed:$/;
+  static readonly #durationSuffix = /\s+\[[\d.]+m?s\]$/;
+
+  readonly pass: number;
+  readonly fail: number;
+  readonly skip: number;
+  readonly errors: number;
+  readonly files: number;
+  readonly hasSummary: boolean;
+  readonly failures: BunTestFailure[];
+  readonly lastFile: string | null;
+
+  constructor(output: string) {
+    const lines = stripVTControlCharacters(output).split(/\r?\n/);
+    let currentFile: string | null = null;
+    let lastFile: string | null = null;
+    let relisted = false;
+    const failures = new Map<string, BunTestFailure>();
+    for (const line of lines) {
+      if (BunTestReport.#relistPattern.test(line)) relisted = true;
+      const header = BunTestReport.#fileHeaderPattern.exec(line);
+      if (header?.[1] && !relisted) {
+        currentFile = header[1].replaceAll("\\", "/");
+        lastFile = currentFile;
+        continue;
+      }
+      if (!line.startsWith("(fail) ")) continue;
+      const name = line.slice("(fail) ".length).replace(BunTestReport.#durationSuffix, "");
+      if (!failures.has(name)) failures.set(name, { file: relisted ? null : currentFile, name });
+    }
+    const ran = lines.findLast((line) => /^Ran \d+ tests? across \d+ files?/.test(line));
+    this.hasSummary = !!ran;
+    this.files = ran ? Number(/across (\d+) files?/.exec(ran)?.[1] ?? 0) : 0;
+    this.failures = [...failures.values()];
+    this.lastFile = lastFile;
+    this.pass = ran
+      ? BunTestReport.#lastCount(lines, /^\s*(\d+) pass$/)
+      : lines.filter((line) => line.startsWith("(pass) ")).length;
+    this.fail = ran ? BunTestReport.#lastCount(lines, /^\s*(\d+) fail$/) : this.failures.length;
+    this.skip = ran ? BunTestReport.#lastCount(lines, /^\s*(\d+) skip$/) : 0;
+    this.errors = ran ? BunTestReport.#lastCount(lines, /^\s*(\d+) errors?$/) : 0;
+  }
+
+  get passed() {
+    return this.hasSummary && this.fail === 0 && this.errors === 0;
+  }
+
+  static #lastCount(lines: string[], pattern: RegExp) {
+    for (const line of lines.toReversed()) {
+      const count = pattern.exec(line)?.[1];
+      if (count) return Number(count);
+    }
+    return 0;
+  }
+}

package/platformTest/IdleWatchedProcess.test.ts

@@ -0,0 +1,64 @@
+import { afterAll, describe, expect, test } from "bun:test";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { IdleWatchedProcess } from "./IdleWatchedProcess";
+
+const roots: string[] = [];
+const makeLogPath = async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "akan-idle-watch-"));
+  roots.push(root);
+  return path.join(root, "nested", "run.log");
+};
+
+afterAll(async () => {
+  await Promise.all(roots.map((root) => rm(root, { recursive: true, force: true })));
+});
+
+describe("IdleWatchedProcess", () => {
+  test("tees the output of a command that finishes into the log and reports its exit code", async () => {
+    const logPath = await makeLogPath();
+    const result = await new IdleWatchedProcess(
+      [process.execPath, "--eval", "console.log('out'); console.error('err'); process.exit(3)"],
+      { logPath, idleMs: 10_000 },
+    ).run();
+
+    expect(result.exitCode).toBe(3);
+    expect(result.hung).toBe(false);
+    expect(result.output).toContain("out");
+    expect(result.output).toContain("err");
+    expect(await readFile(logPath, "utf8")).toContain("out");
+  });
+
+  test("gives up on a command that goes quiet, after asking the caller to clean up", async () => {
+    const logPath = await makeLogPath();
+    let cleanedUp = false;
+    const result = await new IdleWatchedProcess(
+      [process.execPath, "--eval", "console.log('started'); setInterval(() => {}, 1000)"],
+      {
+        logPath,
+        idleMs: 400,
+        onIdle: async () => {
+          cleanedUp = true;
+        },
+      },
+    ).run();
+
+    expect(result.hung).toBe(true);
+    expect(result.exitCode).toBeNull();
+    expect(cleanedUp).toBe(true);
+    expect(result.output).toContain("started");
+  });
+
+  test("a command that keeps talking is not idle, but still stops at the total budget", async () => {
+    const logPath = await makeLogPath();
+    const result = await new IdleWatchedProcess(
+      [process.execPath, "--eval", "setInterval(() => console.log('tick'), 50)"],
+      { logPath, idleMs: 5_000, totalMs: 500 },
+    ).run();
+
+    expect(result.hung).toBe(false);
+    expect(result.timedOut).toBe(true);
+    expect(result.exitCode).toBeNull();
+  });
+});

package/platformTest/IdleWatchedProcess.ts

@@ -0,0 +1,77 @@
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+
+export interface IdleWatchedResult {
+  exitCode: number | null;
+  hung: boolean;
+  timedOut: boolean;
+  output: string;
+  ms: number;
+}
+
+interface IdleWatchedOptions {
+  logPath: string;
+  idleMs: number;
+  totalMs?: number;
+  cwd?: string;
+  env?: Record<string, string | undefined>;
+  onIdle?: () => Promise<void>;
+  onOutput?: (text: string) => void;
+}
+
+/**
+ * Runs a command with its output teed into a log, and gives up on it once the output goes quiet.
+ * Silence is the only reliable hang signal: a runner stuck in a synchronous loop (Bun 1.4.2's Windows
+ * websocket crash spun at 100% CPU) never lets bun's own per-test timeout fire.
+ */
+export class IdleWatchedProcess {
+  readonly #command: string[];
+  readonly #options: IdleWatchedOptions;
+
+  constructor(command: string[], options: IdleWatchedOptions) {
+    this.#command = command;
+    this.#options = options;
+  }
+
+  async run(): Promise<IdleWatchedResult> {
+    const { logPath, idleMs, totalMs, cwd, env, onIdle, onOutput } = this.#options;
+    await mkdir(path.dirname(logPath), { recursive: true });
+    const log = Bun.file(logPath).writer();
+    const startedAt = performance.now();
+    let lastOutputAt = startedAt;
+    let output = "";
+    let hung = false;
+    let timedOut = false;
+    const proc = Bun.spawn(this.#command, { cwd, env, stdin: "ignore", stdout: "pipe", stderr: "pipe" });
+    const pump = async (stream: ReadableStream<Uint8Array>) => {
+      const decoder = new TextDecoder();
+      for await (const chunk of stream) {
+        lastOutputAt = performance.now();
+        const text = decoder.decode(chunk, { stream: true });
+        output += text;
+        log.write(chunk);
+        onOutput?.(text);
+      }
+    };
+    const pumping = Promise.all([pump(proc.stdout), pump(proc.stderr)]);
+    const watch = setInterval(
+      () => {
+        const now = performance.now();
+        if (now - lastOutputAt >= idleMs) hung = true;
+        else if (totalMs !== undefined && now - startedAt >= totalMs) timedOut = true;
+        else return;
+        clearInterval(watch);
+        void (async () => {
+          await onIdle?.().catch(() => undefined);
+          proc.kill();
+        })();
+      },
+      Math.max(50, Math.min(1000, idleMs / 4)),
+    );
+    const exitCode = await proc.exited;
+    clearInterval(watch);
+    await pumping;
+    await log.end();
+    return { exitCode: hung || timedOut ? null : exitCode, hung, timedOut, output, ms: performance.now() - startedAt };
+  }
+}