brittle-jobs 0.1.2 → 0.2.0

package/README.md

@@ -1,6 +1,10 @@
 # brittle-jobs
 
-Run [brittle](https://github.com/holepunchto/brittle) test files concurrently, one process per file, on Node or Bare.
+Run [brittle](https://github.com/holepunchto/brittle) test files concurrently, one isolated process per file.
+
+- A hung file costs one file, not the run: idle and hard timeouts kill the whole process group, grandchildren included.
+- Every file gets its own `TMPDIR`, wiped by the runner on exit or kill, so leaked tmp data cannot starve the disk.
+- Pool size is not tied to core count. Test files are mostly wait-bound, so the default oversubscribes.
 
 ## Installation
 
@@ -8,97 +12,65 @@ Run [brittle](https://github.com/holepunchto/brittle) test files concurrently, o
 npm install --save-dev brittle-jobs
 ```
 
-`brittle` is a peer dependency: the consumer's install is what runs each file.
+The runner needs Node >= 22. Test files run on `bare` by default, or on anything passed to `--runtime`.
 
 ## Usage
 
 ```bash
-brittle-jobs test/*.js
-brittle-jobs --bare -j 4 test/all.ts
+brittle-jobs                          # test/*.{js,ts,mjs}, minus all.*
+brittle-jobs 'test/**/*.ts' --jobs 8
+brittle-jobs test/*.js --runtime node
 ```
 
 ```
-brittle-jobs [flags] <files...>
-
-  --bare              run test files with bare instead of node
-  --jobs|-j <n>       concurrent test-file workers (positive integer; default: available CPU parallelism)
-  --bail|-b           bail on first assert failure and stop scheduling files
-  --timeout|-t <ms>   per-test timeout passed to brittle
-
-  BRITTLE_JOBS=<n>    concurrent test-file workers, overridden by --jobs
+brittle-jobs [globs|files...] [flags]
+
+  -j, --jobs N          concurrent processes (default BRITTLE_JOBS or 2 x cores)
+  -t, --timeout MS      hard cap per file (default 300000)
+      --idle-timeout MS kill file after this long without output (default 120000)
+      --retries N       rerun failed files, pass on retry = FLAKY (default 0)
+      --min-free-mb N   wait for free disk on tmp root before spawning (default 1024)
+      --shard i/n       run the i-th of n slices
+      --runtime CMD     child command (default bare)
+  -b, --bail            stop on first failure
 ```
 
-Each file runs as `<node|bare> brittle/cmd.js [--bail] [--timeout ms] <file>`, exactly what
-`brittle-node`/`brittle-bare` do, so per-file semantics are unchanged. On `--bare` the binary comes
-from the project's own `bare-runtime` install, not from `PATH`: a global `bare` is often an older
-version, and `node_modules/.bin/bare` is a Node process whose only job is to spawn the real binary.
-`PATH` is used only when `bare-runtime` is not installed.
+Each file runs as `<runtime> <file>`; a brittle test file runs itself. `bare` resolves from the project's own
+`bare-runtime` install, then from `PATH`.
 
-Output is one line per file as it finishes, the full spec-formatted TAP for any file that fails, and a
-summary. On a TTY a progress line names the files in flight so a long file cannot look like a hang.
-Exit code is 1 when any file fails its TAP or exits non-zero.
+Output is one line per file as it finishes, the full output of any file that fails, the ten slowest files, and a
+summary. Exit code is 1 when any file fails or hangs.
 
 ```
-200 files · bare · jobs=10
+[98/99] PASS (3.5s) test/harness.ts
+[99/99] HUNG (120.4s) test/exec.ts: no output for 120000ms, last seen "python create package table"
 
-✓ test/basic/chat.ts · 12 tests · 3.2s
-✗ test/basic/boot.ts · 4.1s
-    ...
-198/200 files passed · 1840 tests · 61.3s
-failed: test/basic/boot.ts, test/api/mesh.ts
+98 pass, 0 flaky, 0 fail, 1 hung of 99 in 120.4s
 ```
 
-### Runner files
+A `HUNG` report includes the process tree of the file at the moment it was killed. On GitHub Actions, failures emit
+`::error file=...::` annotations and their output is grouped.
 
-A generated runner containing only the declarative wrapper emitted by `brittle-make-test` is expanded
-into the files it loads instead of being run as one process. A line prefixed with `if (isBare)` is
-skipped when running on node:
+### Isolation
 
-```js
-const isBare = typeof Bare !== 'undefined'
+- `TMPDIR`, `TMP`, `TEMP` point at a per-file directory under `os.tmpdir()/brittle-jobs-<cwd hash>`. It is removed
+  when the file ends, however it ends. A stale root from a killed runner is removed at startup.
+- `BRITTLE_JOBS_WORKER_ID` and `JEST_WORKER_ID` hold the pool slot (`1..jobs`), for namespacing ports or databases.
+- Files start largest first. `--shard i/n` takes every n-th file of that order, so heavy files spread across shards.
 
-await test.load(import.meta.resolve('./basic/chat.ts'))
-if (isBare) await test.load(import.meta.resolve('./tui/keys.ts'))
-```
+### Limits
 
-The runner file stays a valid brittle entrypoint, so `bare test/all.ts` still works serially. A file
-with setup, inline tests, comments, unsupported guards, or other unrecognized source runs as one
-process so its behavior stays intact. A runner with no applicable loads also runs as one process; a
-file that emits incomplete or no TAP counts as failed.
+- POSIX only: process groups are not available on Windows.
+- A grandchild that calls `setsid` escapes the group kill.
+- Two concurrent runs from the same working directory share a tmp root and wipe each other.
 
-### Scheduling
-
-`--jobs` sets the number of concurrent test-file workers. The default is exactly the host's available
-CPU parallelism. `BRITTLE_JOBS` sets the worker count for CI without changing the command line, and
-`--jobs` overrides both; either setting may be higher than the host CPU count. For example:
-
-```bash
-brittle-jobs --bare --jobs=16 test/*.js
-BRITTLE_JOBS=16 brittle-jobs --bare test/*.js
-```
-
-Each run records how long every file took in `node_modules/.cache/brittle-jobs.json`, and the next run
-starts the slowest files first, with never-seen files ahead of them. This only matters once a single
-file takes longer than the rest of the suite divided by `--jobs`; below that the queue is packed
-either way. `--bail` keeps the given order instead, so the first file listed is the first one to fail.
-
-## API
-
-```js
-const run = require('brittle-jobs')
-
-const { passed, failed, results } = await run(['test/all.ts'], {
-  bare: false,
-  jobs: 4,
-  bail: false,
-  timeout: 30000,
-  cwd: process.cwd(),
-  out: process.stdout
-})
-```
+## Migrating from 0.1
 
-`results` holds one entry per file: `{ file, results, code, signal, stderr, failed, ms }`, where
-`results` is a [prettytap](https://www.npmjs.com/package/prettytap) `Results`.
+- The runner is a CLI only; the `require('brittle-jobs')` API is gone.
+- Default runtime is `bare`. `--bare` is accepted and ignored; use `--runtime node` for Node.
+- Generated `all.*` runner files are skipped, not expanded. Pass the test files or a glob.
+- `--timeout` is now a per-file cap enforced by the runner, not brittle's per-test timeout.
+- No timing cache; files are ordered by size.
 
 ## License
 

package/bin.js

@@ -1,55 +1,266 @@
 #!/usr/bin/env node
-const process = require('process')
-const paparam = require('paparam')
-const run = require('./index')
-
-const cmd = paparam
-  .command(
-    'brittle-jobs',
-    paparam.flag('--bare', 'Run test files with bare instead of node'),
-    paparam.flag(
-      '--jobs|-j <n>',
-      'Concurrent test-file workers (default: available CPU parallelism)'
-    ),
-    paparam.flag('--bail|-b', 'Bail on first assert failure and stop scheduling files'),
-    paparam.flag('--timeout|-t <ms>', 'Per-test timeout passed to brittle'),
-    paparam.rest('<files>'),
-    paparam.bail((bail) => {
-      console.error(bail.reason)
-      console.error(bail.command.usage())
-      process.exit(1)
-    })
+import { spawn, execFileSync } from 'child_process'
+import crypto from 'crypto'
+import fs from 'fs'
+import os from 'os'
+import path from 'path'
+import { createRequire } from 'module'
+import { parseArgs } from 'util'
+
+const { values: opts, positionals } = parseArgs({
+  allowPositionals: true,
+  options: {
+    jobs: { type: 'string', short: 'j' },
+    timeout: { type: 'string', short: 't', default: '300000' },
+    'idle-timeout': { type: 'string', default: '120000' },
+    retries: { type: 'string', default: '0' },
+    'min-free-mb': { type: 'string', default: '1024' },
+    shard: { type: 'string' },
+    runtime: { type: 'string' },
+    bail: { type: 'boolean', short: 'b', default: false },
+    bare: { type: 'boolean', default: false },
+    help: { type: 'boolean', short: 'h', default: false }
+  }
+})
+
+if (opts.help) {
+  console.log(`brittle-jobs [globs|files...] [flags]
+
+  -j, --jobs N          concurrent processes (default BRITTLE_JOBS or 2 x cores)
+  -t, --timeout MS      hard cap per file (default 300000)
+      --idle-timeout MS kill file after this long without output (default 120000)
+      --retries N       rerun failed files, pass on retry = FLAKY (default 0)
+      --min-free-mb N   wait for free disk on tmp root before spawning (default 1024)
+      --shard i/n       run the i-th of n slices
+      --runtime CMD     child command (default bare)
+  -b, --bail            stop on first failure`)
+  process.exit(0)
+}
+
+const GRACE_MS = 2000
+const jobs = Math.max(
+  1,
+  Number(opts.jobs || process.env.BRITTLE_JOBS) || 2 * os.availableParallelism()
+)
+const timeoutMs = Number(opts.timeout)
+const idleMs = Number(opts['idle-timeout'])
+const retries = Number(opts.retries)
+const minFree = Number(opts['min-free-mb']) * 1024 * 1024
+const gha = !!process.env.GITHUB_ACTIONS
+const [runtime, ...runtimeArgs] = (opts.runtime || defaultRuntime()).split(' ')
+
+function defaultRuntime() {
+  try {
+    return createRequire(path.join(process.cwd(), 'package.json'))('bare-runtime')()
+  } catch {
+    return 'bare'
+  }
+}
+
+let files = [
+  ...new Set(
+    fs
+      .globSync(positionals.length ? positionals : ['test/*.{js,ts,mjs}'])
+      .filter((f) => !/^all\./.test(path.basename(f)) && fs.statSync(f).isFile())
   )
-  .parse()
+]
+  .map((f) => ({ f, size: fs.statSync(f).size }))
+  .sort((a, b) => b.size - a.size || a.f.localeCompare(b.f))
+  .map((x) => x.f)
+
+if (opts.shard) {
+  const [i, n] = opts.shard.split('/').map(Number)
+  if (!(i >= 1 && i <= n)) die(`bad --shard ${opts.shard}`)
+  files = files.filter((_, k) => k % n === i - 1)
+}
+if (files.length === 0) die('no test files matched')
+
+// ponytail: tmp root keyed by cwd, two concurrent runs in one cwd wipe each other. Key by pid if that happens.
+const cwdHash = crypto.createHash('sha1').update(process.cwd()).digest('hex').slice(0, 8)
+const tmpRoot = path.join(fs.realpathSync(os.tmpdir()), `brittle-jobs-${cwdHash}`)
+fs.rmSync(tmpRoot, { recursive: true, force: true })
+fs.mkdirSync(tmpRoot, { recursive: true })
+
+const active = new Set()
+const results = []
+let waiters = []
+let stop = false
 
-if (!cmd) process.exit(0)
-if (cmd.rest.length === 0) {
-  console.error('Error: No test files were specified')
-  process.exit(1)
+function die(msg) {
+  console.error(`brittle-jobs: ${msg}`)
+  process.exit(2)
 }
 
-const { bare, jobs, bail, timeout } = cmd.flags
-let parsedJobs
-if (jobs !== undefined) {
-  parsedJobs = Number(jobs)
+function killGroup(pid, sig) {
   try {
-    run.validateJobs(parsedJobs)
+    process.kill(-pid, sig)
+  } catch {}
+}
+
+function processTree(pgid) {
+  try {
+    const rows = execFileSync('ps', ['-eo', 'pid,ppid,pgid,etime,command'], {
+      encoding: 'utf8'
+    }).split('\n')
+    return [rows[0], ...rows.filter((r) => r.trim().split(/\s+/)[2] === String(pgid))].join('\n')
   } catch {
-    console.error(`Error: --jobs must be a positive safe integer`)
-    process.exit(1)
+    return ''
   }
 }
 
-run(cmd.rest, {
-  bare,
-  bail,
-  jobs: parsedJobs,
-  timeout: timeout ? Number(timeout) : undefined
-})
-  .then(({ failed }) => {
-    if (failed && !process.exitCode) process.exitCode = 1
+function shutdown(code) {
+  stop = true
+  for (const pid of active) killGroup(pid, 'SIGKILL')
+  fs.rmSync(tmpRoot, { recursive: true, force: true })
+  process.exit(code)
+}
+process.on('SIGINT', () => shutdown(130))
+process.on('SIGTERM', () => shutdown(143))
+
+async function diskGate() {
+  while (fs.statfsSync(tmpRoot).bavail * fs.statfsSync(tmpRoot).bsize < minFree) {
+    if (active.size === 0) {
+      console.error(
+        `brittle-jobs: free disk on ${tmpRoot} below ${opts['min-free-mb']} MB with nothing running`
+      )
+      shutdown(2)
+    }
+    await new Promise((resolve) => waiters.push(resolve))
+  }
+}
+
+function runOnce(file, slot) {
+  return new Promise((resolve) => {
+    const tmp = fs.mkdtempSync(path.join(tmpRoot, 'bb-'))
+    const started = Date.now()
+    const child = spawn(runtime, [...runtimeArgs, file], {
+      detached: true,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: {
+        ...process.env,
+        TMPDIR: tmp,
+        TMP: tmp,
+        TEMP: tmp,
+        BRITTLE_JOBS_WORKER_ID: String(slot),
+        JEST_WORKER_ID: String(slot)
+      }
+    })
+    const pid = child.pid
+    if (pid) active.add(pid)
+
+    let output = ''
+    let lastTest = ''
+    let hung = ''
+    let idleTimer
+
+    const hang = (why) => {
+      if (hung) return
+      hung = why
+      output += `\n--- process tree at kill ---\n${processTree(pid)}\n`
+      killGroup(pid, 'SIGTERM')
+      setTimeout(() => killGroup(pid, 'SIGKILL'), GRACE_MS)
+    }
+    const hardTimer = setTimeout(() => hang(`timeout ${timeoutMs}ms`), timeoutMs)
+    const touch = () => {
+      clearTimeout(idleTimer)
+      idleTimer = setTimeout(() => hang(`no output for ${idleMs}ms`), idleMs)
+    }
+    const ondata = (chunk) => {
+      const text = String(chunk)
+      output += text
+      for (const line of text.split('\n')) {
+        const m = line.match(/^\s*(?:# |(?:not )?ok \d+ - )(.+)/)
+        if (m) lastTest = m[1].replace(/ # time.*$/, '')
+      }
+      touch()
+    }
+    child.stdout.on('data', ondata)
+    child.stderr.on('data', ondata)
+    touch()
+
+    let exit = null
+    const finish = () => {
+      clearTimeout(hardTimer)
+      clearTimeout(idleTimer)
+      active.delete(pid)
+      fs.rmSync(tmp, { recursive: true, force: true })
+      for (const w of waiters.splice(0)) w()
+      const secs = (Date.now() - started) / 1000
+      if (hung)
+        return resolve({ status: 'HUNG', reason: `${hung}, last seen "${lastTest}"`, output, secs })
+      if (exit.code === 0) return resolve({ status: 'PASS', output, secs })
+      resolve({
+        status: 'FAIL',
+        reason: exit.err || `exit ${exit.code ?? exit.signal}`,
+        output,
+        secs
+      })
+    }
+    child.on('error', (err) => {
+      exit = { err: err.message }
+      finish()
+    })
+    child.on('exit', (code, signal) => {
+      exit = { code, signal }
+      killGroup(pid, 'SIGKILL')
+    })
+    child.on('close', () => exit && !exit.err && finish())
   })
-  .catch((err) => {
-    console.error(`Error: ${err.message}`)
-    process.exitCode = 1
+}
+
+async function runFile(file, slot) {
+  let res
+  for (let attempt = 0; attempt <= retries && !stop; attempt++) {
+    await diskGate()
+    res = await runOnce(file, slot)
+    if (res.status === 'PASS') {
+      if (attempt > 0) res.status = 'FLAKY'
+      break
+    }
+  }
+  return res
+}
+
+function report(file, res) {
+  results.push({ file, ...res })
+  const ok = res.status === 'PASS' || res.status === 'FLAKY'
+  const color = res.status === 'PASS' ? 32 : res.status === 'FLAKY' ? 33 : 31
+  const reason = res.reason ? `: ${res.reason}` : ''
+  console.log(
+    `[${results.length}/${files.length}] \x1b[${color}m${res.status}\x1b[0m (${res.secs.toFixed(1)}s) ${file}${reason}`
+  )
+  if (ok) return
+  if (gha) console.log(`::error file=${file}::${res.status}${reason}\n::group::${file} output`)
+  console.log(res.output.trim())
+  if (gha) console.log('::endgroup::')
+  if (opts.bail) stop = true
+}
+
+const started = Date.now()
+console.log(`brittle-jobs: ${files.length} files, ${jobs} jobs, runtime ${runtime}`)
+
+let next = 0
+await Promise.all(
+  Array.from({ length: Math.min(jobs, files.length) }, async (_, i) => {
+    while (!stop && next < files.length) {
+      const file = files[next++]
+      const res = await runFile(file, i + 1)
+      if (res) report(file, res)
+    }
   })
+)
+
+fs.rmSync(tmpRoot, { recursive: true, force: true })
+
+const count = (s) => results.filter((r) => r.status === s).length
+const bad = results.filter((r) => r.status === 'FAIL' || r.status === 'HUNG')
+console.log(`\nslowest:`)
+for (const r of [...results].sort((a, b) => b.secs - a.secs).slice(0, 10)) {
+  console.log(`  ${r.secs.toFixed(1)}s ${r.file}`)
+}
+console.log(
+  `\n${count('PASS')} pass, ${count('FLAKY')} flaky, ${count('FAIL')} fail, ${count('HUNG')} hung` +
+    ` of ${files.length} in ${((Date.now() - started) / 1000).toFixed(1)}s`
+)
+for (const r of bad) console.log(` - ${r.status} ${r.file}: ${r.reason}`)
+process.exit(bad.length || results.length < files.length ? 1 : 0)

package/package.json

@@ -1,33 +1,24 @@
 {
   "name": "brittle-jobs",
-  "version": "0.1.2",
-  "description": "Run brittle test files concurrently, one process per file, on Node or Bare.",
-  "main": "index.js",
+  "version": "0.2.0",
+  "description": "Run brittle test files concurrently, one isolated process per file, with hang detection and tmp cleanup.",
+  "type": "module",
   "bin": {
     "brittle-jobs": "bin.js"
   },
   "files": [
-    "index.js",
-    "bin.js",
-    "lib"
+    "bin.js"
   ],
+  "engines": {
+    "node": ">=22"
+  },
   "scripts": {
-    "test": "brittle-node test/index.js",
-    "lint": "prettier . --check && lunte",
+    "test": "node --test test/run.test.js",
+    "lint": "prettier . --check",
     "format": "prettier . --write"
   },
   "prettier": "prettier-config-holepunch",
-  "dependencies": {
-    "paparam": "^1.13.0",
-    "prettytap": "^0.2.0"
-  },
-  "peerDependencies": {
-    "brittle": ">=4"
-  },
   "devDependencies": {
-    "bare-runtime": "^1.30.0",
-    "brittle": "^4.1.0",
-    "lunte": "^1.8.4",
     "prettier": "^3.6.2",
     "prettier-config-holepunch": "^2.0.0"
   },

package/index.js

@@ -1,151 +0,0 @@
-const fs = require('fs')
-const path = require('path')
-const expand = require('./lib/manifest')
-const runFile = require('./lib/child')
-const report = require('./lib/report')
-const timings = require('./lib/timings')
-const resolveJobs = require('./lib/jobs')
-
-module.exports = async function run(files, opts = {}) {
-  const cwd = opts.cwd ?? process.cwd()
-  const out = opts.out ?? process.stdout
-  const bare = !!opts.bare
-  const jobs = resolveJobs(opts.jobs)
-  validateJobs(jobs)
-  const runtime = bare ? bareRuntime(cwd) : process.execPath
-
-  const args = [require.resolve('brittle/cmd.js', { paths: [cwd] })]
-  if (opts.bail) args.push('--bail')
-  if (opts.timeout) args.push('--timeout', String(opts.timeout))
-
-  const expanded = files.flatMap((file) => expand(path.resolve(cwd, file), { bare }))
-  // Bailing asks for the first failure, not the shortest run. Keep the order
-  // that was asked for so the file that fails is the file that was listed first.
-  const queue = opts.bail ? expanded : timings.order(expanded, cwd)
-  const total = queue.length
-  const results = []
-  const running = new Set()
-  const start = Date.now()
-  let stop = false
-  let bar = report.progress({}, total)
-
-  const abort = () => {
-    stop = true
-    for (const r of running) {
-      try {
-        r.kill()
-      } catch {}
-    }
-    process.exitCode = 130
-  }
-  let listenerInstalled = false
-
-  try {
-    process.once('SIGINT', abort)
-    listenerInstalled = true
-
-    out.write(report.header({ total, runtime, jobs }))
-    bar = report.progress(out, total)
-    const tick = () =>
-      bar.update(
-        results.length,
-        [...running].map((r) => path.relative(cwd, r.file))
-      )
-
-    await new Promise((resolve, reject) => {
-      let settled = false
-
-      const stopWithError = (err) => {
-        if (settled) return
-        stop = true
-        const pending = []
-        for (const r of running) {
-          try {
-            r.kill()
-          } catch {}
-          pending.push(Promise.resolve(r.promise).catch(() => {}))
-        }
-        settled = true
-        Promise.all(pending).then(() => {
-          running.clear()
-          reject(err)
-        })
-      }
-
-      const next = () => {
-        if (settled) return
-        if (running.size === 0 && (stop || queue.length === 0)) {
-          settled = true
-          resolve()
-          return
-        }
-        while (!stop && running.size < jobs && queue.length > 0) {
-          let r
-          try {
-            r = runFile(queue.shift(), { runtime, args, cwd })
-          } catch (err) {
-            stopWithError(err)
-            return
-          }
-          running.add(r)
-          Promise.resolve(r.promise).then((res) => {
-            if (settled) return
-            bar.clear()
-            running.delete(r)
-            try {
-              results.push(res)
-              out.write(report.line(res, cwd))
-              if (res.failed) {
-                out.write(report.detail(res))
-                if (opts.bail) stop = true
-              }
-            } catch (err) {
-              stopWithError(err)
-              return
-            }
-            next()
-          }, stopWithError)
-        }
-        tick()
-      }
-
-      next()
-    })
-
-    out.write(report.summary(results, { total, ms: Date.now() - start, cwd }))
-    timings.write(cwd, results)
-  } finally {
-    bar.stop()
-    if (listenerInstalled) process.off('SIGINT', abort)
-  }
-
-  const failed = results.filter((r) => r.failed).length
-  return { passed: results.length - failed, failed, results }
-}
-
-// The launcher on PATH is whichever Bare the shell found, often an older
-// global one, and node_modules/.bin/bare is a Node process that only spawns the
-// real binary. Both cost a process per file. Take the binary the project
-// installed, and only fall back to the launcher when there is none.
-function bareRuntime(cwd) {
-  let bin
-  try {
-    bin = require(require.resolve('bare-runtime', { paths: [cwd] }))('bare')
-  } catch {
-    return 'bare'
-  }
-  try {
-    fs.accessSync(bin, fs.constants.X_OK)
-  } catch {
-    fs.chmodSync(bin, 0o755)
-  }
-  return bin
-}
-
-function validateJobs(jobs) {
-  if (typeof jobs !== 'number' || !Number.isSafeInteger(jobs) || jobs < 1) {
-    throw new TypeError('jobs must be a positive safe integer')
-  }
-}
-
-module.exports.validateJobs = validateJobs

package/lib/child.js

@@ -1,66 +0,0 @@
-const path = require('path')
-const { spawn } = require('child_process')
-const { Parser } = require('prettytap')
-
-const planLine = /^1\.\.(\d+)$/
-const resultLine = /^(?:not )?ok\b/
-
-function validateTap(results) {
-  // An empty stream is handled by the existing "no TAP output" report. Do not
-  // turn that into a second, less useful validation error.
-  if (!results.foundTapData) return null
-
-  const header = results.lines.findIndex((line) => /^TAP version \d+$/.test(line))
-  const tapLines = results.lines.slice(header + 1)
-  const plans = tapLines.map((line) => line.match(planLine)).filter(Boolean)
-  if (plans.length === 0) return 'missing TAP plan'
-  if (plans.length > 1) return 'multiple TAP plans'
-
-  const expectedTests = Number(plans[0][1])
-  if (!Number.isSafeInteger(expectedTests)) return 'invalid TAP plan count'
-  const observedTests = tapLines.filter((line) => resultLine.test(line)).length
-  if (observedTests !== expectedTests) {
-    return `TAP plan expected ${expectedTests} tests but observed ${observedTests}`
-  }
-
-  return null
-}
-
-module.exports = function runFile(file, { runtime, args, cwd }) {
-  const start = Date.now()
-  const child = spawn(runtime, [...args, path.relative(cwd, file)], {
-    cwd,
-    stdio: ['ignore', 'pipe', 'pipe']
-  })
-  const parser = new Parser()
-  let stderr = ''
-
-  child.stdout.setEncoding('utf8').on('data', (chunk) => parser.write(chunk))
-  child.stderr.setEncoding('utf8').on('data', (chunk) => {
-    stderr += chunk
-  })
-
-  const promise = new Promise((resolve) => {
-    let settled = false
-    const done = (code, signal) => {
-      if (settled) return
-      settled = true
-      parser.end()
-      const results = parser.results
-      const validationError = validateTap(results)
-      if (validationError !== null) {
-        results.validationError = validationError
-        stderr += `TAP validation failed: ${validationError}\n`
-      }
-      const failed =
-        !results.isPassing() || validationError !== null || code !== 0 || signal !== null
-      resolve({ file, results, code, signal, stderr, failed, ms: Date.now() - start })
-    }
-    child.on('error', (err) => {
-      stderr += err.message + '\n'
-    })
-    child.on('close', done)
-  })
-
-  return { file, promise, kill: () => child.kill() }
-}

package/lib/cpus.js

@@ -1,11 +0,0 @@
-// Kept as a compatibility alias for callers that used the old internal name.
-// Job sizing no longer reads cgroup quota files: CPU parallelism is only the
-// fallback when neither the API nor BRITTLE_JOBS specifies a worker count.
-const resolveJobs = require('./jobs')
-
-function cpus() {
-  return resolveJobs()
-}
-
-module.exports = cpus
-module.exports.resolve = resolveJobs

package/lib/jobs.js

@@ -1,16 +0,0 @@
-const os = require('os')
-
-// An explicit API/CLI value is authoritative. Otherwise let CI choose a
-// worker count without tying it to the host's CPU count, and use the host
-// parallelism only when neither setting is present.
-function resolveJobs(explicit) {
-  if (explicit !== undefined && explicit !== null) return explicit
-
-  const fromEnv = Number(process.env.BRITTLE_JOBS)
-  if (Number.isSafeInteger(fromEnv) && fromEnv > 0) return fromEnv
-
-  return os.availableParallelism()
-}
-
-module.exports = resolveJobs
-module.exports.resolve = resolveJobs

package/lib/manifest.js

@@ -1,93 +0,0 @@
-const fs = require('fs')
-const { fileURLToPath, pathToFileURL } = require('url')
-
-const LOAD = /^(if \(isBare\) )?await test\.load\(import\.meta\.resolve\((['"])([^'"]+)\2\)\);?$/
-const IMPORT = /^import\s+[^'"]+\sfrom\s*(['"])([^'"]+)\1;?$/
-
-const PATTERNS = {
-  call: /^await runTests\(\);?$/,
-  wrapper: /^async\s+function runTests\s*\(\s*\)\s*\{$/,
-  brittle: /^const test = \(await import\((['"])brittle\1\)\)\.default;?$/,
-  pause: /^test\.pause\(\);?$/,
-  resume: /^test\.resume\(\);?$/,
-  isBare: /^const isBare = typeof Bare !== (['"])undefined\1;?$/,
-  jobs: /^test\.configure\(\{\s*jobs:[^{}]*\}\);?$/,
-  comment: /^\/\//,
-  close: /^\}$/
-}
-const REQUIRED = ['call', 'wrapper', 'brittle', 'pause', 'resume']
-
-module.exports = function expand(file, { bare }) {
-  const specifiers = parse(fs.readFileSync(file, 'utf8'))
-  if (specifiers === null) return [file]
-
-  const files = []
-  for (const { guarded, specifier } of specifiers) {
-    if (guarded && !bare) continue
-    const resolved = resolve(file, specifier)
-    if (resolved === null) return [file]
-    files.push(resolved)
-  }
-  return files.length > 0 ? files : [file]
-}
-
-// Recognize only the small declarative wrapper emitted by brittle-make-test,
-// plus the two edits it survives in practice: package imports and a jobs
-// configuration, both of which this runner replaces with one process per file.
-// Any other statement must run as the original file so setup and inline tests
-// remain in the same process and unsupported control flow is never guessed at.
-function parse(source) {
-  const seen = new Set()
-  const loads = []
-
-  for (const raw of source.split(/\r?\n/)) {
-    const line = raw.trim()
-    if (line === '') continue
-
-    const load = LOAD.exec(line)
-    if (load) {
-      loads.push({ guarded: !!load[1], specifier: load[3] })
-      continue
-    }
-
-    const imported = IMPORT.exec(line)
-    if (imported) {
-      // A package import cannot be observed once the loads are split out. A
-      // relative one is local setup, so keep the file whole.
-      if (/^[./]/.test(imported[2])) return null
-      continue
-    }
-
-    const name = Object.keys(PATTERNS).find((key) => PATTERNS[key].test(line))
-    if (name === undefined) return null
-    seen.add(name)
-  }
-
-  if (!REQUIRED.every((key) => seen.has(key))) return null
-  if (loads.some((load) => load.guarded) && !seen.has('isBare')) return null
-  return loads
-}
-
-function resolve(file, specifier) {
-  // Keep the accepted subset equivalent to import.meta.resolve for relative
-  // file specifiers. A process can only be started with a filesystem path.
-  // The recognizer intentionally does not decode JavaScript string escapes.
-  // Reject them rather than resolving a different path from the runner.
-  if (
-    specifier.includes('\\') ||
-    (specifier !== '.' &&
-      specifier !== '..' &&
-      !specifier.startsWith('./') &&
-      !specifier.startsWith('../'))
-  ) {
-    return null
-  }
-
-  try {
-    const url = new URL(specifier, pathToFileURL(file))
-    if (url.protocol !== 'file:' || url.hostname || url.search || url.hash) return null
-    return fileURLToPath(url)
-  } catch {
-    return null
-  }
-}

package/lib/report.js

@@ -1,89 +0,0 @@
-const path = require('path')
-const { SpecFormatter, bold, faint, green, red } = require('prettytap')
-
-const secs = (ms) => (ms / 1000).toFixed(1) + 's'
-const indent = (text) =>
-  text
-    .split('\n')
-    .map((line) => (line ? '    ' + line : line))
-    .join('\n')
-
-const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
-const ERASE = '\x1b[2K\x1b[1G'
-
-// A long file keeps a terminal silent for minutes. Repaint a single line so the
-// run is visibly alive and says which files it is waiting on.
-function progress(out, total) {
-  if (!out.isTTY) return { update() {}, clear() {}, stop() {} }
-
-  const start = Date.now()
-  let frame = 0
-  let done = 0
-  let running = []
-  let shown = false
-
-  const paint = () => {
-    const names = running.slice(0, 3).join(' ')
-    const more = running.length > 3 ? ` +${running.length - 3}` : ''
-    const line = `${SPINNER[frame]} ${done}/${total} · ${names}${more} · ${secs(Date.now() - start)}`
-    out.write((shown ? ERASE : '') + faint(line.slice(0, (out.columns || 80) - 1)))
-    shown = true
-  }
-  const clear = () => {
-    if (!shown) return
-    out.write(ERASE)
-    shown = false
-  }
-
-  const timer = setInterval(() => {
-    frame = (frame + 1) % SPINNER.length
-    paint()
-  }, 100)
-  if (timer.unref) timer.unref()
-
-  return {
-    update(nextDone, nextRunning) {
-      done = nextDone
-      running = nextRunning
-      paint()
-    },
-    clear,
-    stop() {
-      clearInterval(timer)
-      clear()
-    }
-  }
-}
-
-function header({ total, runtime, jobs }) {
-  return faint(`${total} files · ${path.basename(runtime)} · jobs=${jobs}`) + '\n\n'
-}
-
-function line(res, cwd) {
-  const name = path.relative(cwd, res.file)
-  if (res.failed) return `${red('✗')} ${bold(name)} ${faint('· ' + secs(res.ms))}\n`
-  return `${green('✓')} ${name} ${faint(`· ${res.results.expectedTests} tests · ${secs(res.ms)}`)}\n`
-}
-
-function detail(res) {
-  let out = ''
-  if (res.results.foundTapData) {
-    const spec = new SpecFormatter()
-    out += spec.formatToString(res.results) + spec.summaryToString()
-  }
-  out += res.stderr
-  if (!res.results.foundTapData) out += red('no TAP output') + '\n'
-  if (res.code !== 0) out += red(`runner exited: ${res.signal ?? res.code}`) + '\n'
-  return indent(out.trimEnd()) + '\n\n'
-}
-
-function summary(results, { total, ms, cwd }) {
-  const failed = results.filter((r) => r.failed)
-  const tests = results.reduce((n, r) => n + Math.max(r.results.expectedTests, 0), 0)
-  const color = failed.length ? red : green
-  const out = `\n${color(bold(`${results.length - failed.length}/${total} files passed`))} ${faint(`· ${tests} tests · ${secs(ms)}`)}\n`
-  if (failed.length === 0) return out
-  return out + red('failed: ') + failed.map((r) => path.relative(cwd, r.file)).join(', ') + '\n'
-}
-
-module.exports = { header, line, detail, summary, progress }

package/lib/timings.js

@@ -1,43 +0,0 @@
-const fs = require('fs')
-const path = require('path')
-
-// Unknown files are scheduled first: a file with no recorded time may be the
-// long one, and starting it last is what leaves a single process owning the
-// tail of the run.
-const UNKNOWN = Number.MAX_SAFE_INTEGER
-
-const cache = (cwd) => path.join(cwd, 'node_modules', '.cache', 'brittle-jobs.json')
-
-function read(cwd) {
-  try {
-    return JSON.parse(fs.readFileSync(cache(cwd), 'utf8'))
-  } catch {
-    return {}
-  }
-}
-
-// Longest processing time first. The makespan of a greedy queue is bounded by
-// 4/3 of the optimum in this order, against no bound at all in runner order.
-function order(queue, cwd) {
-  const ms = read(cwd)
-  const of = (file) => ms[path.relative(cwd, file)] ?? UNKNOWN
-  return queue
-    .map((file, index) => ({ file, index, ms: of(file) }))
-    .sort((a, b) => b.ms - a.ms || a.index - b.index)
-    .map((entry) => entry.file)
-}
-
-function write(cwd, results) {
-  if (results.length === 0) return
-  const ms = read(cwd)
-  for (const res of results) ms[path.relative(cwd, res.file)] = res.ms
-  try {
-    fs.mkdirSync(path.dirname(cache(cwd)), { recursive: true })
-    fs.writeFileSync(cache(cwd), JSON.stringify(ms))
-  } catch {
-    // A read-only or absent node_modules costs the next run its ordering, not
-    // this run its results.
-  }
-}
-
-module.exports = { order, write, cache }