@vzn/vx 0.0.427 → 0.0.429

package/package.json

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

package/src/cli/init.ts

@@ -374,6 +374,9 @@ function namelessNotes(root: string, dirs: readonly string[]): string[] {
     })
     .map((dir) => path.relative(root, dir).split(path.sep).join('/'))
     .sort()
+    // The root's own manifest is the empty relative path: a nameless
+    // single-package repo read `not mapped:  — its package.json…` (M-54).
+    .map((rel) => (rel === '' ? 'the root' : rel))
   if (withScripts.length === 0) return []
   const shown =
     withScripts.slice(0, 3).join(', ') +

package/src/workspace/config-eval.ts

@@ -128,8 +128,12 @@ self.onmessage = async (e) => {
   const envBefore = watched ? { ...live } : null
   const cwdBefore = watched ? globalThis.process.cwd() : null
   // The umask is the process's, not the worker's: a config's umask(0o777)
-  // here left every file vx wrote after it 000 (D-125). Put back below.
-  const umaskIn = globalThis.process.umask()
+  // here left every file vx wrote after it 000 (D-125). Read only when
+  // blaming, the one evaluation in flight: Bun reads it by setting 0 and
+  // back, so this read beside the main thread's left the process at 0
+  // and blamed an innocent config. An ordinary load's change is the
+  // loader's to see, on the main thread, once the round is done.
+  const umaskIn = watched ? globalThis.process.umask() : null
   const same = (a, b) =>
     a !== undefined && b !== undefined && Object.is(a.value, b.value) && a.get === b.get && a.set === b.set &&
     a.writable === b.writable && a.enumerable === b.enumerable && a.configurable === b.configurable
@@ -148,9 +152,7 @@ self.onmessage = async (e) => {
     return out
   }
   const umaskBack = () => {
-    if (globalThis.process.umask() === umaskIn) return false
-    globalThis.process.umask(umaskIn)
-    return true
+    if (umaskIn !== null && globalThis.process.umask() !== umaskIn) globalThis.process.umask(umaskIn)
   }
   try {
     const ns = await import(path)
@@ -160,24 +162,29 @@ self.onmessage = async (e) => {
     const mod = await ns?.default
     const isObject = mod !== null && typeof mod === 'object'
     const nonJson = isObject ? nonJsonPaths(mod) : []
+    // Seen, then put back, BEFORE the reply: the caller terminates a
+    // blaming worker as soon as it answers, and a restore after the reply
+    // lost that race and left the process at the config's mask.
+    const report = changed()
+    umaskBack()
     postMessage({
       id,
       ok: true,
       nonJson,
       json: isObject && nonJson.length === 0 ? JSON.stringify(mod) : null,
       fn: typeof mod === 'function',
-      changed: changed(),
-      umask: umaskBack(),
+      changed: report,
     })
   } catch (err) {
+    const report = changed()
+    umaskBack()
     postMessage({
       id,
       ok: false,
       name: err?.name ?? 'Error',
       message: err?.message ?? String(err),
       stack: err?.stack ?? null,
-      changed: changed(),
-      umask: umaskBack(),
+      changed: report,
       position:
         err?.position && typeof err.position === 'object'
           ? { file: err.position.file, line: err.position.line, column: err.position.column }
@@ -189,9 +196,6 @@ self.onmessage = async (e) => {
 
 const FUNCTION_EXPORT = (): void => {}
 
-/** A repeat load moved the process's umask; the loader names the config (D-125). */
-export class UmaskChanged extends Error {}
-
 const WORKER_URL = `data:text/javascript,${encodeURIComponent(WORKER_SRC)}`
 
 interface WorkerReply {
@@ -200,8 +204,6 @@ interface WorkerReply {
   json: string | null
   /** The default export is a function, which JSON cannot carry back. */
   fn?: boolean
-  /** The evaluation moved the process's umask; the worker put it back. */
-  umask?: boolean
   nonJson: NonJsonValue[]
   name: string
   message: string
@@ -363,7 +365,6 @@ export async function evaluateConfigFresh(configPath: string): Promise<unknown>
       timer.unref?.()
       w.postMessage({ id, path: abs, env: { ...process.env } })
     })
-    if (reply.umask === true) throw new UmaskChanged()
     const [nonJson] = reply.nonJson
     if (nonJson !== undefined) throw new UserError(nonJsonMessage(configPath, nonJson))
     // A function stands in for the one the config exported, so the caller's

package/src/workspace/project-loader.ts

@@ -9,7 +9,6 @@ import {
   CONFIG_EXIT,
   evalBudgetMs,
   evaluateConfigFresh,
-  UmaskChanged,
   WATCHED_BUILTIN_NAMES,
 } from './config-eval.js'
 import { hasEsmExport, unprovidedBareImports } from './config-imports.js'
@@ -496,7 +495,6 @@ export async function loadProjectConfigs(
     if (repeat) refuseUnprovidedImports(bytes!, configPath, 'Project')
     const mod = repeat
       ? await evaluateConfigFresh(configPath).catch((err: unknown) => {
-          if (err instanceof UmaskChanged) throw builtinsChanged(['process.umask'], configPath)
           throw configLoadError(err, configPath, 'Project') ?? err
         })
       : await loadDefaultExport(configPath, 'Project', bytes!)
@@ -508,7 +506,10 @@ export async function loadProjectConfigs(
           ...restoreBuiltins(builtins, overlapping),
           ...restoreEnv(env),
           ...restoreCwd(cwd),
-          ...restoreUmask(umask),
+          // Alone in the round: nothing else reads the umask now. Beside
+          // other loads the round reads it once they are done (see
+          // `currentUmask`).
+          ...(overlapping ? [] : restoreUmask(umask)),
         ]
     // Loads overlap, so another config's change can surface after this
     // one: named here, the refusal blamed the wrong file (D-119). The round
@@ -604,12 +605,22 @@ export async function loadProjectConfigs(
       for (const i of misses) {
         const configPath = prepared[i]!.configPath
         const own = await builtinsChangedBy(configPath)
+        // The blaming worker is gone, so this thread reads alone; and a
+        // worker that outlived its budget was ended before it could put
+        // the umask back.
+        restoreUmask(umask)
         if (own.length > 0) throw builtinsChanged(own, configPath)
       }
       throw builtinsChanged(changedInRound)
     }
     if (first !== undefined) throw first.failed
-    if (changed.length > 0) throw builtinsChanged(changed)
+    // One load in the round, in the worker (a repeat load), is the one
+    // that moved it: the worker no longer reads the umask to say so.
+    if (changed.length > 0)
+      throw builtinsChanged(
+        changed,
+        misses.length === 1 ? prepared[misses[0]!]!.configPath : undefined,
+      )
     return results.map((r) => (r as Loaded).config)
   } finally {
     endRound()
@@ -906,8 +917,9 @@ function currentUmask(): number {
   // Through globalThis, as restoreCwd: the playground's shim has no umask.
   const proc = globalThis.process as { umask?: (mask?: number) => number }
   if (typeof proc.umask !== 'function') return -1
-  // No argument reads it: setting 0 and back would open a window where a
-  // file written by an overlapping write landed world-writable.
+  // Bun reads it by setting 0 and putting it back (probed on 1.4.2: four
+  // workers reading at once left the process at 0), so it is read on this
+  // thread only, and never while the config worker evaluates.
   return proc.umask()
 }