@vzn/vx 0.0.179 → 0.0.181

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.179",
+  "version": "0.0.181",
   "description": "A fast, correct task runner and build cache for JavaScript monorepos.",
   "type": "module",
   "exports": {
@@ -17,10 +17,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@vzn/vx-linux-x64": "0.0.179",
-    "@vzn/vx-linux-arm64": "0.0.179",
-    "@vzn/vx-darwin-x64": "0.0.179",
-    "@vzn/vx-darwin-arm64": "0.0.179"
+    "@vzn/vx-linux-x64": "0.0.181",
+    "@vzn/vx-linux-arm64": "0.0.181",
+    "@vzn/vx-darwin-x64": "0.0.181",
+    "@vzn/vx-darwin-arm64": "0.0.181"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/workspace/config-eval.ts

@@ -39,6 +39,9 @@ import path from 'node:path'
 import { MAX_TIMEOUT_MS, UserError } from '../util/index.js'
 import { nonJsonMessage, nonJsonPaths, type NonJsonValue } from './json-data.js'
 
+/** Why a config's `process.exit` throws, on both load paths (D-65). */
+export const CONFIG_EXIT = 'a config exports its object; it cannot end the run'
+
 const WORKER_SRC = `
 const nonJsonPaths = ${nonJsonPaths.toString()}
 // The parent's stdout is a verb's JSON or vx mcp's JSON-RPC stream, and a
@@ -60,6 +63,11 @@ const quiet = (async () => {
   const ownBunWrite = B.write
   B.write = (dest, ...rest) => ownBunWrite(dest === B.stdout ? B.stderr : dest, ...rest)
   B.stdout.writer = (...args) => B.stderr.writer(...args)
+  // An exit here ended the worker unheard, and the load waited out its
+  // whole deadline to say the worker did not answer (D-65).
+  P.exit = (code) => {
+    throw new Error('process.exit(' + (code ?? '') + ') in a config: ' + ${JSON.stringify(CONFIG_EXIT)})
+  }
 })()
 self.onmessage = async (e) => {
   await quiet
@@ -124,12 +132,12 @@ interface Pending {
 }
 
 /**
- * How long a single config evaluation may take before we treat the worker as
- * wedged. Real evaluations are ~10 ms; this exists only so a killed or hung
- * worker cannot stall a long-lived process indefinitely. Read per call so a
- * test can drive the deadline instead of waiting it out.
+ * How long a single config evaluation may take, in the worker or in process
+ * (D-66). Real evaluations are ~10 ms; this exists only so a hung config or a
+ * killed worker cannot stall a run or a long-lived process indefinitely. Read
+ * per call so a test can drive the deadline instead of waiting it out.
  */
-function workerTimeoutMs(): number {
+export function evalBudgetMs(): number {
   const raw = process.env['VX_CONFIG_WORKER_TIMEOUT_MS']
   // Same kind of value as the teardown deadline, so the same treatment: a
   // BOUND on a worker that may be wedged, with no "no limit" reading. Falls
@@ -258,7 +266,7 @@ export async function evaluateConfigFresh(configPath: string): Promise<unknown>
     // otherwise take milliseconds. Nothing else bounds it: there is no
     // run-level timeout. The budget is enormous next to the ~10 ms a real
     // evaluation costs, so it can only fire on a genuine wedge.
-    const budget = workerTimeoutMs()
+    const budget = evalBudgetMs()
     const reply = await new Promise<WorkerReply>((resolve, reject) => {
       pending.set(id, { resolve, reject })
       timer = setTimeout(() => {

package/src/workspace/project-loader.ts

@@ -3,7 +3,7 @@ import path from 'node:path'
 import type { ProjectConfig, WorkspaceConfig } from '../config.js'
 import { UserError, xxh3hex } from '../util/index.js'
 import { validateProjectConfig, validateWorkspace } from './config-schema.js'
-import { beginEvalRound, evaluateConfigFresh } from './config-eval.js'
+import { beginEvalRound, CONFIG_EXIT, evalBudgetMs, evaluateConfigFresh } from './config-eval.js'
 import { hasEsmExport, unprovidedBareImports } from './config-imports.js'
 import {
   configEvalKey,
@@ -136,8 +136,27 @@ async function loadDefaultExport(
     holdSource(hash, source)
   }
   let ns: { default?: unknown }
+  const unguard = guardExit()
+  let deadline: ReturnType<typeof setTimeout> | undefined
   try {
-    ns = (await import(specifier)) as { default?: unknown }
+    // The worker's budget, here too: a top-level await that never settled
+    // while a timer kept the loop alive hung `vx run` for good, silently
+    // (D-66).
+    const budget = evalBudgetMs()
+    ns = (await Promise.race([
+      import(specifier),
+      new Promise<never>((_, reject) => {
+        deadline = setTimeout(
+          () =>
+            reject(
+              new UserError(
+                `${kind} config ${configPath} did not finish evaluating within ${budget}ms (VX_CONFIG_WORKER_TIMEOUT_MS)`,
+              ),
+            ),
+          budget,
+        )
+      }),
+    ])) as { default?: unknown }
   } catch (err) {
     // A served module's frames name its specifier; the user wrote the path.
     if (err instanceof Error && err.stack !== undefined) {
@@ -145,6 +164,8 @@ async function loadDefaultExport(
     }
     throw configLoadError(err, configPath, kind) ?? err
   } finally {
+    clearTimeout(deadline)
+    unguard()
     if (source !== null) releaseSource(hash)
   }
   const mod = ns?.default
@@ -152,6 +173,28 @@ async function loadDefaultExport(
   return mod
 }
 
+/**
+ * A config's `process.exit` ended vx mid-load: `exit(0)` was a green run
+ * that ran nothing and printed nothing (D-65). While any config evaluates
+ * in process it throws instead, at the config's line. vx's own exit is
+ * signal forwarding's, which a run installs after its load and removes
+ * when it ends.
+ */
+let evaluating = 0
+let ownExit: typeof process.exit = process.exit
+function guardExit(): () => void {
+  if (evaluating++ === 0) {
+    ownExit = process.exit
+    process.exit = configExit
+  }
+  return () => {
+    if (--evaluating === 0) process.exit = ownExit
+  }
+}
+const configExit = ((code?: number | string | null) => {
+  throw new Error(`process.exit(${code ?? ''}) in a config: ${CONFIG_EXIT}`)
+}) as typeof process.exit
+
 /**
  * A bare import nothing above the config provides is refused BEFORE the
  * evaluation: left to Bun, a workspace with no `node_modules` would have