@vzn/vx 0.0.196 → 0.0.198

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.196",
+  "version": "0.0.198",
   "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.196",
-    "@vzn/vx-linux-arm64": "0.0.196",
-    "@vzn/vx-darwin-x64": "0.0.196",
-    "@vzn/vx-darwin-arm64": "0.0.196"
+    "@vzn/vx-linux-x64": "0.0.198",
+    "@vzn/vx-linux-arm64": "0.0.198",
+    "@vzn/vx-darwin-x64": "0.0.198",
+    "@vzn/vx-darwin-arm64": "0.0.198"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/cache/cache.ts

@@ -26,7 +26,16 @@
 // layer speaks is `CacheLayer` in layer.ts; `plugin-host.ts` enforces it.
 
 import { Database, type SQLQueryBindings } from 'bun:sqlite'
-import { accessSync, constants, existsSync, mkdirSync, renameSync, writeFileSync } from 'node:fs'
+import {
+  accessSync,
+  closeSync,
+  constants,
+  existsSync,
+  mkdirSync,
+  openSync,
+  renameSync,
+  writeFileSync,
+} from 'node:fs'
 import { readdir, rm, stat, unlink, writeFile } from 'node:fs/promises'
 import path from 'node:path'
 import { createTables } from './schema.js'
@@ -129,6 +138,26 @@ function unreadableIndexError(dbFile: string, err: unknown): UserError {
   )
 }
 
+/**
+ * SQLite reports a descriptor it could not get as `SQLITE_CANTOPEN`, never
+ * `EMFILE`, so an open under a low `ulimit -n` reached the user as a bare
+ * `vx: SQLiteError: unable to open database file` (D's lead, A-56). One
+ * open of a file that exists says which it was.
+ */
+function outOfFdsAtOpen(dbFile: string, err: unknown): UserError | undefined {
+  const code = (err as { code?: unknown } | null)?.code
+  if (typeof code !== 'string' || !code.startsWith('SQLITE_CANTOPEN')) return undefined
+  try {
+    closeSync(openSync(process.execPath, 'r'))
+    return undefined
+  } catch (probe) {
+    if (!isOutOfFds(probe)) return undefined
+    return new UserError(
+      `the cache index ${dbFile} could not be opened (${(err as Error).message}) — ${OUT_OF_FDS_HINT}`,
+    )
+  }
+}
+
 /** Say once, on the channel the opener has, that an upgrade emptied the index. */
 export function noteSchemaReset(cache: Cache, warn: (message: string) => void): void {
   if (cache.formatChange !== null) {
@@ -527,7 +556,11 @@ export class Cache implements CacheLayer {
     const absent = mode === 'inspect' && !existsSync(dbFile)
     this.writeBlocked = absent ? 'no index there yet' : openCacheDir(cacheDir)
     this.write = localPolicy.write && this.writeBlocked === null
-    this.db = new Database(absent ? ':memory:' : dbFile, { create: true })
+    try {
+      this.db = new Database(absent ? ':memory:' : dbFile, { create: true })
+    } catch (err) {
+      throw outOfFdsAtOpen(dbFile, err) ?? err
+    }
     // busy_timeout makes concurrent writers wait for the lock instead of
     // failing immediately with SQLITE_BUSY. Two parallel `vx run`
     // invocations in CI is a normal pattern; without this the second one
@@ -544,7 +577,16 @@ export class Cache implements CacheLayer {
       try {
         return read()
       } catch (err) {
-        if (!unreadableIndex(err)) throw err
+        if (!unreadableIndex(err)) {
+          const fds = outOfFdsAtOpen(dbFile, err)
+          if (fds === undefined) throw err
+          try {
+            closeDb(this.db)
+          } catch {
+            // The refusal is the error worth reporting.
+          }
+          throw fds
+        }
         try {
           closeDb(this.db)
         } catch {

package/src/workspace/project-loader.ts

@@ -387,6 +387,7 @@ export async function loadProjectConfigs(
     closure?: readonly [string, readonly string[]]
   }
   const builtins = builtinSnapshot()
+  const env = { ...process.env }
   const loadOne = async (entry: (typeof prepared)[number]): Promise<Loaded> => {
     const { configPath, cacheKey } = entry
     // A fast key that missed: the closure is stale or the file changed.
@@ -427,7 +428,7 @@ export async function loadProjectConfigs(
       : await loadDefaultExport(configPath, 'Project', bytes!)
     // Before anything reads through them: a replaced `Array.prototype.includes`
     // turned the JSON-data walk's own check into "a cyclic reference".
-    const changed = repeat ? [] : restoreBuiltins(builtins)
+    const changed = repeat ? [] : [...restoreBuiltins(builtins), ...restoreEnv(env)]
     if (changed.length > 0) throw builtinsChanged(changed, configPath)
     assertDefaultObject(mod, 'Project', configPath)
     // Validation runs HERE, on whichever object we ended up with, so a
@@ -485,7 +486,7 @@ export async function loadProjectConfigs(
         if (r.closure !== undefined) learnedClosures.push(r.closure)
       }
     }
-    const changed = restoreBuiltins(builtins)
+    const changed = [...restoreBuiltins(builtins), ...restoreEnv(env)]
     if (first !== undefined) throw first.failed
     if (changed.length > 0) throw builtinsChanged(changed)
     return results.map((r) => (r as Loaded).config)
@@ -539,8 +540,11 @@ function builtinSnapshot(): BuiltinSnapshot {
 /** Loads run together, so the config named is the one whose load saw the change. */
 function builtinsChanged(changed: readonly string[], configPath?: string): UserError {
   const who = configPath === undefined ? 'a project config' : configPath
+  const env = changed.some((c) => c.startsWith('process.env.'))
+    ? '; a task gets an env var through `exec.env.define` or `passThrough`'
+    : ''
   return new UserError(
-    `${who} changed ${changed.join(', ')} while it was evaluated — a config must not change the built-ins vx runs on: other configs are read through them and cache keys are made with them`,
+    `${who} changed ${changed.join(', ')} while it was evaluated — a config must not change the built-ins vx runs on: other configs are read through them and cache keys are made with them${env}`,
   )
 }
 
@@ -567,6 +571,31 @@ function restoreBuiltins(before: BuiltinSnapshot): string[] {
   return changed
 }
 
+/**
+ * A first load's `process.env.X = …` gave every other project's task that
+ * value through `passThrough` and reached vx's own `VX_*` reads, while a
+ * repeat load, in a worker, left both unchanged: one config, two
+ * environments, by load order (D-76). Assigned back, not defined:
+ * `process.env` refuses `defineProperty`.
+ */
+function restoreEnv(before: Readonly<Record<string, string | undefined>>): string[] {
+  const changed: string[] = []
+  const live = process.env
+  for (const key of Object.keys(live)) {
+    if (live[key] === before[key]) continue
+    changed.push(`process.env.${key}`)
+    if (key in before) live[key] = before[key]
+    else delete live[key]
+  }
+  for (const key of Object.keys(before)) {
+    if (!(key in live)) {
+      changed.push(`process.env.${key}`)
+      live[key] = before[key]
+    }
+  }
+  return changed
+}
+
 function sameDescriptor(a: PropertyDescriptor, b: PropertyDescriptor): boolean {
   return (
     a.value === b.value &&