@vzn/vx 0.0.50 → 0.0.51

package/src/workspace/project-loader.ts

@@ -1,10 +1,16 @@
+import { realpathSync, statSync } from 'node:fs'
 import path from 'node:path'
 import type { ProjectConfig, WorkspaceConfig } from '../config.js'
 import { UserError, xxh3hex } from '../util/index.js'
 import { validateProjectConfig, validateWorkspace } from './config-schema.js'
 import { beginEvalRound, evaluateConfigFresh } from './config-eval.js'
 import { hasEsmExport, unprovidedBareImports } from './config-imports.js'
-import { configEvalKey, configEvalKeyFromClosure, type ConfigEvalStore } from './config-cache.js'
+import {
+  configEvalKey,
+  configEvalKeyFromClosure,
+  configImports,
+  type ConfigEvalStore,
+} from './config-cache.js'
 import { readOnce } from './load-reads.js'
 
 // The validator lives in config-schema.ts; re-exported so a reader that
@@ -420,6 +426,41 @@ export async function loadProjectConfig(
   return config!
 }
 
+/** When this process first began loading each workspace config, in ms. */
+const workspaceLoadedAt = new Map<string, number>()
+
+/**
+ * A repeat load in one process (`vx mcp`'s every call, `vx watch`'s every
+ * cycle) busts the workspace config's own URL, but Bun answers what it
+ * imports from the module registry: an edited local plugin kept its first
+ * version and `listTasks` served its old tasks with no word (item 1046).
+ * Bun cannot evaluate an imported module again, so the load is refused,
+ * naming the file, as `vx watch` already says when it sees the edit. Only
+ * a repeat load pays for the walk; a CLI verb loads once.
+ */
+async function refuseStaleWorkspaceImports(configPath: string, since: number): Promise<void> {
+  for (const file of await configImports(configPath)) {
+    let mtime: number
+    try {
+      mtime = statSync(file).mtimeMs
+    } catch {
+      continue
+    }
+    // `since` is whole milliseconds and an mtime is not: a file written in
+    // the millisecond the first load began (1000.4 against 1000) read as
+    // changed, and the control reload was refused one run in ten. An edit
+    // inside that millisecond is one the load may have read anyway.
+    if (Math.floor(mtime) > since) {
+      // The walk names real paths: a root reached through a symlink (macOS's
+      // temp dir) named `../target/helper.mjs` from the link.
+      const from = path.dirname(realpathSync(configPath))
+      throw new UserError(
+        `${path.basename(configPath)} imports ${path.relative(from, file)}, which changed after this process loaded it; a running process cannot evaluate an imported module again — restart it to apply the edit`,
+      )
+    }
+  }
+}
+
 /**
  * Find and load `vx.workspace.{ts,mts,js,mjs}` from the workspace
  * root. Returns `null` if no such file exists (the common case;
@@ -430,8 +471,19 @@ export async function loadWorkspaceConfig(root: string): Promise<WorkspaceConfig
   for (const configPath of WORKSPACE_CONFIG_FILENAMES.map((f) => path.join(root, f))) {
     const bytes = await readOnce(undefined, configPath)
     if (bytes === null) continue
+    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
+    // 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
+    // config at all (D-6).
+    assertDefaultObject(mod, 'Workspace', configPath)
     validateWorkspace(mod, configPath)
+    // Set by a load that succeeded: a failed one may have left nothing in
+    // the registry, and its fix must not be refused.
+    if (since === undefined) workspaceLoadedAt.set(configPath, startedAt)
     return mod
   }
   return null

package/src/workspace/workspace.ts

@@ -416,25 +416,65 @@ async function memberDirs(root: string, pattern: string): Promise<string[]> {
     }
     return dirs
   }
-  const globPattern = normalized === '' ? 'package.json' : `${normalized}/package.json`
-  const glob = new Bun.Glob(globPattern)
   const dirs: string[] = []
-  // A linked member is a member, as the readdir path above has it:
-  // `packages/*` found `packages/b -> ../ext/b` while `packages/{a,b}` and
-  // `pack*/*` did not (item 987). Followed only where the depth is bounded:
-  // under `**` the scan would walk every pnpm `node_modules` link.
-  const followSymlinks = !normalized.includes('**')
-  for await (const rel of glob.scan({ cwd: root, onlyFiles: true, dot: false, followSymlinks })) {
-    // Skip nested node_modules — workspace package globs shouldn't
-    // ever reach into them, but a pathological pattern like `**`
-    // would. Avoid splitting the path on the hot loop.
-    if (rel.includes(`${path.sep}node_modules${path.sep}`)) continue
-    if (rel.startsWith(`node_modules${path.sep}`)) continue
-    dirs.push(path.dirname(path.resolve(root, rel)))
+  // `Bun.Glob`'s scan finds nothing for a brace whose alternatives hold a
+  // slash, though its `match` reads one: `packages/{a,nested/b}` listed
+  // neither package, and both ran under no verb while the root still
+  // claimed them (D-2). Such a pattern is scanned as its expansions.
+  for (const expanded of slashBraceExpansions(normalized)) {
+    const globPattern = expanded === '' ? 'package.json' : `${expanded}/package.json`
+    const glob = new Bun.Glob(globPattern)
+    // A linked member is a member, as the readdir path above has it:
+    // `packages/*` found `packages/b -> ../ext/b` while `packages/{a,b}` and
+    // `pack*/*` did not (item 987). Followed only where the depth is bounded:
+    // under `**` the scan would walk every pnpm `node_modules` link.
+    const followSymlinks = !expanded.includes('**')
+    for await (const rel of glob.scan({ cwd: root, onlyFiles: true, dot: false, followSymlinks })) {
+      // Skip nested node_modules — workspace package globs shouldn't
+      // ever reach into them, but a pathological pattern like `**`
+      // would. Avoid splitting the path on the hot loop.
+      if (rel.includes(`${path.sep}node_modules${path.sep}`)) continue
+      if (rel.startsWith(`node_modules${path.sep}`)) continue
+      dirs.push(path.dirname(path.resolve(root, rel)))
+    }
   }
   return dirs
 }
 
+/**
+ * `pattern` with its first brace group expanded, recursively, while that
+ * group holds a `/`; any other pattern as itself, since `Bun.Glob`
+ * expands a slash-free brace on its own. An unbalanced or escaped brace
+ * is left to the glob.
+ */
+function slashBraceExpansions(pattern: string): string[] {
+  if (pattern.includes('\\')) return [pattern]
+  for (let open = pattern.indexOf('{'); open !== -1; open = pattern.indexOf('{', open + 1)) {
+    let depth = 0
+    const cuts: number[] = []
+    let close = -1
+    for (let i = open; i < pattern.length && close === -1; i++) {
+      const c = pattern[i]
+      if (c === '{') depth++
+      else if (c === '}' && --depth === 0) close = i
+      else if (c === ',' && depth === 1) cuts.push(i)
+    }
+    if (close === -1) return [pattern]
+    const body = pattern.slice(open + 1, close)
+    if (cuts.length === 0 || !body.includes('/')) continue
+    const head = pattern.slice(0, open)
+    const tail = pattern.slice(close + 1)
+    const bounds = [open, ...cuts, close]
+    const out: string[] = []
+    for (let k = 0; k + 1 < bounds.length; k++) {
+      const alt = pattern.slice(bounds[k]! + 1, bounds[k + 1])
+      out.push(...slashBraceExpansions(head + alt + tail))
+    }
+    return [...new Set(out)]
+  }
+  return [pattern]
+}
+
 /**
  * The project's config file, by `PROJECT_CONFIG_FILENAMES` precedence, or null.
  *