@vzn/vx 0.0.651 → 0.0.653

package/src/workspace/filter.ts

@@ -22,7 +22,7 @@
 // given, the base set is "all projects" and excluded packages are removed.
 
 import path from 'node:path'
-import { BUN_GLOB_WILDCARDS, relPosix, UserError } from '../util/index.js'
+import { BUN_GLOB_WILDCARDS, hasControl, printable, relPosix, UserError } from '../util/index.js'
 import type { PackageGraph } from './package-graph.js'
 import { canonicalDir } from './canonical-dir.js'
 import type { ProjectMeta } from './workspace.js'
@@ -76,6 +76,13 @@ export function parseFilter(
   /** The filter as typed, when `raw` is the `./` reading of a name (`dirFallback`). */
   typed = raw,
 ): ParsedFilter {
+  // No project name, path or git ref holds one; echoed raw, a newline split
+  // the refusal in two and an escape painted the terminal.
+  if (hasControl(raw)) {
+    throw new UserError(
+      `filter "${printable(raw)}" holds a control character: no project name, path or git ref does`,
+    )
+  }
   let s = raw
   const negate = s.startsWith('!')
   if (negate) s = s.slice(1)
@@ -124,9 +131,18 @@ export function parseFilter(
   if (scoped !== null && !scoped[1]!.startsWith('./') && scoped[1] !== '.') {
     s = scoped[1]!
     gitSince = scoped[2]!
+    // Neither Turbo nor pnpm reads it (both keep `^...` in the name):
+    // `{dir}^...[ref]` dropped the `^...` and selected the inverse, and
+    // the name spellings matched nothing.
+    if (s.endsWith('^...'))
+      throw new UserError(
+        `filter "${raw}" puts ^... before a git ref, which no form reads: ` +
+          `<sel>...[<ref>] is <sel> where it or a dependency changed, ` +
+          `<sel>[<ref>]^... the dependencies of the changed ones`,
+      )
     // The name glob kept the `...` and matched nothing (create-t3-turbo,
     // `@acme/*...[HEAD]`).
-    if (s.endsWith('...') && !s.endsWith('^...')) {
+    if (s.endsWith('...')) {
       s = s.slice(0, -3)
       sinceViaDeps = true
     }

package/src/workspace/index.ts

@@ -28,6 +28,7 @@ export {
   lockKey,
   NO_LOCK,
   readLockfile,
+  lockfileWrite,
   writeLockfile,
   type Lockfile,
   type LockedProject,
@@ -38,7 +39,7 @@ export {
   parseDependenciesLock,
   readDependenciesLock,
   recordedDigests,
-  writeDependenciesLock,
+  dependenciesLockWrite,
   type DependenciesLock,
 } from './dependencies-lock.js'
 export {
@@ -60,6 +61,7 @@ export {
   validateWorkspace,
 } from './config-schema.js'
 export { configImports } from './config-imports.js'
+export { repoIdsOf } from './repo-id.js'
 export {
   checkProjectNames,
   findWorkspaceRoot,

package/src/workspace/json-data.ts

@@ -8,10 +8,14 @@
 // worker's, which never saw it — or, where the validator does not type
 // the value, it was silently outside the key on both. So every path
 // refuses it, before schema validation, by this one rule: the first load
-// on the live object (`validateProjectConfig`), the worker before its
+// on the live object before its JSON copy (project-loader.ts), the worker before its
 // `JSON.stringify` (config-eval.ts). The worker embeds `nonJsonPaths` by its source text, so
 // the function must stay self-contained: no import, no module-scope name.
 //
+// JSON writes only own enumerable string keys: a symbol key or a
+// non-enumerable property vanished from the key and the lock
+// (`"config":{}`), so it is refused too.
+//
 // An `undefined` PROPERTY is allowed: JSON drops it, the validator reads
 // it as absent, and configs write it with conditional spreads. Inside an
 // array it is refused, because JSON writes it as `null`.
@@ -29,13 +33,20 @@ export function nonJsonPaths(value: unknown): NonJsonValue[] {
   // The key or index at each level, rendered only for a finding: the walk
   // runs on every first load, and a path string built per node cost three
   // times the schema check itself.
-  const keys: Array<string | number> = []
+  const keys: Array<string | number | symbol> = []
   // The objects on the path to the one being walked: a cycle throws in
   // `JSON.stringify` and would recurse here forever. A DAG is data.
   const ancestors: object[] = []
+  const MAX_DEPTH = 256
   const found = (is: string): void => {
     let path = ''
-    for (const k of keys) path += typeof k === 'number' ? `[${k}]` : path === '' ? k : `.${k}`
+    for (const k of keys)
+      path +=
+        typeof k === 'number' || typeof k === 'symbol'
+          ? `[${String(k)}]`
+          : path === ''
+            ? k
+            : `.${k}`
     out.push({ path: path === '' ? 'the default export' : path, is })
   }
   const walk = (v: unknown, inArray: boolean): void => {
@@ -45,6 +56,12 @@ export function nonJsonPaths(value: unknown): NonJsonValue[] {
     else if (typeof v === 'number' && !Number.isFinite(v)) found(String(v))
     else if (v === undefined && inArray) found('undefined in an array, which JSON writes as null')
     else if (typeof v === 'object' && v !== null) {
+      // Deeper, the walk and `JSON.stringify` overflowed the stack: a
+      // config 100,000 levels deep was vx's own RangeError (VX_E_INTERNAL).
+      if (ancestors.length >= MAX_DEPTH) {
+        found(`nested deeper than ${MAX_DEPTH} levels`)
+        return
+      }
       if (ancestors.includes(v)) {
         found('a cyclic reference')
         return
@@ -57,6 +74,13 @@ export function nonJsonPaths(value: unknown): NonJsonValue[] {
           walk(v[i], true)
           keys.pop()
         }
+        // Symbols only: listing an array's own names allocates every index
+        // string, +1-4% on a 20k-task lock, for a named property no config writes.
+        for (const key of Object.getOwnPropertySymbols(v)) {
+          keys.push(key)
+          found('a symbol key, which JSON drops')
+          keys.pop()
+        }
         ancestors.pop()
         return
       }
@@ -71,16 +95,18 @@ export function nonJsonPaths(value: unknown): NonJsonValue[] {
         return
       }
       ancestors.push(v)
-      for (const key of Object.keys(v)) {
+      for (const key of Reflect.ownKeys(v)) {
         keys.push(key)
         // Read by descriptor: a getter is code, and each read may answer
         // differently. `vx show` read one three times, so the key, the
         // check and the command could each see another value, and a
         // throwing one surfaced as vx's own stack (D-67). Never called here.
-        const d = Object.getOwnPropertyDescriptor(v, key)
-        if (d !== undefined && d.get !== undefined) found('a getter')
-        else if (d !== undefined && d.set !== undefined) found('a setter')
-        else walk(d?.value, false)
+        const d = Object.getOwnPropertyDescriptor(v, key) as PropertyDescriptor
+        if (typeof key === 'symbol') found('a symbol key, which JSON drops')
+        else if (d.enumerable !== true) found('a non-enumerable property, which JSON drops')
+        else if (d.get !== undefined) found('a getter')
+        else if (d.set !== undefined) found('a setter')
+        else walk(d.value, false)
         keys.pop()
       }
       ancestors.pop()

package/src/workspace/lockfile.ts

@@ -11,11 +11,18 @@
 //     eval-free.
 //   - `vx lock --check` AUDITS it: full re-evaluation + deep equality.
 
-import { readFileSync } from 'node:fs'
-import { rename, rm } from 'node:fs/promises'
+import { readFileSync, statSync } from 'node:fs'
 import path from 'node:path'
 import type { ProjectConfig } from '../config.js'
-import { keysSorted, relPosix, UserError, xxh3, xxh3hex } from '../util/index.js'
+import {
+  keysSorted,
+  type PendingWrite,
+  relPosix,
+  UserError,
+  writeAllOrNone,
+  xxh3,
+  xxh3hex,
+} from '../util/index.js'
 import { VERSION } from '../version.js'
 import { validateProjectConfig } from './config-schema.js'
 import { PROJECT_CONFIG_FILENAMES } from './workspace.js'
@@ -38,6 +45,12 @@ export interface Lockfile {
    * by directory, so a name a plugin gives never invalidates the lock.
    */
   projects: Record<string, LockedProject>
+  /**
+   * Root-relative POSIX directories holding their own `.vx/workspace.*`,
+   * where every outer project's outputs stop. Absent when there is none, so a
+   * workspace without one locks the bytes it always did.
+   */
+  nestedWorkspaces?: string[]
   /** Written by `writeLockfile` from the bytes; never read off the object. */
   validated?: string
 }
@@ -101,7 +114,16 @@ export function lockDigest(lock: Lockfile): string | undefined {
  */
 export async function readLockfile(root: string): Promise<Lockfile | null> {
   const file = Bun.file(lockfilePath(root))
-  if (!(await file.exists())) return null
+  if (!(await file.exists())) {
+    // A directory reads as no file: `--check` said "run `vx lock`", which cannot write over it.
+    if (statSync(lockfilePath(root), { throwIfNoEntry: false })?.isDirectory()) {
+      throw new UserError(
+        `${LOCKFILE_NAME} is a directory — remove it and run \`vx lock\``,
+        'VX_E_LOCK',
+      )
+    }
+    return null
+  }
   let parsed: unknown
   let text: string
   try {
@@ -123,7 +145,7 @@ export async function readLockfile(root: string): Promise<Lockfile | null> {
   if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
     throw new UserError(`${LOCKFILE_NAME} must be a JSON object — re-run \`vx lock\``, 'VX_E_LOCK')
   }
-  const lock = parsed as { version?: unknown; projects?: unknown }
+  const lock = parsed as { version?: unknown; projects?: unknown; nestedWorkspaces?: unknown }
   if (lock.version !== LOCKFILE_VERSION) {
     throw new UserError(
       `${LOCKFILE_NAME} has unsupported version ${String(lock.version)} ` +
@@ -153,21 +175,47 @@ export async function readLockfile(root: string): Promise<Lockfile | null> {
       Array.isArray(entry) ||
       typeof file !== 'string' ||
       !PROJECT_CONFIG_FILENAMES.includes(file) ||
-      typeof config !== 'object' ||
-      config === null ||
-      Array.isArray(config)
+      !isObj(config) ||
+      // A run trusts these shapes: a string `name`, a `tags` list, a `tasks` object.
+      (config['name'] !== undefined && typeof config['name'] !== 'string') ||
+      (config['tags'] !== undefined && !Array.isArray(config['tags'])) ||
+      (config['tasks'] !== undefined && !isObj(config['tasks']))
     ) {
-      throw new UserError(
-        `${LOCKFILE_NAME}: entry for "${dir}" is malformed — re-run \`vx lock\``,
-        'VX_E_LOCK',
-      )
+      throw malformed(dir)
     }
   }
+  const nested = lock.nestedWorkspaces
+  if (
+    nested !== undefined &&
+    (!Array.isArray(nested) ||
+      nested.some((d) => typeof d !== 'string' || d === '.' || !isLockKey(d)))
+  ) {
+    throw new UserError(
+      `${LOCKFILE_NAME}: \`nestedWorkspaces\` must list directories under the workspace root — re-run \`vx lock\``,
+      'VX_E_LOCK',
+    )
+  }
   pooledIn(parsed as Pooled)
+  // After the pool is put back, as a task may be an index into it. A
+  // string `dependsOn` was walked per character: "dependsOn b#a".
+  for (const [dir, entry] of Object.entries(lock.projects as Record<string, LockedProject>)) {
+    const tasks = entry.config.tasks as Obj | undefined
+    for (const name in tasks) {
+      const t = tasks[name]
+      if (!isObj(t) || (t['dependsOn'] !== undefined && !Array.isArray(t['dependsOn'])))
+        throw malformed(dir)
+    }
+  }
   digests.set(parsed as Lockfile, xxh3hex(text))
   return parsed as Lockfile
 }
 
+const malformed = (dir: string): UserError =>
+  new UserError(
+    `${LOCKFILE_NAME}: entry for "${dir}" is malformed — re-run \`vx lock\``,
+    'VX_E_LOCK',
+  )
+
 /**
  * The project entries of a lock's bytes with its pool put back, or null
  * for bytes that do not parse as a lock: an entry compares across two
@@ -335,31 +383,32 @@ function taskKeysSorted(key: string, value: unknown): unknown {
   return Object.fromEntries(Object.entries(value).map(([name, task]) => [name, keysSorted(task)]))
 }
 
-export async function writeLockfile(root: string, lock: Lockfile): Promise<void> {
-  // Written beside its name and renamed over it: `Bun.write` truncates in
-  // place, so a run, or `vx watch` woken by the write
-  // itself (item 971), could read an empty or half-written lock and fail
-  // on "not valid JSON" (item 972).
-  const file = lockfilePath(root)
-  const tmp = `${file}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`
-  try {
-    // Minified: the file only vx reads, and it loads faster than pretty
-    // JSON (measured, 10k projects: 15.6 ms against 22.5 ms). `vx.lock.json`
-    // beside each config is the copy for people.
-    const sorted = JSON.parse(JSON.stringify(lock.projects, taskKeysSorted)) as Lockfile['projects']
-    const body = JSON.stringify({ version: lock.version, ...pooledOut(sorted) })
-    await Bun.write(tmp, `${body.slice(0, -1)},"validated":"${validatedDigest(body)}"}\n`)
-    await rename(tmp, file)
-  } catch (err) {
-    // Best effort: where the write was refused the temp cannot be named
-    // either (ENOTDIR), and that must not replace the refusal itself.
-    await rm(tmp, { force: true }).catch(() => {})
-    // The refusal names the file the user knows: a read-only checkout read
-    // `open '…/.vx/projects.lock.json.tmp-…'` where it had read the lock's own name.
-    const e = err as NodeJS.ErrnoException
-    if (typeof e.message === 'string') e.message = e.message.split(tmp).join(file)
-    if (e.path === tmp) e.path = file
-    throw err
+/**
+ * Written beside its name and renamed over it: `Bun.write` truncates in
+ * place, so a run, or `vx watch` woken by the write itself (item 971),
+ * could read an empty or half-written lock and fail on "not valid JSON"
+ * (item 972).
+ */
+export function writeLockfile(root: string, lock: Lockfile): Promise<void> {
+  return writeAllOrNone([lockfileWrite(root, lock)], root)
+}
+
+/** The lock's file and bytes, for `writeAllOrNone`. */
+export function lockfileWrite(root: string, lock: Lockfile): PendingWrite {
+  // Minified: the file only vx reads, and it loads faster than pretty
+  // JSON (measured, 10k projects: 15.6 ms against 22.5 ms). `vx.lock.json`
+  // beside each config is the copy for people.
+  const sorted = JSON.parse(JSON.stringify(lock.projects, taskKeysSorted)) as Lockfile['projects']
+  const nested = lock.nestedWorkspaces ?? []
+  const body = JSON.stringify({
+    version: lock.version,
+    ...(nested.length > 0 ? { nestedWorkspaces: nested } : {}),
+    ...pooledOut(sorted),
+  })
+  return {
+    file: lockfilePath(root),
+    text: `${body.slice(0, -1)},"validated":"${validatedDigest(body)}"}\n`,
+    shown: LOCKFILE_NAME,
   }
 }
 

package/src/workspace/migration.ts

@@ -5,11 +5,12 @@
 // whichever tool wrote it. Core knows no source format here: a mapper returns a
 // `MigrationPlan` and this file does the rest.
 
-import { existsSync, readFileSync } from 'node:fs'
+import { existsSync, readFileSync, realpathSync } from 'node:fs'
 import { unlink } from 'node:fs/promises'
 import path from 'node:path'
 import { workspaceFileWritten } from '../handoff.js'
 import {
+  checkIgnoreSync,
   DOT_VX_GITIGNORE,
   executablePath,
   gitEnv,
@@ -22,6 +23,31 @@ import * as ui from '../ui/index.js'
 import { VERSION } from '../version.js'
 import { WORKSPACE_CONFIG_FILENAMES } from './project-loader.js'
 
+/**
+ * The nearest existing directory at or above `dir` (under `root`) and its
+ * real path when that path is outside `realRoot`; none when it is inside.
+ */
+function linkOut(
+  root: string,
+  realRoot: string,
+  dir: string,
+): [link: string | undefined, real: string] {
+  for (let at = dir; ; at = path.dirname(at)) {
+    let real: string
+    try {
+      real = realpathSync(at)
+    } catch {
+      // quiet: not made yet; mkdir makes it a real directory under its parent
+      if (at === root) return [undefined, realRoot]
+      continue
+    }
+    const rel = path.relative(realRoot, real)
+    return rel === '..' || rel.startsWith(`..${path.sep}`) || path.isAbsolute(rel)
+      ? [at, real]
+      : [undefined, real]
+  }
+}
+
 /** The root config `vx init` writes outside a Turbo or Nx repo: no task yet. */
 export function starterProject(format: MigrationFormat): string {
   return format === 'ts'
@@ -42,6 +68,10 @@ export function isStarterConfig(file: string): boolean {
   }
 }
 
+/** A C0 or C1 control, or DEL. */
+// oxlint-disable-next-line no-control-regex
+const CONTROL = /[\x00-\x1f\x7f-\x9f]/g
+
 /**
  * Escape an arbitrary string into a single-quoted TS literal. Escapes
  * backslash + quote AND raw newlines/CR — a value with an embedded newline
@@ -55,7 +85,10 @@ export function quoteTsLiteral(s: string): string {
     .replaceAll('\\', '\\\\')
     .replaceAll("'", "\\'")
     .replaceAll('\n', '\\n')
-    .replaceAll('\r', '\\r')}'`
+    .replaceAll('\r', '\\r')
+    // Any other control as its escape: a script's raw ESC landed in the
+    // file as the byte, and `cat vx.config.ts` retitled the terminal.
+    .replace(CONTROL, (c) => `\\x${c.charCodeAt(0).toString(16).padStart(2, '0')}`)}'`
 }
 
 /**
@@ -239,8 +272,9 @@ export interface ApplyMigrationArgs {
    * the migrated workspace has its .vx/projects.lock.json and its graph rules checked
    * (2026-10-14). On success `said` is its line, shown as the
    * report's `lock` row; a refusal (a graph rule, a plugin not installed
-   * yet) prints above the report and the migration still succeeds: its
-   * files are written, and `vx lock` is the step to re-run.
+   * yet) prints above the report, the files stay written, `vx lock` is the
+   * step to re-run, and the exit is 1: a run reads only the lock, so the
+   * migration is not done (as `vx init`'s own path exits).
    */
   lock?: (root: string) => Promise<{ code: number; said: string }>
   /** Rows of what the tool did before the write, e.g. `['ran', 'bun add -d …']`. */
@@ -345,11 +379,23 @@ export async function applyMigration(args: ApplyMigrationArgs): Promise<number>
 
   // A plan is a mapper's reading of the repo's own files (an Nx node's
   // `root`, a workspace glob): one that names `../x` wrote outside it.
+  // A member directory linked out of the root is spelled inside it, so the
+  // real directory is asked too: core's discovery never loads a config
+  // there. `.vx` is not a project: its files are refused outside the
+  // root at the write (`refuseSymlink`).
+  const realRoot = realpathSync(root)
   for (const f of files) {
     const rel = relPosix(root, f.abs)
     if (rel === '..' || rel.startsWith('../') || path.isAbsolute(rel)) {
       throw new UserError(`${f.relPath}: outside the workspace root`)
     }
+    if (rel.startsWith('.vx/')) continue
+    const [link, real] = linkOut(root, realRoot, path.dirname(f.abs))
+    if (link !== undefined) {
+      throw new UserError(
+        `${f.relPath}: outside the workspace root (${relPosix(root, link)} resolves to ${real}); vx loads no project there`,
+      )
+    }
   }
 
   if (!dry && !force) {
@@ -389,8 +435,8 @@ export async function applyMigration(args: ApplyMigrationArgs): Promise<number>
       ui.print('out', ui.excerpt(f.relPath, f.contents))
     }
   } else if (!dry) {
-    for (const f of files) refuseSymlink(f.abs)
-    for (const f of files) await writeNoFollow(f.abs, f.contents)
+    for (const f of files) refuseSymlink(f.abs, root)
+    for (const f of files) await writeNoFollow(f.abs, f.contents, root)
     for (const f of replaced) await unlink(f)
     // The lock that follows loads its plugins from the file just written.
     workspaceFileWritten()
@@ -531,7 +577,7 @@ export async function applyMigration(args: ApplyMigrationArgs): Promise<number>
     lock === undefined || lock.code === 0 ? next : `fix the above, then vx lock and ${next}`
   rows.push(null, ['next', said])
   ui.print('out', ui.report(`${verb} ${VERSION}`, rows))
-  return 0
+  return lock === undefined || lock.code === 0 ? 0 : 1
 }
 
 /**
@@ -583,25 +629,7 @@ function ignoreAdvice(root: string, ignored: readonly string[], dry: boolean): s
 
 /** The paths (root-relative) git's ignore rules drop; none outside a work tree. */
 function gitIgnored(root: string, relPaths: readonly string[]): string[] {
-  if (relPaths.length === 0) return []
-  try {
-    const r = Bun.spawnSync({
-      cmd: [executablePath('git'), 'check-ignore', '--stdin', '-z'],
-      env: gitEnv(),
-      cwd: root,
-      stdin: Buffer.from(relPaths.map((p) => `${p}\0`).join('')),
-      stdout: 'pipe',
-      stderr: 'ignore',
-    })
-    // 0: some ignored; 1: none; anything else (no work tree): nothing to say.
-    if (r.exitCode !== 0) return []
-    return r.stdout
-      .toString()
-      .split('\0')
-      .filter((p) => p !== '')
-  } catch {
-    return []
-  }
+  return [...(checkIgnoreSync(root, relPaths) ?? [])]
 }
 
 function inGitWorkTree(root: string): boolean {
@@ -658,7 +686,7 @@ const EXAMPLE_BODY = `export default {
     build: {
       exec: { command: 'tsc -b' },
       dependsOn: ['^build'],
-      inputs: { files: ['src/**'] }, cache: { outputs: { files: ['dist/**'] } },
+      inputs: { files: ['src/**'] }, outputs: { files: ['dist/**'] }, cache: true,
     },
   },
 }`
@@ -747,7 +775,7 @@ function renderConfigFile(p: GeneratedProject, format: MigrationFormat): string
     // The suggested block sits in the task, commented: deleting `// `
     // after setting the real globs caches it, no copying from the TODO.
     const block =
-      t.task['cache'] === undefined
+      t.task['cache'] !== true
         ? t.todos.find(isCacheTodo)?.match(/^cache: add `(.+?)`/)?.[1]
         : undefined
     lines.push(
@@ -790,11 +818,10 @@ function ownConfigNamed(
   return {
     ...p,
     tasks: p.tasks.map((t) => {
-      const outputs = (t.task?.['cache'] as { outputs?: { files?: unknown } } | undefined)?.outputs
+      const outputs = t.task?.['outputs'] as { files?: unknown } | undefined
       if (!Array.isArray(outputs?.files) || !outputs.files.includes(planned)) return t
-      const cache = t.task!['cache'] as Record<string, unknown>
       const files = outputs.files.map((f: unknown) => (f === planned ? `!${name}` : f))
-      return { ...t, task: { ...t.task, cache: { ...cache, outputs: { ...outputs, files } } } }
+      return { ...t, task: { ...t.task, outputs: { ...outputs, files } } }
     }),
   }
 }

package/src/workspace/module-state.ts

@@ -0,0 +1,62 @@
+// What a module's exports hold, to tell whether a config changed a module
+// other configs import. Both functions are self-contained: the config
+// worker embeds them by their source (config-eval.ts), as it does
+// `nonJsonPaths`, and a minified build renames only what each one holds.
+
+/** One entry per export: every value reachable from it, in walk order, compared by identity. */
+export type ExportState = Map<PropertyKey, unknown[]>
+
+/**
+ * Every value each export of `ns` reaches through own properties and Map
+ * and Set entries, without calling a getter. Functions and typed arrays
+ * are compared by identity only. State a module keeps unexported, behind a
+ * function, is not reached.
+ */
+export function exportState(ns: object): ExportState {
+  const ownKeys = Reflect.ownKeys
+  const describe = Object.getOwnPropertyDescriptor
+  const protoOf = Object.getPrototypeOf
+  const state: ExportState = new Map()
+  for (const name of ownKeys(ns)) {
+    const out: unknown[] = []
+    const seen = new Set<object>()
+    const walk = (v: unknown): void => {
+      out.push(v)
+      if (v === null || typeof v !== 'object' || seen.has(v) || ArrayBuffer.isView(v)) return
+      seen.add(v)
+      out.push(protoOf(v))
+      if (v instanceof Map)
+        for (const [k, x] of v) {
+          out.push(k)
+          walk(x)
+        }
+      else if (v instanceof Set) for (const x of v) walk(x)
+      for (const k of ownKeys(v)) {
+        const d = describe(v, k)!
+        out.push(k, d.get, d.set, d.writable)
+        if ('value' in d) walk(d.value)
+      }
+    }
+    try {
+      walk((ns as Record<PropertyKey, unknown>)[name])
+    } catch {
+      // A binding not yet initialized, or a Proxy's trap that throws.
+      out.push('\0threw')
+    }
+    state.set(name, out)
+  }
+  return state
+}
+
+/** The exports whose state differs between `before` and `after`. */
+export function changedExports(before: ExportState, after: ExportState): string[] {
+  const out: string[] = []
+  for (const name of new Set([...before.keys(), ...after.keys()])) {
+    const a = before.get(name)
+    const b = after.get(name)
+    let same = a !== undefined && b !== undefined && a.length === b.length
+    for (let i = 0; same && i < a!.length; i++) same = Object.is(a![i], b![i])
+    if (!same) out.push(String(name))
+  }
+  return out
+}

package/src/workspace/nested-dirs.ts

@@ -19,9 +19,16 @@ import type { ProjectEntry } from './workspace.js'
  * once we leave the `p.dir` block entirely. The inner loop is still bounded by
  * that block (near-O(P log P) on real trees; interlopers are few), not the
  * full tail.
+ *
+ * `workspaces`: the absolute roots of nested workspaces (each holds its own
+ * `.vx/workspace.*`), a boundary for outputs: each joins the dirs of every
+ * project it lies under. An outer output glob that ran into one let the
+ * clean before a run delete its files. Never passed for inputs: a task may
+ * read them, and an input left out of the key is a stale hit.
  */
 export function computeNestedProjectDirs(
   entries: Array<Pick<ProjectEntry, 'name' | 'dir'>>,
+  workspaces: readonly string[] = [],
 ): Map<string, string[]> {
   const result = new Map<string, string[]>()
   if (entries.length === 0) return result
@@ -42,6 +49,7 @@ export function computeNestedProjectDirs(
       // else: an interloping sibling (`foo-utils` for `foo`) that shares the
       // string prefix but isn't nested — skip it, descendants may follow.
     }
+    for (const w of workspaces) if (w.startsWith(prefix)) nested.push(w)
     result.set(p.name, nested)
   }
   return result