@vzn/vx 0.0.411 → 0.0.413

package/package.json

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

package/src/workspace/migration.ts

@@ -10,7 +10,7 @@ import { unlink } from 'node:fs/promises'
 import path from 'node:path'
 import { executablePath, relPosix, UserError } from '../util/index.js'
 import type { ProjectMeta } from './workspace.js'
-import { loadWorkspace, unreachedHint, unreachedPackages } from './workspace.js'
+import { loadWorkspace, reachesManifest, unreachedHint, unreachedPackages } from './workspace.js'
 import { WORKSPACE_CONFIG_FILENAMES } from './project-loader.js'
 
 /**
@@ -357,8 +357,10 @@ export async function applyMigration(args: ApplyMigrationArgs): Promise<number>
   // Globs that reach no package: "no scripts" was true and named nothing
   // to fix (M-42).
   const globs = workspace?.packageGlobs.filter((g) => g !== '.') ?? []
+  // Asked of the globs, not of `metas`: a nameless or shared-name member
+  // is matched yet absent from `metas` (M-46).
   const noMembers =
-    globs.length > 0 && metas.every((m) => path.resolve(m.dir) === path.resolve(root))
+    workspace !== undefined && globs.length > 0 && !(await reachesManifest(workspace))
       ? [
           `the workspace globs (${globs.map((g) => `"${g}"`).join(', ')}) match no package.json: add a package under one, or fix the glob`,
         ]

package/src/workspace/project-loader.ts

@@ -456,6 +456,7 @@ export async function loadProjectConfigs(
   // More than one evaluation in flight: a change seen after one load may
   // be another's.
   let overlapping = false
+  let tainted = false
   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.
@@ -500,7 +501,7 @@ export async function loadProjectConfigs(
     const changed = repeat
       ? []
       : [
-          ...restoreBuiltins(builtins),
+          ...restoreBuiltins(builtins, overlapping),
           ...restoreEnv(env),
           ...restoreCwd(cwd),
           ...restoreUmask(umask),
@@ -585,20 +586,30 @@ export async function loadProjectConfigs(
             ...restoreUmask(umask),
           ]
         : []
-    if (first?.failed instanceof ChangedInRound) {
+    // Overlapping loads check most built-ins only here, so a change one
+    // config made may have broken another's load: it is refused first, and
+    // nothing the round evaluated is stored.
+    const changedInRound =
+      first?.failed instanceof ChangedInRound
+        ? first.failed.changed
+        : overlapping && changed.length > 0
+          ? changed
+          : undefined
+    if (changedInRound !== undefined) {
+      tainted = true
       for (const i of misses) {
         const configPath = prepared[i]!.configPath
         const own = await builtinsChangedBy(configPath)
         if (own.length > 0) throw builtinsChanged(own, configPath)
       }
-      throw builtinsChanged(first.failed.changed)
+      throw builtinsChanged(changedInRound)
     }
     if (first !== undefined) throw first.failed
     if (changed.length > 0) throw builtinsChanged(changed)
     return results.map((r) => (r as Loaded).config)
   } finally {
     endRound()
-    if (store !== undefined) {
+    if (store !== undefined && !tainted) {
       if (evals.length > 0) {
         if (store.putConfigEvals !== undefined) store.putConfigEvals(evals)
         else for (const [k, json] of evals) store.putConfigEval(k, json)
@@ -655,10 +666,11 @@ interface OwnProperties {
 
 interface BuiltinSnapshot {
   readonly prims: Primitives
-  readonly props: readonly OwnProperties[]
+  /** Undefined for a watched name the snapshot leaves out. */
+  readonly props: readonly (OwnProperties | undefined)[]
 }
 
-function builtinSnapshot(): BuiltinSnapshot {
+function builtinSnapshot(leaveOut?: string): BuiltinSnapshot {
   const prims: Primitives = {
     ownKeys: Reflect.ownKeys,
     descriptorOf: Object.getOwnPropertyDescriptor,
@@ -668,8 +680,12 @@ function builtinSnapshot(): BuiltinSnapshot {
     same: Object.is,
     keyName: String,
   }
-  const props: OwnProperties[] = []
+  const props: (OwnProperties | undefined)[] = []
   for (let i = 0; i < WATCHED_BUILTINS.length; i++) {
+    if (WATCHED_BUILTINS[i]![0] === leaveOut) {
+      props[i] = undefined
+      continue
+    }
     const proto = WATCHED_BUILTINS[i]![1]
     const keys = prims.ownKeys(proto)
     const descriptors: PropertyDescriptor[] = []
@@ -727,15 +743,36 @@ function builtinsChanged(changed: readonly string[], configPath?: string): UserE
   )
 }
 
+/**
+ * The built-ins checked after each of several overlapping loads: the ones
+ * the loader itself reads through between loads (its promises, maps, sets,
+ * JSON and keys). The rest are checked once, at the round's end: all of
+ * them after every load was ~73 µs a config, a quarter of a cold load of
+ * 1,000 (2026-10-03). A lone load checks them all. By index, decided at
+ * module load: a lookup through a `Set` is one a config can replace (D-124).
+ */
+const EVERY_LOAD: readonly boolean[] = WATCHED_BUILTINS.map(([name]) =>
+  [
+    'Object.prototype',
+    'JSON',
+    'Promise.prototype',
+    'Map.prototype',
+    'Set.prototype',
+    'Bun.hash',
+  ].includes(name),
+)
+
 /** Puts back what changed since `before`, naming each property it put back. */
-function restoreBuiltins(before: BuiltinSnapshot | undefined): string[] {
+function restoreBuiltins(before: BuiltinSnapshot | undefined, everyLoadOnly = false): string[] {
   const changed: string[] = []
   if (before === undefined) return changed
   const p = before.prims
   for (let i = 0; i < WATCHED_BUILTINS.length; i++) {
     const name = WATCHED_BUILTINS[i]![0]
+    if (everyLoadOnly && !EVERY_LOAD[i]) continue
     const proto = WATCHED_BUILTINS[i]![1]
-    const was = before.props[i]!
+    const was = before.props[i]
+    if (was === undefined) continue
     const keys = p.ownKeys(proto)
     if (unchanged(p, proto, keys, was)) continue
     // Slow path, a change only: a linear lookup keeps it off `Map`.
@@ -890,7 +927,29 @@ export async function loadWorkspaceConfig(root: string): Promise<WorkspaceConfig
     const since = workspaceLoadedAt.get(configPath)
     if (since !== undefined) await refuseStaleWorkspaceImports(configPath, since)
     const startedAt = Date.now()
-    const mod = (await loadDefaultExport(configPath, 'Workspace', bytes)) as WorkspaceConfig
+    // The same guard a project config's first load has: the workspace config
+    // runs in this process too, and its `Object.prototype.exec` ran in a
+    // project's task under a key that never saw it (D-126). Its globals are
+    // left out: it loads first in every run, filtered or not, so none
+    // depends on what else loaded (D-122's case), and plugins' tests and
+    // tools hand state through them.
+    const builtins = builtinSnapshot('globalThis')
+    const env = { ...process.env }
+    const cwd = process.cwd()
+    const umask = currentUmask()
+    let mod: WorkspaceConfig
+    try {
+      mod = (await loadDefaultExport(configPath, 'Workspace', bytes)) as WorkspaceConfig
+    } finally {
+      const changed = [
+        ...restoreBuiltins(builtins),
+        ...restoreEnv(env),
+        ...restoreCwd(cwd),
+        ...restoreUmask(umask),
+      ]
+      // eslint-disable-next-line no-unsafe-finally -- the refusal outranks the load's own error
+      if (changed.length > 0) throw builtinsChanged(changed, configPath)
+    }
     // Checked again once awaited, as a project config is: a Promise default
     // passed the first check, and `Promise.resolve(null)` crashed the
     // validator with a stack while `Promise.resolve(42)` loaded as no

package/src/workspace/workspace.ts

@@ -395,6 +395,28 @@ export function memberBaseDirs(workspace: Workspace): string[] {
   return [...bases]
 }
 
+/**
+ * True when a member glob reaches a `package.json` other than the root's,
+ * addressable or not: a nameless manifest, or two sharing a name, is
+ * matched and left out, not unmatched (M-46).
+ */
+export async function reachesManifest(workspace: Workspace): Promise<boolean> {
+  const { positive, negative } = splitPackageGlobs(workspace.packageGlobs)
+  const root = path.resolve(workspace.root)
+  for (const pattern of positive) {
+    for (const dir of await memberDirs(workspace.root, pattern)) {
+      if (path.resolve(dir) === root) continue
+      if (negative.length > 0 && excludedBy(relPosix(workspace.root, dir), negative)) continue
+      try {
+        if ((await stat(path.join(dir, 'package.json'))).isFile()) return true
+      } catch (err) {
+        absent(err, undefined)
+      }
+    }
+  }
+  return false
+}
+
 /**
  * The directories a workspace glob names. For the `<dir>/*` shape this is
  * one readdir of `<dir>` — the same answer `Bun.Glob` gives, at a third of