@vzn/vx 0.0.596 → 0.0.598

package/src/workspace/project-loader.ts

@@ -9,6 +9,7 @@ import {
   CONFIG_EXIT,
   evalBudgetMs,
   evaluateConfigFresh,
+  thrownValueMessage,
   WATCHED_BUILTIN_NAMES,
 } from './config-eval.js'
 import { hasEsmExport, unprovidedBareImports } from './config-imports.js'
@@ -86,7 +87,12 @@ function assertDefaultObject(mod: unknown, kind: string, configPath: string): vo
 const heldSources = new Map<string, { source: string; uses: number }>()
 let serving = false
 
-const HELD_QUERY = /\?vx-held=([0-9a-f]+)$/
+const HELD_QUERY = /\?vx-(?:held|literal)=([0-9a-f]+)$/
+
+// Bun's resolver reads `\` as a separator, even in a file: URL, so a
+// config under `a\b` was looked for under `a/b`. Resolving it here keeps
+// the path as written; only the served load can take it.
+const LITERAL_QUERY = /\?vx-literal=[0-9a-f]+$/
 
 function serveHeldSources(): void {
   if (serving) return
@@ -94,6 +100,7 @@ function serveHeldSources(): void {
   Bun.plugin({
     name: 'vx-config-bytes',
     setup(build) {
+      build.onResolve({ filter: LITERAL_QUERY }, (args) => ({ path: args.path, namespace: 'file' }))
       build.onLoad({ filter: HELD_QUERY }, (args) => ({
         contents: heldSources.get(HELD_QUERY.exec(args.path)![1]!)!.source,
         loader: /\.[cm]?ts\?/.test(args.path) ? 'ts' : 'js',
@@ -135,7 +142,7 @@ const COMMONJS_HINT =
   /\b(?:module|exports|require|this|__dirname|__filename)\b|\\|\bexport\s*=(?!=)/
 
 /** vx's module-cache query, which no user wrote: stripped from anything shown to them. */
-const BUST_QUERY = /\?vx-(?:bust|held)=[^'"\s]*/g
+const BUST_QUERY = /\?vx-(?:bust|held|literal)=[^'"\s]*/g
 
 // Bun has native TS / ESM execution — no transpiler dep needed. We fold
 // a short content hash into the import URL as a cache-bust key so that:
@@ -156,10 +163,18 @@ async function loadDefaultExport(
   // URL yet, and a repeat load (the one that could replay an evaluation
   // made under earlier env values) re-evaluates in a worker instead
   // (`loadedConfigs`, item 678).
+  const literal = configPath.includes('\\')
   const source =
-    kind === 'Project' ? servableSource(bytes, /\.[cm]?ts$/.test(configPath) ? 'ts' : 'js') : null
+    kind === 'Project' || literal
+      ? servableSource(bytes, /\.[cm]?ts$/.test(configPath) ? 'ts' : 'js')
+      : null
+  if (literal && source === null) {
+    throw new UserError(
+      `${kind} config ${configPath} sits under a path that holds a backslash, which Bun loads only as an ES module in UTF-8`,
+    )
+  }
   const hash = xxh3hex(bytes)
-  const specifier = `${configPath}?vx-${source !== null ? 'held' : 'bust'}=${hash}`
+  const specifier = `${configPath}?vx-${literal ? 'literal' : source !== null ? 'held' : 'bust'}=${hash}`
   if (source !== null) {
     serveHeldSources()
     holdSource(hash, source)
@@ -191,7 +206,7 @@ async function loadDefaultExport(
     if (err instanceof Error && err.stack !== undefined) {
       err.stack = err.stack.replaceAll(specifier, configPath).replace(BUST_QUERY, '')
     }
-    throw configLoadError(err, configPath, kind) ?? err
+    throw loadFailure(err, configPath, kind)
   } finally {
     clearTimeout(deadline)
     unguard()
@@ -341,6 +356,16 @@ export function configLoadError(err: unknown, configPath: string, kind: string):
   return null
 }
 
+/** What a failed load throws: Bun's own errors and non-Error throws as user errors, the rest as thrown. */
+function loadFailure(err: unknown, configPath: string, kind: string): unknown {
+  const user = configLoadError(err, configPath, kind)
+  if (user !== null) return user
+  if (err !== null && typeof err === 'object' && typeof (err as Error).message === 'string') {
+    return err
+  }
+  return new UserError(thrownValueMessage(kind, configPath, Bun.inspect(err, { compact: true })))
+}
+
 export interface LoadProjectConfigOptions {
   /** Observe the CURRENT environment: no eval cache, even when `evalCache` is passed. */
   fresh?: boolean
@@ -523,7 +548,7 @@ export async function loadProjectConfigs(
     if (repeat) refuseUnprovidedImports(bytes!, configPath, 'Project')
     const mod = repeat
       ? await evaluateConfigFresh(configPath).catch((err: unknown) => {
-          throw configLoadError(err, configPath, 'Project') ?? err
+          throw loadFailure(err, configPath, 'Project')
         })
       : await loadDefaultExport(configPath, 'Project', bytes!)
     // Before anything reads through them: a replaced `Array.prototype.includes`
@@ -812,6 +837,7 @@ const BUN_MEMBERS_VX_READS: readonly PropertyKey[] = [
   'env',
   'file',
   'hash',
+  'inspect',
   'main',
   'nanoseconds',
   'plugin',
@@ -820,6 +846,7 @@ const BUN_MEMBERS_VX_READS: readonly PropertyKey[] = [
   'semver',
   'serve',
   'sleep',
+  'sleepSync',
   'spawn',
   'spawnSync',
   'stderr',

package/src/workspace/workspace.ts

@@ -290,13 +290,17 @@ async function readRootManifests(
     )
   }
   if (ws === undefined || ws === null) return { globs: ['.'], catalogs }
+  // bun's `{ catalog }` and yarn's `{ nohoist }` name no members, and both
+  // managers run the root alone; vx refused them as no array (D-151).
+  if (typeof ws === 'object' && !Array.isArray(ws) && !('packages' in ws)) {
+    return { globs: ['.'], catalogs }
+  }
   if (ws && typeof ws === 'object' && !Array.isArray(ws) && 'packages' in ws) {
-    const globs = assertGlobList(
-      (ws as { packages?: unknown }).packages ?? [],
-      pkgPath,
-      'workspaces.packages',
-    )
-    return { globs, catalogs }
+    const packages = (ws as { packages?: unknown }).packages
+    // Yarn 1 and 4 run the root alone under `packages: null`; read as an
+    // empty list, the root was no project and every verb ran nothing (D-150).
+    if (packages === null) return { globs: ['.'], catalogs }
+    return { globs: assertGlobList(packages, pkgPath, 'workspaces.packages'), catalogs }
   }
   return { globs: assertGlobList(ws, pkgPath, 'workspaces'), catalogs }
 }
@@ -454,13 +458,27 @@ function extglobRefusal(pattern: string, file: string, field: string): UserError
  * to the workspace root.
  */
 export function resolveCacheDir(root: string, config: WorkspaceConfig | null): string {
-  const rel = config?.cacheDir ?? (process.env['VX_CACHE_DIR'] || path.join('.vx', 'cache'))
+  const env = process.env['VX_CACHE_DIR']
+  // `cacheDir: '   '` is refused at load (X-22); the variable made the same
+  // directory named in spaces at the root (D-160).
+  if (config?.cacheDir === undefined && env !== undefined && env !== '' && env.trim() === '') {
+    throw new UserError('VX_CACHE_DIR is only whitespace — name a directory, or unset it')
+  }
+  const rel = config?.cacheDir ?? (env || path.join('.vx', 'cache'))
+  const home = process.env['HOME'] || homedir()
   // No shell expands `~` in a config string or a quoted variable, and
   // `'~/.cache/vx'` made a directory named `~` in the workspace.
-  if (rel.startsWith('~/')) {
-    return path.join(process.env['HOME'] || homedir(), rel.slice(1))
+  const dir =
+    rel === '~' || rel.startsWith('~/') ? path.join(home, rel.slice(1)) : path.resolve(root, rel)
+  // The cache writes a `*` .gitignore beside its index: a bare `~` made a
+  // directory named `~`, and expanded it would land in home itself (D-153).
+  if (path.resolve(dir) === path.resolve(home)) {
+    const source = config?.cacheDir !== undefined ? 'cacheDir' : 'VX_CACHE_DIR'
+    throw new UserError(
+      `${source} ${JSON.stringify(rel)} is the home directory itself, where the cache's \`*\` .gitignore and index would land — name a directory under it, like '~/.cache/vx'`,
+    )
   }
-  return path.resolve(root, rel)
+  return dir
 }
 
 /**
@@ -711,12 +729,17 @@ async function readManifest(root: string, dir: string, file: string): Promise<st
     )
     if (searchable) unreadable(err, file)
     process.stderr.write(
-      `vx: ${relPosix(root, dir)} is not readable by this user — skipped, with any project in it\n`,
+      `vx: ${shownDir(root, dir)} is not readable by this user — skipped, with any project in it\n`,
     )
     return null
   }
 }
 
+/** `dir` as a discovery line names it: the root's own path is '' (D-127, D-154). */
+function shownDir(root: string, dir: string): string {
+  return relPosix(root, dir) || 'the workspace root'
+}
+
 export async function listProjects(workspace: Workspace): Promise<ProjectMeta[]> {
   return discoverProjects(workspace)
 }
@@ -769,7 +792,7 @@ export async function discoverProjects(
         // same flight as the failed read, so naming it costs nothing.
         if (configPath !== null) {
           process.stderr.write(
-            `vx: ${relPosix(workspace.root, dir)} has a vx config but no package.json — skipped: vx names a project by its package.json "name"\n`,
+            `vx: ${shownDir(workspace.root, dir)} has a vx config but no package.json — skipped: vx names a project by its package.json "name"\n`,
           )
         }
         return null
@@ -800,9 +823,8 @@ export async function discoverProjects(
       // fine for a dir that declares no tasks; a dir with a vx config was
       // meant to run.
       if (configPath !== null) {
-        const rel = relPosix(workspace.root, dir)
         process.stderr.write(
-          `vx: ${rel === '' ? 'the workspace root' : rel} has a vx config but its package.json has no "name" — skipped\n`,
+          `vx: ${shownDir(workspace.root, dir)} has a vx config but its package.json has no "name" — skipped\n`,
         )
       }
       continue