@vzn/vx 0.0.652 → 0.0.653

package/src/cli/why.ts

@@ -7,12 +7,14 @@
 
 import { indexDb, Cache } from '../cache/index.js'
 import { anchoredSpecError, flagHint, formatValue, seeHelp } from './help.js'
-import { buildTaskGraph, isGroupTask, splitTaskId } from '../graph/index.js'
+import { buildTaskGraph, isDefaultBuild, isGroupTask, splitTaskId } from '../graph/index.js'
 import {
   cacheKeyDiff,
   explainCacheKey,
   inputWriters,
   latestRunId,
+  LocalHistoryProvider,
+  recordedTasks,
   rootCauses,
   upstreamTask,
   whyDidThisRerun,
@@ -20,6 +22,7 @@ import {
 import { resolveRunId } from '../orchestrator/index.js'
 import { MASKED, nearMatches, printable, refusal, UserError } from '../util/index.js'
 import * as ui from '../ui/index.js'
+import type { InputWriter, RootCause } from '../history/index.js'
 import type { Style } from '../ui/index.js'
 import { runRules } from '../settings.js'
 import { buildPackageGraph, findWorkspaceRoot } from '../workspace/index.js'
@@ -139,7 +142,7 @@ function suggest(query: string, ids: readonly string[], invoked: boolean): strin
   // No near name: say where to look, or that there is nothing yet.
   // A run of only group tasks records no task row: "nothing has run" was
   // false there, and its advice re-ran the group to the same answer.
-  if (ids.length > 0) return '; `vx last --list` shows what has run'
+  if (ids.length > 0) return '; `vx last --stats` lists the tasks that ran'
   return invoked
     ? '; no recorded run executed a task (a group records none: ask about a task it depends on)'
     : `; nothing has run here yet (vx run ${query}, then vx why)`
@@ -155,7 +158,8 @@ async function resolveTarget(
   cache: Cache,
   target: string,
   cwdProject: () => Promise<string | null>,
-  declared: () => Promise<boolean>,
+  declared: () => Promise<Declared>,
+  declaresId: (id: string) => Promise<Declared>,
 ): Promise<string> {
   const db = indexDb(cache)
   if (target.includes('#')) {
@@ -164,22 +168,40 @@ async function resolveTarget(
     // the error's suggestions and the bare-name form only.
     const [project, task] = splitTaskId(target)
     const hit = db
-      .query('SELECT 1 FROM runs WHERE project = ? AND task = ? ORDER BY id DESC LIMIT 1')
+      .query('SELECT 1 FROM main.runs WHERE project = ? AND task = ? ORDER BY id DESC LIMIT 1')
       .get(project, task)
     if (hit !== null) return target
+    if ((await declaresId(target)) === 'group') throw groupRefusal(target)
   } else {
     // A bare name reads only its own task's rows: the DISTINCT over every
     // pair sorted the whole history (24 of 26 ms at 58k rows), and its list
     // serves only the miss's suggestions below.
     const matches = (
-      db.query('SELECT DISTINCT project FROM runs WHERE task = ? ORDER BY project').all(target) as {
+      db
+        .query('SELECT DISTINCT project FROM main.runs WHERE task = ? ORDER BY project')
+        .all(target) as {
         project: string
       }[]
     ).map((r) => `${r.project}#${target}`)
+    // Asked even when no project ran it: the cwd project's own that never
+    // ran read as a name nobody declares.
+    const here = await cwdProject()
+    if (here !== null) {
+      const own = `${here}#${target}`
+      if (matches.includes(own)) return own
+      // `vx run build` here runs this project's own: another project's
+      // runs were explained in its place, unsaid.
+      const kind = await declaresId(own)
+      if (kind === 'group') throw groupRefusal(own)
+      if (kind !== false) {
+        throw refusal(
+          { tone: 'info', headline: `no runs of ${own} yet`, fix: `vx run ${target}` },
+          { code: 'VX_E_NO_HISTORY', message: `vx why: no recorded runs for "${own}"` },
+        )
+      }
+    }
     if (matches.length === 1) return matches[0]!
     if (matches.length > 1) {
-      const here = await cwdProject()
-      if (here !== null && matches.includes(`${here}#${target}`)) return `${here}#${target}`
       throw new UserError(
         `vx why: "${target}" ran in ${matches.length} projects — pick one:\n` +
           matches.map((m) => `  ${m}`).join('\n'),
@@ -187,17 +209,18 @@ async function resolveTarget(
       )
     }
   }
-  const pairs = db
-    .query('SELECT DISTINCT project, task FROM runs ORDER BY project, task')
-    .all() as Array<{ project: string; task: string }>
-  const ids = pairs.map((p) => `${p.project}#${p.task}`)
+  const ids = new LocalHistoryProvider(db).recentTaskIds()
   const invoked = ids.length === 0 && db.query('SELECT 1 FROM invocations LIMIT 1').get() !== null
   if (ids.length === 0 && !invoked) {
     // `vx run` of a task no project declares is refused: its advice was that.
     const known = await declared()
+    // Where the cwd's project does not declare it (a monorepo root), a bare
+    // `vx run build` is refused too: that advice sent the user in a circle.
+    const here = known && !target.includes('#') ? await cwdProject() : null
+    const all = here !== null && (await declaresId(`${here}#${target}`)) === false ? ' --all' : ''
     throw refusal(
       known
-        ? { tone: 'info', headline: `no runs of ${target} yet`, fix: `vx run ${target}` }
+        ? { tone: 'info', headline: `no runs of ${target} yet`, fix: `vx run ${target}${all}` }
         : {
             tone: 'info',
             headline: `no project declares ${target}`,
@@ -271,16 +294,12 @@ export async function whyCmd(args: readonly string[]): Promise<number> {
       target,
       () => findCwdProject(process.cwd()),
       () => declares(root, target),
+      // The cwd project's own: a bare `vx run` there skips its default build.
+      (id) => declares(root, id, true),
     )
     let runId: string | null
     if (parsed.runId !== undefined) {
-      // A stopped run keeps rows but no header (item 854), and `vx last
-      // --log` prints its id, so the whole id is taken from its rows too.
-      runId =
-        resolveRunId(db, parsed.runId, 'vx why') ??
-        (db.query('SELECT 1 FROM runs WHERE run_id = ? LIMIT 1').get(parsed.runId) !== null
-          ? parsed.runId
-          : null)
+      runId = resolveRunId(db, parsed.runId, 'vx why')
       // An unknown id read as a known run missing the task (X-18).
       if (runId === null) {
         throw new UserError(
@@ -329,18 +348,16 @@ export async function whyCmd(args: readonly string[]): Promise<number> {
     // each moved dependency in this run down to the tasks whose own
     // inputs moved, so one `vx why` names the file, not the next task.
     // A group records no run: the graph names what it gathers.
+    const recorded = recordedTasks(db, runId)
     const unrecorded = diff.entries.filter(
-      (e) =>
-        e.kind === 'upstream' &&
-        e.change === 'changed' &&
-        !cacheKeyDiff(db, runId, upstreamTask(e.name)).found,
+      (e) => e.kind === 'upstream' && e.change === 'changed' && !recorded.has(upstreamTask(e.name)),
     )
     const groups = unrecorded.length > 0 ? await groupMembers(root, taskId) : new Map()
     const roots = rootCauses(db, runId, taskId, diff.entries, groups)
-    const writers = inputWriters(db, root, taskId, diff.entries, roots)
+    const writers = inputWriters(db, runId, root, taskId, diff.entries, roots)
 
     if (parsed.format === 'json') {
-      ui.data('out', `${JSON.stringify({ taskId, runId, why, diff, roots, writers })}\n`)
+      await ui.dataPieces('out', jsonPieces({ taskId, runId, why, diff }, roots, writers))
       return 0
     }
 
@@ -407,8 +424,18 @@ export async function whyCmd(args: readonly string[]): Promise<number> {
           const what = r.entries.map((e) =>
             e.name === e.kind ? e.kind : `${e.kind} ${printable(e.name)}`,
           )
+          // A 20,000-task chain printed whole is one 389 KB line.
+          const chain = r.chain
+          const ids =
+            chain.length > CHAIN_SHOWN
+              ? [
+                  ...chain.slice(0, 2).map((id) => ui.id(id)),
+                  ui.dim(`${chain.length - 5} more`),
+                  ...chain.slice(-3).map((id) => ui.id(id)),
+                ]
+              : chain.map((id) => ui.id(id))
           return [
-            ...r.chain.flatMap((id, i) => [...(i > 0 ? [ui.dim(' \u2190 ')] : []), ui.id(id)]),
+            ...ids.flatMap((id, i) => [...(i > 0 ? [ui.dim(' \u2190 ')] : []), id]),
             ui.dim(' \u2190 '),
             ui.strong(
               `${what.slice(0, 3).join(', ')}${what.length > 3 ? ` and ${what.length - 3} more` : ''}`,
@@ -470,6 +497,33 @@ export async function whyCmd(args: readonly string[]): Promise<number> {
 
 const ROOTS_SHOWN = 5
 
+/** Longer root-cause chains print their two ends around a count. */
+const CHAIN_SHOWN = 6
+
+/** Bytes of roots per piece written. */
+const PIECE_BYTES = 1 << 20
+
+/**
+ * `{ ...head, roots, writers }` as one `JSON.stringify` of it gives, in
+ * pieces: every root carries its whole chain, so a 20,000-task chain's
+ * roots hold 2×10⁸ ids, more than one string holds.
+ */
+function* jsonPieces(
+  head: object,
+  roots: readonly RootCause[],
+  writers: readonly InputWriter[],
+): Generator<string> {
+  let piece = `${JSON.stringify(head).slice(0, -1)},"roots":[`
+  for (let i = 0; i < roots.length; i++) {
+    piece += `${i > 0 ? ',' : ''}${JSON.stringify(roots[i])}`
+    if (piece.length >= PIECE_BYTES) {
+      yield piece
+      piece = ''
+    }
+  }
+  yield `${piece}],"writers":${JSON.stringify(writers)}}\n`
+}
+
 const CHANGE_HUE: Record<string, Style> = { added: 'ok', removed: 'error', changed: 'warn' }
 
 type DiffEntry = ReturnType<typeof cacheKeyDiff>['entries'][number]
@@ -508,21 +562,41 @@ function upstreamTodo(upstream: readonly DiffEntry[], unrecorded: readonly DiffE
   return out
 }
 
-/** Whether a project declares `target` (`pkg#task`, or a bare task); true when no config loads. */
-async function declares(root: string, target: string): Promise<boolean> {
+/** A declared group (no `exec`) records no run: `group` when every declaration is one. */
+type Declared = false | 'task' | 'group'
+
+/** Whether a project declares `target` (`pkg#task`, or a bare task); `task` when no config loads. */
+async function declares(root: string, target: string, own = false): Promise<Declared> {
   try {
     const projects = await loadCliProjects(root, await discoverCliProjects(root), 'all')
     const [project, task] = target.includes('#') ? splitTaskId(target) : [undefined, target]
-    return [...projects.values()].some(
-      (p) =>
-        (project === undefined || p.name === project) && Object.hasOwn(p.config.tasks ?? {}, task),
-    )
+    const found = [...projects.values()].flatMap((p) => {
+      const t = p.config.tasks?.[task]
+      return (project === undefined || p.name === project) &&
+        Object.hasOwn(p.config.tasks ?? {}, task) &&
+        !(own && isDefaultBuild(t))
+        ? [t]
+        : []
+    })
+    if (found.length === 0) return false
+    // The default build is a group too, but no one declared it.
+    return found.every((t) => t?.exec === undefined && !isDefaultBuild(t)) ? 'group' : 'task'
   } catch {
     // quiet: with no lock or a broken config, the run says why itself
-    return true
+    return 'task'
   }
 }
 
+function groupRefusal(id: string): UserError {
+  return refusal(
+    { tone: 'info', headline: `${id} is a group, which records no run`, fix: `vx show ${id}` },
+    {
+      code: 'VX_E_NO_HISTORY',
+      message: `vx why: ${id} is a group, which records no run (vx show ${id} names what it gathers)`,
+    },
+  )
+}
+
 /**
  * Each group in `taskId`'s graph with the tasks it gathers. Empty when a
  * config no longer loads: the advice then names the group to `vx show`.

package/src/cli/workspace-config.ts

@@ -7,6 +7,7 @@
 import { existsSync } from 'node:fs'
 import path from 'node:path'
 import type { WorkspaceConfig } from '../config.js'
+import type { LazyGitEnumeration } from '../cache/index.js'
 import { UserError } from '../util/index.js'
 import { sayLine } from '../ui/index.js'
 import {
@@ -65,10 +66,19 @@ export async function loadCliWorkspace(
 export async function discoverCliProjects(
   root: string,
   load: CliLoadOptions = {},
+  /** The whole-tree enumeration the caller started; the run reuses it with the discovery. */
+  git?: LazyGitEnumeration,
 ): Promise<ProjectMeta[]> {
   const warn = load.warn ?? warnToStderr
   const ws = await loadCliWorkspace(root, warn)
-  return await discoverProjects(root, lockReader(root), ws.plugins, stageCacheDir(ws, load), warn)
+  return await discoverProjects(
+    root,
+    lockReader(root),
+    ws.plugins,
+    stageCacheDir(ws, load),
+    warn,
+    git,
+  )
 }
 
 /**

package/src/config.ts

@@ -497,6 +497,15 @@ export interface ExecConfig {
    * it on a worker that is. Omitted → anywhere.
    */
   platforms?: readonly Platform[]
+  /**
+   * The worker type to run it on, by name (`'ubuntu'`), when an executor
+   * that names worker types (`TaskExecutor.workers`, `@vzn/vx-dte`'s
+   * `workers`) runs it: only that type's machines take it, and a run
+   * whose executor has no such type, or none on one of `platforms`, is
+   * refused before it starts. Placement only: not in the key, and a run
+   * on this machine ignores it. Omitted → the first type that fits.
+   */
+  worker?: string
   /** Environment exposed to the child process. */
   env?: ExecEnv
   /**

package/src/exec/env.ts

@@ -39,7 +39,9 @@ export interface BuildEnvOptions {
 }
 
 export function buildIsolatedEnv(opts: BuildEnvOptions): NodeJS.ProcessEnv {
-  const out: NodeJS.ProcessEnv = {}
+  // No prototype: on `{}`, a name `__proto__` hit the setter and reached
+  // no task, though the key folded it.
+  const out: NodeJS.ProcessEnv = Object.create(null)
 
   for (const name of ESSENTIAL_ENV) {
     const value = opts.source[name]

package/src/exec/executor.ts

@@ -48,6 +48,11 @@ export interface ExecuteSandbox {
    * that builds the request again hands `sandboxRequestFor` too.
    */
   readonly dependencyReads?: readonly string[]
+  /**
+   * The heads of those outputs (absolute): a refused read under one is a
+   * file beside them, reported. Handed `sandboxRequestFor` with them.
+   */
+  readonly dependencyReported?: readonly string[]
 }
 
 /** One declared input file, as the cache key saw it. */
@@ -79,8 +84,9 @@ export interface TaskInputs {
    * Dependencies whose cache keys are folded. `outputs` lists each one's
    * declared output files (workspace-relative POSIX, as stored with its cache
    * entry) — restored on disk before this task runs, so an input-shipping
-   * executor can include them in the input root. Empty when the upstream's
-   * entry is not in the local index (a non-cacheable dependency).
+   * executor can include them in the input root. A non-cacheable
+   * dependency's are its declared outputs found on disk; a cacheable one
+   * with no entry in the local index lists none.
    */
   readonly upstream: ReadonlyArray<{
     readonly taskId: string
@@ -109,6 +115,12 @@ export interface ServerSpec {
   readonly sandbox?: { readonly config: SandboxConfig; readonly nested: readonly string[] }
 }
 
+/**
+ * One task's command, as core hands it to an executor. A plugin
+ * executor's `outputs`, `envDefine` and `forwardArgs` are frozen copies:
+ * core saves the outputs after the command, and a config or the run's
+ * args are shared with other tasks.
+ */
 export interface ExecuteRequest {
   /** `${project}#${task}` — for executors that route or log by task. */
   readonly taskId: string
@@ -150,6 +162,12 @@ export interface ExecuteRequest {
    * executor's `platforms`: its key includes it. Absent when the task names none.
    */
   readonly platform?: string
+  /**
+   * The worker type to run it on, one of the executor's `workers`: the
+   * task's `exec.worker`, else the first type with one of its platforms.
+   * Absent when the executor names no types.
+   */
+  readonly worker?: string
   /**
    * Which attempt of the task this is, from 2 when it retries; absent on
    * the first. An executor that can, runs a retry somewhere other than
@@ -190,7 +208,8 @@ export interface ExecuteRequest {
   readonly onStderr: (chunk: string) => void
   /**
    * Aborted when the run stops (Ctrl-C, SIGTERM, SIGHUP or an embedder's
-   * `RunOptions.signal`) or when `timeoutMs` elapses. An executor ends its
+   * `RunOptions.signal`), when `timeoutMs` elapses, or when fail-fast
+   * withdraws a task `running` says is not begun. An executor ends its
    * work and returns: a child an executor spawned is not one core can
    * reach (H-10, H-12). One already aborted is work not to start (B-55).
    * Any exit after the timeout's abort, a 0 included, is a timeout. Core
@@ -236,10 +255,11 @@ export interface ExecuteResult extends RunResult {
    */
   readonly outputs?: { kind: 'disk' } | { kind: 'deferred'; materialize: () => Promise<void> }
   /**
-   * Tracked files the command changed where it ran, workspace-relative
-   * POSIX: an executor that runs it elsewhere says so, as this disk shows
-   * none of it. One the key read withholds the save under the key, as an
-   * input changed here does.
+   * Tracked files the command changed where it ran, and untracked ones it
+   * found there, workspace-relative POSIX: an executor that runs it
+   * elsewhere says so, as this disk shows none of it. One the key read, or
+   * one its inputs declare, withholds the save under the key, as an input
+   * changed here does.
    */
   readonly changed?: readonly string[]
   /**
@@ -291,9 +311,12 @@ export interface TaskExecutor {
   /** Runs the command somewhere else. Never offered a `pinnedLocal` task. */
   readonly remote?: boolean
   /**
-   * A `remote` executor that enforces `ExecuteRequest.sandbox` where it
-   * runs the command, as the local one does. It is offered sandboxed tasks
-   * and their dependants; the request's violations come back on the result.
+   * Enforces `ExecuteRequest.sandbox` where it runs the command, as the
+   * local one does; the request's violations come back on the result. Only
+   * such an executor is offered a task that declares `exec.sandbox`, here
+   * or remote: one that ran it unsandboxed passed a boundary it never
+   * checked and cached the output. A `remote` one is offered the
+   * dependants of a sandboxed task too.
    */
   readonly sandbox?: boolean
   /**
@@ -338,6 +361,14 @@ export interface TaskExecutor {
    * declares none is never offered such a task off this machine.
    */
   readonly platforms?: readonly string[]
+  /**
+   * Its worker types in order of preference, each with the platforms its
+   * machines run (`@vzn/vx-dte`'s `workers`). A task naming `exec.worker`
+   * is offered it only when it has that type on one of the task's
+   * platforms; any other task goes to the first type that fits, on
+   * `ExecuteRequest.worker`. Its `platforms` must list every one of them.
+   */
+  readonly workers?: ReadonlyArray<readonly [name: string, platforms: readonly string[]]>
   /**
    * How many tasks this executor runs at once. Its tasks then occupy a pool
    * of this size instead of the local worker slots, so a remote pool is not
@@ -345,7 +376,11 @@ export interface TaskExecutor {
    * is refused when the executor is resolved. Absent = the local pool.
    */
   readonly capacity?: number
-  /** Per-task opt-out at placement time. Absent = accepts every task it is offered. */
+  /**
+   * Per-task opt-out at placement time. Absent = accepts every task it is
+   * offered. `false` or `undefined` declines; any other non-boolean is
+   * refused, naming the plugin.
+   */
   accepts?(task: TaskPlacement): boolean
   /**
    * The tasks placed here that will run and have NOT finished yet — called
@@ -406,8 +441,17 @@ export interface TaskExecutor {
    * Where a task it was handed runs (`small#2`), for the live row; asked
    * per frame. `null` while it holds the task for a machine to begin it:
    * the row says `waiting`, and its clock starts when a machine begins it.
+   * Under `--continue=never` a failure aborts the `signal` of each task it
+   * answers `null` for, and the task is skipped, never started.
    */
   running?(taskId: string): string | null | undefined
+  /**
+   * A `servers` executor's: no task left in the run uses persistent task
+   * `taskId`, so each copy it started beside a dependant stops now, not at
+   * teardown. Core asks once, as the run stops its own copy (`schema.md`,
+   * "Stopped once nothing needs it"). A throw is ignored.
+   */
+  unneeded?(taskId: string): void
   execute(req: ExecuteRequest): Promise<ExecuteResult>
 }
 
@@ -431,7 +475,11 @@ export interface MachineReport {
   /** Bytes in use at once, at the most and on average. */
   memoryPeakBytes: number
   memoryAvgBytes: number
-  /** Core-time its tasks used over the core-time it had, 0 to 1. */
+  /**
+   * Its machine's busy core-time over the core-time it had, from its first
+   * task's send to its last one's end, 0 to 1 (its tasks' own where its
+   * machine said none): whether cores were left idle.
+   */
   utilization: number
   /** Cores the executor booked for the tasks it ran, on average over its time online. */
   bookedAvg?: number
@@ -574,8 +622,8 @@ export function assertExecuteResult(
 
 /**
  * Place one task: the first executor, in declaration order, that may take
- * it — a `remote` executor is skipped for a `pinnedLocal` task, then
- * `accepts()` decides. Decided once per task before scheduling. The local
+ * it — a `remote` executor is skipped for a `pinnedLocal` task, any one
+ * `barred` names is skipped, then `accepts()` decides. Decided once per task before scheduling. The local
  * executor accepts everything, so with it declared the only throw is an
  * `accepts()` that threw: refused as `label` names that executor, where it
  * surfaced as a bare stack naming no plugin (item 1022).
@@ -586,10 +634,12 @@ export function selectExecutor(
   label: (executor: TaskExecutor) => string = (e) => `executor '${e.name}'`,
   /** `task.pinnedLocal` as `executor` sees it: one that enforces the sandbox or carries servers lifts some pins. */
   pinnedFor: (executor: TaskExecutor) => boolean = () => task.pinnedLocal,
+  /** Never offered the task: a sandboxed one is barred from an executor that does not enforce it. */
+  barred: (executor: TaskExecutor) => boolean = () => false,
 ): TaskExecutor {
   for (const executor of executors) {
     const pinned = pinnedFor(executor)
-    if (pinned && executor.remote === true) continue
+    if ((pinned && executor.remote === true) || barred(executor)) continue
     if (executor.accepts === undefined) return executor
     let taken: unknown
     try {
@@ -602,6 +652,17 @@ export function selectExecutor(
         taken.catch(() => {})
         throw new Error('returned a Promise; accepts is synchronous')
       }
+      // `'no'` was truthy and took the task; admit refuses the same answer.
+      if (taken !== undefined && typeof taken !== 'boolean') {
+        const t = typeof taken
+        const what =
+          taken === null
+            ? 'null'
+            : Array.isArray(taken)
+              ? 'an array'
+              : `${t === 'object' ? 'an' : 'a'} ${t}`
+        throw new Error(`returned ${what}, not true or false`)
+      }
     } catch (err) {
       const m = thrownMessage(err)
       throw new UserError(`${label(executor)} failed in accepts for ${task.taskId}: ${m}`)

package/src/exec/kill-tree.ts

@@ -151,7 +151,7 @@ function stopGuard(): void {
 
 function guardWrite(line: string): void {
   if (typeof guardFd !== 'number') return
-  let deadline = Date.now() + GUARD_STALL_MS
+  let deadline = performance.now() + GUARD_STALL_MS
   // A turn's batch can be more than the queue takes at once: it goes in
   // pieces as the guard drains it, and only a guard that takes nothing for
   // the whole stall is gone. With one deadline for the batch, 2000 strikes
@@ -162,9 +162,9 @@ function guardWrite(line: string): void {
       const n = writeSync(guardFd, bytes, 0, Math.min(bytes.length, GUARD_PIECE))
       if (n === bytes.length) return
       bytes = bytes.subarray(n)
-      deadline = Date.now() + GUARD_STALL_MS
+      deadline = performance.now() + GUARD_STALL_MS
     } catch (err) {
-      if ((err as NodeJS.ErrnoException).code !== 'EAGAIN' || Date.now() >= deadline) break
+      if ((err as NodeJS.ErrnoException).code !== 'EAGAIN' || performance.now() >= deadline) break
       Bun.sleepSync(1)
     }
   }
@@ -414,7 +414,7 @@ export async function untilGroupsGone(
   children: readonly Child[],
   graceMs: number,
 ): Promise<Child[]> {
-  const deadline = Date.now() + graceMs
+  const deadline = performance.now() + graceMs
   let timer: ReturnType<typeof setTimeout> | undefined
   // Not unref'd: it is what guarantees progress when every other handle
   // has drained, and the grace is bounded either way.
@@ -426,8 +426,8 @@ export async function untilGroupsGone(
   ])
   if (timer !== undefined) clearTimeout(timer)
   let left = children.filter(groupAlive)
-  while (left.length > 0 && Date.now() < deadline) {
-    await Bun.sleep(Math.min(GROUP_POLL_MS, deadline - Date.now()))
+  while (left.length > 0 && performance.now() < deadline) {
+    await Bun.sleep(Math.min(GROUP_POLL_MS, deadline - performance.now()))
     left = left.filter(groupAlive)
   }
   return left
@@ -443,7 +443,7 @@ export async function untilGroupsGone(
  * and a group that ignored the SIGTERM went un-killed; there the group
  * signal is the answer and the grace ends the wait.
  */
-function groupAlive(child: Child): boolean {
+export function groupAlive(child: Child): boolean {
   if (!(child.pid > 0) || goneGroups.has(child)) return false
   try {
     process.kill(-child.pid, 0)