@vzn/vx 0.0.639 → 0.0.641

package/src/cli/upgrade.ts

@@ -112,13 +112,18 @@ export function versionSpec(tag: string | undefined): string {
  * as an internal error with a stack (a network namespace without a
  * route, 2026-09-16). One line, the host and the reason.
  */
-async function fetchOrRefuse(url: string, init: RequestInit, what: string): Promise<Response> {
+async function fetchOrRefuse(
+  url: string,
+  init: RequestInit,
+  what: string,
+  verb = 'vx upgrade',
+): Promise<Response> {
   try {
     return await fetch(url, init)
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err)
     throw new UserError(
-      `vx upgrade: could not reach ${new URL(url).host} to ${what} (${message}) — check the network or the proxy and re-run`,
+      `${verb}: could not reach ${new URL(url).host} to ${what} (${message}) — check the network or the proxy and re-run`,
     )
   }
 }
@@ -130,33 +135,43 @@ async function fetchOrRefuse(url: string, init: RequestInit, what: string): Prom
  * connection was closed unexpectedly"), which `fetchOrRefuse` never sees
  * and the CLI printed as an internal error with a stack.
  */
-async function readOrRefuse<T>(read: () => Promise<T>, url: string, what: string): Promise<T> {
+async function readOrRefuse<T>(
+  read: () => Promise<T>,
+  url: string,
+  what: string,
+  verb = 'vx upgrade',
+): Promise<T> {
   try {
     return await read()
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err)
     throw new UserError(
-      `vx upgrade: could not ${what} from ${new URL(url).host} (${message}) — nothing replaced; check the network or the proxy and re-run`,
+      `${verb}: could not ${what} from ${new URL(url).host} (${message}) — nothing replaced; check the network or the proxy and re-run`,
     )
   }
 }
 
 /** The registry's document for `pkg@spec` (`latest` or a version). */
-export async function fetchManifest(pkg: string, spec: string): Promise<unknown> {
+export async function fetchManifest(
+  pkg: string,
+  spec: string,
+  verb = 'vx upgrade',
+): Promise<unknown> {
   const url = `${REGISTRY}/${pkg}/${spec}`
   const res = await fetchOrRefuse(
     url,
     { redirect: 'follow', headers: { Accept: 'application/json', 'User-Agent': `vx/${VERSION}` } },
     'read the release',
+    verb,
   )
   if (!res.ok) {
     throw new UserError(
-      `vx upgrade: could not read ${pkg}@${spec} from the npm registry (${res.status})${res.status === 404 && spec !== 'latest' ? ` — is ${spec} a published version?` : ''}`,
+      `${verb}: could not read ${pkg}@${spec} from the npm registry (${res.status})${res.status === 404 && spec !== 'latest' ? ` — is ${spec} a published version?` : ''}`,
     )
   }
   // A body that is not JSON (a captive portal's page, a proxy's error
   // page served with a 200) is the same refusal as a cut one.
-  return await readOrRefuse(() => res.json(), url, 'read the release')
+  return await readOrRefuse(() => res.json(), url, 'read the release', verb)
 }
 
 /** What a verified registry document names: the version, its tarball and the signed integrity. */
@@ -395,6 +410,8 @@ export interface ManagedInstall {
   cwd: string
   /** The project field that lists `@vzn/vx`. */
   field?: 'dependencies' | 'devDependencies' | 'optionalDependencies'
+  /** The `@vzn/vx-*` plugins the same package.json lists from the registry, moved with core. */
+  plugins?: string[]
 }
 
 const FIELDS = ['devDependencies', 'dependencies', 'optionalDependencies'] as const
@@ -417,6 +434,45 @@ function listingField(dir: string): ManagedInstall['field'] | undefined {
   })
 }
 
+/** A release's platform binary, which the launcher pulls in itself: no plugin. */
+const PLATFORM = /^@vzn\/vx-(?:darwin|linux)-(?:x64|arm64)$/
+
+/**
+ * The `@vzn/vx-*` plugins `dir`'s package.json lists from the registry
+ * (a `workspace:` or `file:` link is the repo's own). Every @vzn package
+ * releases together, so they move with core in its one install (M,
+ * 2026-10-16); one in another field would move fields under core's flag,
+ * so it is refused.
+ */
+function pluginsBeside(dir: string, field: NonNullable<ManagedInstall['field']>): string[] {
+  const pkg = readJson(path.join(dir, 'package.json'))
+  const plugins: string[] = []
+  for (const f of FIELDS) {
+    const deps = pkg?.[f]
+    if (typeof deps !== 'object' || deps === null) continue
+    for (const [name, spec] of Object.entries(deps as Record<string, unknown>)) {
+      if (!name.startsWith(`${PACKAGE}-`) || PLATFORM.test(name)) continue
+      if (typeof spec !== 'string' || /^(?:workspace|file|link|portal):/.test(spec)) continue
+      if (f !== field) {
+        throw new UserError(
+          `vx upgrade: ${name} is in ${f} and ${PACKAGE} in ${field}; list them in one field so one install moves them together`,
+        )
+      }
+      plugins.push(name)
+    }
+  }
+  return plugins.sort()
+}
+
+/** The version of `pkg` installed where `dir` resolves it, if any. */
+function installedVersion(dir: string, pkg: string): string | undefined {
+  for (let d = dir; ; d = path.dirname(d)) {
+    const v = readJson(path.join(d, 'node_modules', pkg, 'package.json'))?.['version']
+    if (typeof v === 'string') return v
+    if (path.dirname(d) === d) return undefined
+  }
+}
+
 /** The project's package manager: its lockfile, then `packageManager`, then the tree's shape. */
 function projectManager(dir: string, execPath: string): ManagedInstall['manager'] {
   for (let d = dir; ; d = path.dirname(d)) {
@@ -463,12 +519,15 @@ export function managedInstall(execPath: string, cwd: string): ManagedInstall |
   if (/\/yarn\/global\//.test(p)) return { manager: 'yarn', scope: 'global', cwd: root }
   const field = listingField(root)
   if (field !== undefined) {
-    return { manager: projectManager(root, execPath), scope: 'project', cwd: root, field }
+    const plugins = pluginsBeside(root, field)
+    return { manager: projectManager(root, execPath), scope: 'project', cwd: root, field, plugins }
   }
   for (let d = path.resolve(cwd); d.startsWith(root); d = path.dirname(d)) {
     const f = listingField(d)
-    if (f !== undefined)
-      return { manager: projectManager(d, execPath), scope: 'project', cwd: d, field: f }
+    if (f !== undefined) {
+      const plugins = pluginsBeside(d, f)
+      return { manager: projectManager(d, execPath), scope: 'project', cwd: d, field: f, plugins }
+    }
     if (path.dirname(d) === d) break
   }
   // npm's global tree: `<prefix>/lib/node_modules` (nvm, volta, Homebrew alike).
@@ -503,7 +562,8 @@ export function upgradeArgv(install: ManagedInstall, version: string): string[]
     bun: { devDependencies: '--dev', dependencies: '', optionalDependencies: '--optional' },
     yarn: { devDependencies: '--dev', dependencies: '', optionalDependencies: '--optional' },
   }[manager][field]
-  const argv = manager === 'npm' ? ['npm', 'install', spec] : [manager, 'add', spec]
+  const specs = [spec, ...(install.plugins ?? []).map((p) => `${p}@${version}`)]
+  const argv = manager === 'npm' ? ['npm', 'install', ...specs] : [manager, 'add', ...specs]
   if (flag !== '') argv.push(flag)
   // pnpm refuses an `add` at a workspace's root without saying it means the root.
   if (manager === 'pnpm' && existsSync(path.join(install.cwd, 'pnpm-workspace.yaml')))
@@ -511,13 +571,17 @@ export function upgradeArgv(install: ManagedInstall, version: string): string[]
   return argv
 }
 
-/** The version `tag` names, or the registry's latest, read for the "already at" check. */
-async function targetVersion(tag: string | undefined): Promise<string> {
+/**
+ * The version `tag` names, or the registry's latest: read for the "already
+ * at" check, and by `vx init`, which always installs the latest release.
+ */
+export async function targetVersion(tag: string | undefined, verb = 'vx upgrade'): Promise<string> {
   const spec = versionSpec(tag)
   if (spec !== 'latest') return spec
-  const v = ((await fetchManifest(PACKAGE, 'latest')) as { version?: unknown } | null)?.version
+  const v = ((await fetchManifest(PACKAGE, 'latest', verb)) as { version?: unknown } | null)
+    ?.version
   if (typeof v !== 'string' || !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(v)) {
-    throw new UserError(`vx upgrade: the npm registry named no latest version of ${PACKAGE}`)
+    throw new UserError(`${verb}: the npm registry named no latest version of ${PACKAGE}`)
   }
   return v
 }
@@ -527,13 +591,14 @@ async function targetVersion(tag: string | undefined): Promise<string> {
  * `version`; vx never installs one. `step` names the install when a run
  * moves two (`project `, `global `).
  */
-async function upgradeManaged(
+export async function upgradeManaged(
   install: ManagedInstall,
   version: string,
   current = VERSION,
   step = '',
 ): Promise<void> {
-  if (version === current) {
+  const plugins = install.plugins ?? []
+  if (version === current && plugins.every((p) => installedVersion(install.cwd, p) === version)) {
     ui.print('out', ui.status('info', 'vx upgrade', `${step}already at ${current}`))
     return
   }
@@ -547,7 +612,11 @@ async function upgradeManaged(
   }
   ui.print(
     'out',
-    ui.status('info', 'vx upgrade', `${step}${current} → ${version}`),
+    ui.status(
+      'info',
+      'vx upgrade',
+      `${step}${version === current ? 'plugins' : current} → ${version}`,
+    ),
     ui.text([ui.cmd(argv.join(' ')), ui.dim(` in ${install.cwd}`)]),
   )
   const proc = Bun.spawnSync({
@@ -557,7 +626,14 @@ async function upgradeManaged(
   })
   if (proc.exitCode !== 0) {
     throw new UserError(
-      `vx upgrade: ${argv.join(' ')} failed (exit ${proc.exitCode}) — vx changed nothing itself`,
+      `vx upgrade: ${argv.join(' ')} failed (exit ${proc.exitCode}) — vx changed nothing itself${
+        // The install is pinned, so pnpm refuses a release younger than
+        // its minimumReleaseAge instead of mixing releases; its words
+        // print above, so the way out is named (as vx-migrate does).
+        install.manager === 'pnpm'
+          ? `; if pnpm refused a version published within its minimumReleaseAge, list ${[PACKAGE, ...plugins].join(', ')} under minimumReleaseAgeExclude in pnpm-workspace.yaml`
+          : ''
+      }`,
     )
   }
 }
@@ -636,6 +712,31 @@ export async function upgradeGlobal(
   })
 }
 
+/**
+ * `vx upgrade -g`: bring this vx, the global one, to `version` and nothing
+ * else (owner, 2026-10-16) — no project's package.json, no plugin. The
+ * project's own vx refuses: no global ran.
+ */
+export async function upgradeOnlyGlobal(
+  self: string,
+  version: string,
+  current = VERSION,
+): Promise<void> {
+  if (current === version) {
+    ui.print('out', ui.status('info', 'vx upgrade', `global already at ${current}`))
+    return
+  }
+  // Read from the binary's own directory, not cwd: a project there is not this install's.
+  const install = managedInstall(self, path.dirname(self))
+  if (install?.scope === 'project') {
+    throw new UserError(
+      `vx upgrade -g: no global vx ran — ${self} is the project's own. Install one (npm install -g ${PACKAGE}), or run \`vx upgrade\` to move the project's`,
+    )
+  }
+  if (install === null) await upgradeBinary(self, version, current, 'global ')
+  else await upgradeManaged(install, version, current, 'global ')
+}
+
 /** `run`, its refusal naming `what` after the verb: a run that moves two installs says which failed. */
 async function named(what: string, run: () => Promise<void>): Promise<void> {
   try {
@@ -646,7 +747,9 @@ async function named(what: string, run: () => Promise<void>): Promise<void> {
   }
 }
 
-export async function upgradeCmd(args: readonly string[]): Promise<number> {
+export async function upgradeCmd(argv: readonly string[]): Promise<number> {
+  const global = argv.some((a) => a === '-g' || a === '--global')
+  const args = argv.filter((a) => a !== '-g' && a !== '--global')
   const unknown = args.find((a) => a.startsWith('-'))
   if (unknown !== undefined) {
     sayNotice(
@@ -670,10 +773,18 @@ export async function upgradeCmd(args: readonly string[]): Promise<number> {
     )
   }
   const dest = process.execPath
+  const handedOffFrom = process.env['VX_HANDED_OFF']
+  if (global) {
+    // A launcher from before -g handed the call over: the global is the one that did.
+    const version = await targetVersion(tag)
+    if (handedOffFrom !== undefined) await upgradeGlobal(handedOffFrom, version)
+    else await upgradeOnlyGlobal(dest, version)
+    return 0
+  }
   const install = managedInstall(dest, process.cwd())
   // A global vx handed this run to the project's own: both move, to one
   // version, the project first (owner, 2026-10-15).
-  const from = process.env['VX_HANDED_OFF']
+  const from = handedOffFrom
   if (from !== undefined) {
     const version = await targetVersion(tag)
     await named('project vx', () =>

package/src/cli/watch-filter.ts

@@ -2,6 +2,7 @@
 // rules, git-ignored paths, the root arm's filter) and which files reshape
 // the watched set. Pure decisions over paths; the loop acts on them.
 
+import fs from 'node:fs'
 import path from 'node:path'
 import {
   executablePath,
@@ -32,13 +33,8 @@ export function isIgnoredWatchPath(rel: string): boolean {
   const segments = rel.split(path.sep)
   for (let i = 1; i <= segments.length; i++) if (isIgnoredDir(segments.slice(0, i))) return true
   if (IGNORED_SUFFIXES.some((suf) => rel.endsWith(suf))) return true
-  const name = segments[segments.length - 1]!
-  // A restore's own temporary file, never an input (`ALWAYS_IGNORE`):
-  // renamed away before the judgement, it read as a deletion and ran one
-  // more cycle where an uncached task makes ignored paths count.
-  if (name.startsWith('.vx-tmp-')) return true
   // `vx lock`'s review copy: no input, so a re-lock is no cycle.
-  return name === 'vx.lock.json'
+  return segments[segments.length - 1] === 'vx.lock.json'
 }
 
 /**
@@ -369,12 +365,14 @@ export function gitSpeller(root: string): (p: string) => string {
  * a project moved away whole is one event on its directory): what existed
  * when watch armed, so a path born and gone since is told from a deletion
  * (watch-judge.ts). `tracked` is the files git tracks: a user edits those,
- * so a server cannot be blamed for one. Undefined when git cannot answer:
+ * so a server cannot be blamed for one. `links` is the symlinks among the
+ * files: a key reads what each points to (cache/linked-inputs.ts), so watch
+ * arms that too. Undefined when git cannot answer:
  * no inventory, every gone path is a deletion as before.
  */
 export function gitFiles(
   workspaceRoot: string,
-): { listed: Set<string>; tracked: Set<string> } | undefined {
+): { listed: Set<string>; tracked: Set<string>; links: Set<string> } | undefined {
   let proc: ReturnType<typeof Bun.spawnSync>
   try {
     proc = Bun.spawnSync({
@@ -383,6 +381,7 @@ export function gitFiles(
         'ls-files',
         '-z',
         '-t',
+        '-s',
         '--cached',
         '--others',
         '--exclude-standard',
@@ -398,18 +397,30 @@ export function gitFiles(
   if (proc.exitCode !== 0) return undefined
   const files = new Set<string>()
   const tracked = new Set<string>()
+  const links = new Set<string>()
   for (const entry of new TextDecoder('utf-8', { ignoreBOM: true })
     .decode(proc.stdout)
     .split('\0')) {
     if (entry.length === 0) continue
-    // `-t` prefixes a tag and a space; `?` is untracked.
-    const p = entry.slice(2)
+    // `-t` prefixes a tag and a space; `?` is untracked, a bare path. A
+    // tracked entry is `-s`'s `<mode> <oid> <stage>\t<path>` after the tag.
+    const untracked = entry[0] === '?'
+    const p = untracked ? entry.slice(2) : entry.slice(entry.indexOf('\t') + 1)
     // An untracked nested repository is listed as `dir/`.
     let abs = path.join(workspaceRoot, p.endsWith('/') ? p.slice(0, -1) : p)
     files.add(abs)
-    if (entry[0] !== '?') tracked.add(abs)
+    if (!untracked) tracked.add(abs)
+    if (untracked ? isLink(abs) : entry.startsWith('120000 ', 2)) links.add(abs)
     for (abs = path.dirname(abs); abs !== workspaceRoot && !files.has(abs); abs = path.dirname(abs))
       files.add(abs)
   }
-  return { listed: files, tracked }
+  return { listed: files, tracked, links }
+}
+
+function isLink(abs: string): boolean {
+  try {
+    return fs.lstatSync(abs).isSymbolicLink()
+  } catch {
+    return false
+  }
 }

package/src/cli/watch-fs.ts

@@ -16,7 +16,8 @@ export const IGNORED_SEGMENTS = ['node_modules', '.git']
 export function isIgnoredDir(segments: readonly string[]): boolean {
   const last = segments.length - 1
   if (IGNORED_SEGMENTS.includes(segments[last]!)) return true
-  return segments[last] === 'cache' && segments[last - 1] === '.vx'
+  // vx's cache, and where its restores stage (archive.ts).
+  return (segments[last] === 'cache' || segments[last] === 'tmp') && segments[last - 1] === '.vx'
 }
 
 /**

package/src/cli/watch-judge.ts

@@ -4,6 +4,7 @@
 
 import fs from 'node:fs'
 import path from 'node:path'
+import { filesBehind } from '../cache/index.js'
 import { xxh3 } from '../util/index.js'
 import { gitIgnored, gitSpeller } from './watch-filter.js'
 import { modifiedBefore } from './watch-fs.js'
@@ -13,9 +14,10 @@ const ABSENT = -1n
 function settledState(abs: string): bigint {
   let st: fs.Stats
   try {
-    // A link is its target string, as the key folds it: following it saw
-    // a retarget to equal bytes as "the same" and ran nothing.
-    if (fs.lstatSync(abs).isSymbolicLink()) return xxh3(`link:${fs.readlinkSync(abs)}`)
+    // A link is its target string and what it points to, as the key folds
+    // it: following it alone saw a retarget to equal bytes as "the same".
+    if (fs.lstatSync(abs).isSymbolicLink())
+      return xxh3(`link:${fs.readlinkSync(abs)}\0${behindState(abs)}`)
     st = fs.statSync(abs)
   } catch {
     return ABSENT
@@ -50,6 +52,34 @@ function settledState(abs: string): bigint {
   return xxh3(Buffer.from(entries.join('\n')))
 }
 
+/**
+ * What a link points to, as change detection reads it: a file's bytes and
+ * mode, a directory's files by size and times (cache/linked-inputs.ts keys
+ * their bytes), nothing for a dangling link.
+ */
+function behindState(link: string): string {
+  let real: string
+  let st: fs.Stats
+  try {
+    real = fs.realpathSync(link)
+    st = fs.statSync(real)
+  } catch {
+    return ''
+  }
+  if (st.isFile()) return `${xxh3(fs.readFileSync(real))}:${st.mode & 0o7777}`
+  if (!st.isDirectory()) return ''
+  return filesBehind(real)
+    .map((rel) => {
+      try {
+        const f = fs.statSync(path.join(real, rel))
+        return `${rel}\0${f.size}\0${f.mtimeMs}\0${f.ctimeMs}`
+      } catch {
+        return rel
+      }
+    })
+    .join('\n')
+}
+
 /** What the judgement reads from the loop, which owns it and may replace it. */
 export interface JudgeContext {
   workspaceRoot: string
@@ -59,6 +89,8 @@ export interface JudgeContext {
   held(): boolean
   /** Projects whose uncached task may read a git-ignored file. */
   uncached(): ReadonlySet<string>
+  /** Paths a task's inputs name outright: a git-ignored file at or under one is an input. */
+  namedIgnored?(): readonly string[]
   /** Whether `abs`, under the project at `ownDir`, lies in a project nested there (`makeFence`). */
   fenced?(ownDir: string, abs: string): boolean
   /** The files git listed at the arm; absent when git could not answer. */
@@ -113,6 +145,15 @@ export class ChangeJudge {
 
   constructor(private readonly ctx: JudgeContext) {}
 
+  /**
+   * Record a path's state as it is, if this loop has not: a link armed for
+   * what it points to, whose own times say "before the arm" whatever
+   * changed behind it, so its first sighting compares against this.
+   */
+  seed(abs: string): void {
+    if (!this.lastState.has(abs)) this.lastState.set(abs, settledState(abs))
+  }
+
   // A path this loop has never judged is a change only if it moved since
   // the watchers went live (its mtime or ctime, `modifiedBefore`). macOS delivers the initial run's own writes
   // AFTER the arm (CI, 2026-09-11: `app dist; re-running...` with no edit
@@ -192,10 +233,13 @@ export class ChangeJudge {
     // user wrote it; one the last cycle wrote (the pid file an uncached
     // task rewrites every run, the loop the filter exists for) stays out,
     // as does one in a project nested under it, which it does not own.
+    // So is one a task's inputs name outright (`.env.local`, `dist/**`).
     const editForUncached = (p: string): boolean =>
-      [...this.ctx.uncached()].some(
+      ([...this.ctx.uncached()].some(
         (dir) => p.startsWith(dir + path.sep) && this.ctx.fenced?.(dir, p) !== true,
-      ) && !this.writtenDuringLastCycle(p)
+      ) ||
+        (this.ctx.namedIgnored?.() ?? []).some((n) => p === n || p.startsWith(n + path.sep))) &&
+      !this.writtenDuringLastCycle(p)
     // A path still there names the cycle before a gone one: an editor or
     // `sed -i` saving through a temporary file fires that file first, and
     // the cycle was announced by a name already renamed away.

package/src/cli/watch-set.ts

@@ -5,6 +5,7 @@
 
 import path from 'node:path'
 import type { ProjectConfig } from '../config.js'
+import { namedOutright } from '../cache/index.js'
 import {
   buildPackageGraph,
   lockKey,
@@ -64,6 +65,8 @@ export interface ConfigSweep {
   inputs: Map<string, string[][]>
   /** Projects with a task that has a command and no cache: it reads what it likes, git-ignored files included. */
   uncached: Set<string>
+  /** Paths a task's inputs name outright (`namedOutright`), absolute: a git-ignored one is an input. */
+  namedIgnored: string[]
   /** Files the project configs import by relative path (item 949). */
   configImports: string[]
   /** Files the workspace config imports by relative path: loaded once per process (item 949). */
@@ -115,6 +118,7 @@ export async function sweepConfigs(
     addTo(outputs, dir, globs)
   const workspaceInputs = new Set<string>()
   const uncached = new Set<string>()
+  const namedIgnored = new Set<string>()
   const folded: [string, ProjectConfig][] = []
   const fold = (dir: string, config: ProjectConfig): void => {
     folded.push([dir, config])
@@ -131,15 +135,20 @@ export async function sweepConfigs(
       add(dir, task.cache?.outputs?.files)
       add(workspaceRoot, task.cache?.outputs?.workspaceFiles)
       if (names !== null && !names.has(name)) continue
-      if (task.cache === undefined && task.exec !== undefined && task.exec.persistent === undefined)
-        uncached.add(dir)
-      for (const g of task.cache?.inputs?.workspaceFiles ?? []) workspaceInputs.add(g)
-      addInputs(dir, task.cache?.inputs?.files, task.cache?.outputs?.files)
-      addInputs(
-        workspaceRoot,
-        task.cache?.inputs?.workspaceFiles,
-        task.cache?.outputs?.workspaceFiles,
+      if (
+        task.inputs === undefined &&
+        task.exec !== undefined &&
+        task.exec.persistent === undefined
       )
+        uncached.add(dir)
+      if (task.inputs !== undefined && task.exec !== undefined) {
+        const named = namedOutright(task)
+        for (const rel of named.files) namedIgnored.add(path.join(dir, rel))
+        for (const rel of named.workspaceFiles) namedIgnored.add(path.join(workspaceRoot, rel))
+      }
+      for (const g of task.inputs?.workspaceFiles ?? []) workspaceInputs.add(g)
+      addInputs(dir, task.inputs?.files, task.cache?.outputs?.files)
+      addInputs(workspaceRoot, task.inputs?.workspaceFiles, task.cache?.outputs?.workspaceFiles)
     }
   }
   const result = (staged: Map<string, ProjectEntry> | null): ConfigSweep => ({
@@ -148,6 +157,7 @@ export async function sweepConfigs(
     outputs,
     inputs,
     uncached,
+    namedIgnored: [...namedIgnored],
     configImports: [...projectImports],
     workspaceConfigImports: [...wsImports],
     staged,