@vzn/vx 0.0.595 → 0.0.597

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'
@@ -127,10 +128,12 @@ function servableSource(bytes: Uint8Array, loader: 'ts' | 'js'): string | null {
 }
 
 // What makes Bun run a file as CommonJS is one of these names at the top
-// level (an escaped `\u006dodule` too, so any backslash counts). Source
+// level (an escaped `\u006dodule` too, so any backslash counts), or
+// TypeScript's `export =`, which spells none of them. Source
 // with none of them runs as a module whichever path loads it, so it skips
 // the parse: 16–20 µs a config, 1,000 cold configs (2026-10-03).
-const COMMONJS_HINT = /\b(?:module|exports|require|this|__dirname|__filename)\b|\\/
+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
@@ -189,7 +192,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()
@@ -339,6 +342,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
@@ -521,7 +534,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`
@@ -810,6 +823,7 @@ const BUN_MEMBERS_VX_READS: readonly PropertyKey[] = [
   'env',
   'file',
   'hash',
+  'inspect',
   'main',
   'nanoseconds',
   'plugin',
@@ -818,6 +832,7 @@ const BUN_MEMBERS_VX_READS: readonly PropertyKey[] = [
   'semver',
   'serve',
   'sleep',
+  'sleepSync',
   'spawn',
   'spawnSync',
   'stderr',

package/src/workspace/repo-id.ts

@@ -13,6 +13,7 @@ import {
   lstatSync,
   openSync,
   readFileSync,
+  realpathSync,
   statSync,
 } from 'node:fs'
 import path from 'node:path'
@@ -25,12 +26,20 @@ import path from 'node:path'
  * git: those share nothing.
  */
 export async function repoIdOf(root: string): Promise<string | null> {
-  const located = locateGitDir(root)
+  // Git walks the physical path; the logical one found no `.git` through a
+  // symlink from outside the repository, and an alias inside it another id.
+  let real: string
+  try {
+    real = realpathSync(root)
+  } catch {
+    real = path.resolve(root)
+  }
+  const located = locateGitDir(real)
   if (located === null) return null
   const identity =
     (await remoteIdentity(root, located.commonDir)) ?? (await firstCommit(located.commonDir, root))
   if (identity === null) return null
-  const rel = path.relative(located.gitRoot, path.resolve(root)).split(path.sep).join('/')
+  const rel = path.relative(located.gitRoot, real).split(path.sep).join('/')
   const key = sha256(`${identity}#${rel}`)
   return sha256(key).slice(0, 16)
 }
@@ -108,11 +117,40 @@ function readOwnedFile(p: string): string | null {
   }
 }
 
-/** The remote's identity from the config file, else from `git remote -v`. */
+/**
+ * The remote's identity from the config file, else from `git remote -v`
+ * when the file cannot settle it: a remote none of whose urls parse (a
+ * rewrite may live in a file vx does not read, as Nx asks git), or
+ * remotes git could read from `config.worktree`.
+ */
 async function remoteIdentity(root: string, commonDir: string): Promise<string | null> {
   const config = readOwnedFile(path.join(commonDir, 'config'))
   const remotes = config === null ? null : parseGitConfigRemotes(config)
-  const urls = remotes ?? (await remotesFromGit(root))
+  if (remotes !== null) {
+    const picked = pickRemote(remotes)
+    // A remote-less repo with nothing to pull one from elsewhere spawns
+    // nothing: git would answer the same, and that spawn was a cost per run.
+    if (picked !== null || (remotes.length === 0 && !worktreeConfigOn(config!))) return picked
+  }
+  return pickRemote(await remotesFromGit(root))
+}
+
+/** `extensions.worktreeConfig` set: git reads `config.worktree` too. */
+function worktreeConfigOn(contents: string): boolean {
+  let inExtensions = false
+  for (const raw of contents.split('\n')) {
+    const line = raw.trim()
+    if (line.startsWith('[')) {
+      inExtensions = /^\[\s*extensions\s*\]/i.test(line)
+      continue
+    }
+    const m = /^worktreeconfig\s*(?:=\s*(\S*))?/i.exec(line)
+    if (inExtensions && m !== null && !/^(false|no|off|0)$/i.test(m[1] ?? 'true')) return true
+  }
+  return false
+}
+
+function pickRemote(urls: [string, string][]): string | null {
   const found = new Map<string, string>()
   let first: string | null = null
   for (const [name, url] of urls) {

package/src/workspace/workspace.ts

@@ -1,4 +1,4 @@
-import { constants, type Dirent } from 'node:fs'
+import { constants, existsSync, type Dirent } from 'node:fs'
 import { access, readdir, realpath, stat } from 'node:fs/promises'
 import { homedir } from 'node:os'
 import path from 'node:path'
@@ -267,11 +267,13 @@ async function readRootManifests(
       }
       catalogs = catalogsOf([parsed])
       const packages = (parsed as { packages?: unknown }).packages
-      if (packages !== undefined) {
+      // A list commented out leaves `packages:` null, which pnpm reads as
+      // absent; vx refused it as "must be an array" (D-149).
+      if (packages !== undefined && packages !== null) {
         return { globs: assertGlobList(packages, yamlPath, 'packages'), catalogs }
       }
     }
-    // No `packages:`: pnpm 10 keeps its settings and catalogs in this file
+    // No `packages:` (or an empty one): pnpm 10 keeps its settings and catalogs in this file
     // for a single-package repo too. The root's package.json decides, as it
     // would without the file; read as an empty list, the root found zero
     // projects and every verb ran nothing and exited 0 (item 984).
@@ -288,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 }
 }
@@ -348,8 +354,13 @@ export async function unreachedPackages(workspace: Workspace): Promise<string[]>
   return found.sort()
 }
 
-/** The line for `unreachedPackages`' finding: the cause, the packages, the glob to add. */
-export function unreachedHint(unreached: readonly string[]): string {
+/**
+ * The line for `unreachedPackages`' finding: the cause, the packages, the
+ * glob to add, and where. A `pnpm-workspace.yaml` with no `packages:` (pnpm
+ * keeps its settings there) is where pnpm reads the globs: the hint said
+ * there was no such file and named package.json, beside ngrx's (2026-10-07).
+ */
+export function unreachedHint(unreached: readonly string[], root: string): string {
   const n = unreached.length
   const shown = unreached.slice(0, 3).join(', ') + (n > 3 ? ` and ${n - 3} more` : '')
   const globs = [
@@ -357,11 +368,11 @@ export function unreachedHint(unreached: readonly string[]): string {
   ]
     .map((g) => `"${g}"`)
     .join(', ')
-  return (
-    `package.json declares no \`workspaces\` (and there is no pnpm-workspace.yaml), so the root is the only project ` +
-    `and ${n} package.json below it ${n === 1 ? 'is' : 'are'} not: ${shown}. ` +
-    `Add \`"workspaces": [${globs}]\` to package.json and re-run.`
-  )
+  const rest = `so the root is the only project and ${n} package.json below it ${n === 1 ? 'is' : 'are'} not: ${shown}.`
+  return existsSync(path.join(root, 'pnpm-workspace.yaml'))
+    ? `pnpm-workspace.yaml lists no \`packages\`, ${rest} Add \`packages: [${globs}]\` to pnpm-workspace.yaml and re-run.`
+    : `package.json declares no \`workspaces\` (and there is no pnpm-workspace.yaml), ${rest} ` +
+        `Add \`"workspaces": [${globs}]\` to package.json and re-run.`
 }
 
 /**
@@ -447,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
 }
 
 /**
@@ -704,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)
 }
@@ -762,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
@@ -793,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