@vzn/vx 0.0.18 → 0.0.21

package/src/cli/migrate-turbo.ts

@@ -1,401 +0,0 @@
-// Turbo → vx mapping. Reads turbo.json (tasks in turbo 2, pipeline in
-// turbo 1), per-package turbo.json `extends` overlays, and each
-// package's scripts. A task is emitted for a package only when the
-// package declares the script (turbo semantics). Global fields become
-// a root vx-preset.ts that configs import and spread — TypeScript
-// composition replaces turbo's global config.
-
-import path from 'node:path'
-import { relPosix, UserError } from '../util/index.js'
-import type { ProjectMeta } from '../workspace/index.js'
-import { quote } from './migrate-emit.js'
-import type { GeneratedProject, GeneratedTask, MigrationPlan, RawExpr } from './migrate.js'
-
-interface TurboTask {
-  dependsOn?: string[]
-  inputs?: string[]
-  outputs?: string[]
-  env?: string[]
-  passThroughEnv?: string[]
-  cache?: boolean
-  persistent?: boolean
-  [key: string]: unknown
-}
-
-interface TurboJson {
-  tasks?: Record<string, TurboTask>
-  pipeline?: Record<string, TurboTask>
-  globalDependencies?: string[]
-  globalEnv?: string[]
-  globalPassThroughEnv?: string[]
-}
-
-const KNOWN_TASK_KEYS = new Set([
-  'dependsOn',
-  'inputs',
-  'outputs',
-  'env',
-  'passThroughEnv',
-  'cache',
-  'persistent',
-  'extends',
-])
-
-const PRESET_FILE = 'vx-preset.ts'
-
-interface Globals {
-  inputs: boolean
-  env: boolean
-  pass: boolean
-}
-
-async function readTurboJson(file: string, root: string): Promise<TurboJson> {
-  const text = await Bun.file(file).text()
-  try {
-    // turbo.json allows comments + trailing commas.
-    return (Bun.JSONC.parse(text) ?? {}) as TurboJson
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err)
-    throw new UserError(`failed to parse ${relPosix(root, file)}: ${msg}`)
-  }
-}
-
-function tasksOf(cfg: TurboJson): Record<string, TurboTask> {
-  return cfg.tasks ?? cfg.pipeline ?? {}
-}
-
-function scriptsOf(meta: ProjectMeta): Record<string, unknown> {
-  // package.json is a system boundary — a script value is whatever the
-  // file holds, not necessarily a string.
-  return (meta.packageJson as unknown as { scripts?: Record<string, unknown> }).scripts ?? {}
-}
-
-/** A script value that can become `exec.command` verbatim. */
-function usableScript(value: unknown): value is string {
-  return typeof value === 'string' && value.length > 0
-}
-
-function describeScript(value: unknown): string {
-  if (value === null) return 'null'
-  if (typeof value === 'string') return 'an empty string'
-  if (Array.isArray(value)) return 'an array'
-  return `a ${typeof value}`
-}
-
-/** Declared task names for a package: plain root keys, `pkg#name` keys
- * for this package, and per-package turbo.json keys — in that order. */
-function taskNamesFor(
-  pkgName: string,
-  rootTasks: Record<string, TurboTask>,
-  pkgTasks: Record<string, TurboTask> | undefined,
-): string[] {
-  const names: string[] = []
-  const push = (n: string): void => {
-    if (!names.includes(n)) names.push(n)
-  }
-  for (const key of Object.keys(rootTasks)) {
-    if (!key.includes('#')) push(key)
-    else if (key.startsWith(`${pkgName}#`)) push(key.slice(pkgName.length + 1))
-  }
-  for (const key of Object.keys(pkgTasks ?? {})) {
-    if (!key.includes('#')) push(key)
-  }
-  return names
-}
-
-export async function migrateTurbo(
-  root: string,
-  metas: readonly ProjectMeta[],
-): Promise<MigrationPlan> {
-  const rootCfg = await readTurboJson(path.join(root, 'turbo.json'), root)
-  const rootTasks = tasksOf(rootCfg)
-
-  const globalInputs = rootCfg.globalDependencies ?? []
-  const globalEnv = rootCfg.globalEnv ?? []
-  const globalPass = rootCfg.globalPassThroughEnv ?? []
-  const globals: Globals = {
-    inputs: globalInputs.length > 0,
-    env: globalEnv.length > 0,
-    pass: globalPass.length > 0,
-  }
-
-  const pkgTasksByName = new Map<string, Record<string, TurboTask>>()
-  for (const meta of metas) {
-    const file = path.join(meta.dir, 'turbo.json')
-    if (await Bun.file(file).exists()) {
-      pkgTasksByName.set(meta.name, tasksOf(await readTurboJson(file, root)))
-    }
-  }
-
-  const notes: string[] = []
-  for (const key of Object.keys(rootTasks)) {
-    if (key.startsWith('//#')) {
-      notes.push(`note: root task ${key} not migrated — vx has no workspace-root tasks`)
-    }
-  }
-
-  // First pass: which tasks does each package emit? Needed so dependsOn
-  // edges can be validated/dropped against the real emitted set.
-  const emitted = new Map<string, Set<string>>()
-  for (const meta of metas) {
-    const scripts = scriptsOf(meta)
-    const set = new Set<string>()
-    for (const name of taskNamesFor(meta.name, rootTasks, pkgTasksByName.get(meta.name))) {
-      if (usableScript(scripts[name])) set.add(name)
-    }
-    emitted.set(meta.name, set)
-  }
-
-  const projects: GeneratedProject[] = []
-  for (const meta of metas) {
-    const scripts = scriptsOf(meta)
-    const pkgTasks = pkgTasksByName.get(meta.name)
-    const own = emitted.get(meta.name)!
-    const used = new Set<string>()
-    const tasks: GeneratedTask[] = []
-    for (const name of taskNamesFor(meta.name, rootTasks, pkgTasks)) {
-      const script = scripts[name]
-      if (!usableScript(script)) {
-        // The turbo task exists and so does the script KEY, but its value
-        // can't become a command. Report it instead of emitting
-        // `command: 42` / `command: null` — the first writes a config that
-        // fails to load, the second used to abort the whole migration in
-        // the emitter, and both landed AFTER "migrated clean, 0 TODOs".
-        // An ABSENT script stays silent: turbo skips the task there too.
-        if (script !== undefined) {
-          tasks.push({
-            name,
-            todos: [
-              `package.json script ${JSON.stringify(name)} is ${describeScript(script)}, not a ` +
-                'non-empty command string — task skipped; write the command by hand',
-            ],
-            task: null,
-          })
-        }
-        continue
-      }
-      const def: TurboTask = {
-        ...rootTasks[name],
-        ...rootTasks[`${meta.name}#${name}`],
-        ...pkgTasks?.[name],
-      }
-      tasks.push(buildTask(name, def, script, own, emitted, globals, used))
-    }
-    projects.push({
-      name: meta.name,
-      dir: meta.dir,
-      importLines: presetImportLines(used, root, meta.dir),
-      tasks,
-    })
-  }
-
-  const extraFiles: MigrationPlan['extraFiles'] = []
-  if (globals.inputs || globals.env || globals.pass) {
-    extraFiles.push({
-      relPath: PRESET_FILE,
-      contents: renderPreset(globalInputs, globalEnv, globalPass),
-    })
-  }
-
-  return { headerNotes: [], projects, extraFiles, notes }
-}
-
-function buildTask(
-  name: string,
-  def: TurboTask,
-  command: string,
-  own: ReadonlySet<string>,
-  emitted: ReadonlyMap<string, ReadonlySet<string>>,
-  globals: Globals,
-  used: Set<string>,
-): GeneratedTask {
-  const todos: string[] = []
-  const persistent = def.persistent === true
-  const cacheEnabled = def.cache !== false && !persistent
-
-  for (const [key, value] of Object.entries(def)) {
-    if (KNOWN_TASK_KEYS.has(key)) continue
-    todos.push(
-      `turbo key ${JSON.stringify(key)} (${JSON.stringify(value)}) has no vx equivalent — ` +
-        'map it manually',
-    )
-  }
-
-  const deps: string[] = []
-  for (const d of def.dependsOn ?? []) {
-    if (d.includes('$TURBO_ROOT$')) {
-      todos.push(
-        `dependsOn ${JSON.stringify(d)} uses $TURBO_ROOT$ — vx has no workspace-root tasks; ` +
-          'restructure manually',
-      )
-      continue
-    }
-    if (d.startsWith('^')) {
-      deps.push(d)
-      continue
-    }
-    const hashAt = d.indexOf('#')
-    if (hashAt !== -1) {
-      const pkg = d.slice(0, hashAt)
-      const task = d.slice(hashAt + 1)
-      if (emitted.get(pkg)?.has(task)) deps.push(d)
-      else
-        todos.push(
-          `dependsOn ${JSON.stringify(d)}: ${pkg} declares no ${task} script — edge dropped`,
-        )
-      continue
-    }
-    // Same-project dep on a script this package lacks: turbo silently
-    // skips the task there, so the edge simply doesn't exist.
-    if (own.has(d)) deps.push(d)
-  }
-
-  const envNames: string[] = []
-  for (const e of def.env ?? []) {
-    if (/[*?[\]!]/.test(e)) {
-      todos.push(
-        `env ${JSON.stringify(e)}: wildcards are not supported in vx env names — ` +
-          'list explicit names in cache.inputs.env + exec.env.passThrough',
-      )
-    } else envNames.push(e)
-  }
-  const passNames: string[] = []
-  for (const e of def.passThroughEnv ?? []) {
-    if (/[*?[\]!]/.test(e)) {
-      todos.push(
-        `passThroughEnv ${JSON.stringify(e)}: wildcards are not supported — list explicit names`,
-      )
-    } else passNames.push(e)
-  }
-
-  const passThrough: (string | RawExpr)[] = []
-  if (globals.env) {
-    passThrough.push({ raw: '...globalEnvInputs' })
-    used.add('globalEnvInputs')
-  }
-  if (globals.pass) {
-    passThrough.push({ raw: '...globalPassThroughEnv' })
-    used.add('globalPassThroughEnv')
-  }
-  passThrough.push(...envNames, ...passNames)
-
-  const exec: Record<string, unknown> = { command }
-  if (passThrough.length > 0) exec.env = { passThrough }
-  if (persistent) {
-    exec.persistent = {}
-    todos.push(
-      'persistent task — set persistent.readyWhen (regex matched against output) so ' +
-        'dependents unblock on readiness, and consider exec.timeout to bound the wait',
-    )
-  }
-
-  const task: Record<string, unknown> = { exec }
-  if (deps.length > 0) task.dependsOn = deps
-
-  if (cacheEnabled) {
-    const files: (string | RawExpr)[] = []
-    const wsFiles: (string | RawExpr)[] = []
-    // globalDependencies are workspace-root-relative by definition —
-    // they map to inputs.workspaceFiles, not project-relative files.
-    if (globals.inputs) {
-      wsFiles.push({ raw: '...globalInputs' })
-      used.add('globalInputs')
-    }
-    if (def.inputs === undefined) {
-      // Turbo's default input set is every package file.
-      files.push('**/*')
-    } else {
-      for (const i of def.inputs) {
-        if (i === '$TURBO_DEFAULT$') {
-          files.push('**/*')
-          continue
-        }
-        const neg = i.startsWith('!')
-        const body = neg ? i.slice(1) : i
-        if (body.startsWith('$TURBO_ROOT$/')) {
-          wsFiles.push((neg ? '!' : '') + body.slice('$TURBO_ROOT$/'.length))
-        } else if (i.includes('$TURBO_ROOT$')) {
-          todos.push(
-            `input ${JSON.stringify(i)}: $TURBO_ROOT$ only maps as a '$TURBO_ROOT$/<path>' ` +
-              'prefix (→ cache.inputs.workspaceFiles) — map manually',
-          )
-        } else files.push(i)
-      }
-    }
-
-    const outFiles: string[] = []
-    const wsOutFiles: string[] = []
-    for (const o of def.outputs ?? []) {
-      if (o.startsWith('!')) {
-        todos.push(
-          `output ${JSON.stringify(o)}: vx outputs have no negation — narrow the positive ` +
-            'globs instead',
-        )
-      } else if (o.startsWith('$TURBO_ROOT$/')) {
-        wsOutFiles.push(o.slice('$TURBO_ROOT$/'.length))
-      } else if (o.includes('$TURBO_ROOT$')) {
-        todos.push(
-          `output ${JSON.stringify(o)}: $TURBO_ROOT$ only maps as a '$TURBO_ROOT$/<path>' ` +
-            'prefix (→ cache.outputs.workspaceFiles) — map manually',
-        )
-      } else outFiles.push(o)
-    }
-
-    const cacheEnv: (string | RawExpr)[] = []
-    if (globals.env) cacheEnv.push({ raw: '...globalEnvInputs' })
-    cacheEnv.push(...envNames)
-
-    const inputs: Record<string, unknown> = { files }
-    if (wsFiles.length > 0) inputs.workspaceFiles = wsFiles
-    if (cacheEnv.length > 0) inputs.env = cacheEnv
-    const outputs: Record<string, unknown> = { files: outFiles }
-    if (wsOutFiles.length > 0) outputs.workspaceFiles = wsOutFiles
-    task.cache = { inputs, outputs }
-  }
-
-  return { name, todos, task }
-}
-
-function presetImportLines(used: ReadonlySet<string>, root: string, dir: string): string[] {
-  if (used.size === 0) return []
-  const rel = relPosix(dir, path.join(root, PRESET_FILE))
-  const spec = rel.startsWith('.') ? rel : `./${rel}`
-  return [`import { ${[...used].sort().join(', ')} } from '${spec}'`]
-}
-
-function renderPreset(inputs: string[], env: string[], pass: string[]): string {
-  // Escape each entry via the shared `quote()` — a turbo.json global (a file
-  // glob, or an env name a user hand-wrote) may contain a `'`/`\`/newline that
-  // would otherwise splice into a malformed, unloadable `vx-preset.ts`.
-  const arr = (xs: string[]): string => `[${xs.map(quote).join(', ')}]`
-  const lines = [
-    '// Generated by `vx migrate` from turbo.json. TypeScript composition',
-    "// replaces turbo's global fields: each vx.config.ts imports these",
-    '// arrays and spreads them into the matching task fields.',
-  ]
-  if (inputs.length > 0) {
-    lines.push(
-      '',
-      '// From globalDependencies — workspace-root-relative, spread into each',
-      '// task’s cache.inputs.workspaceFiles (the $TURBO_ROOT$ equivalent).',
-      `export const globalInputs = ${arr(inputs)}`,
-    )
-  }
-  if (env.length > 0) {
-    lines.push(
-      '',
-      '// From globalEnv: cache inputs AND passed through to every task',
-      '// (vx child environments are isolated; see docs/schema.md).',
-      `export const globalEnvInputs = ${arr(env)}`,
-    )
-  }
-  if (pass.length > 0) {
-    lines.push(
-      '',
-      '// From globalPassThroughEnv: forwarded to every task, never hashed.',
-      `export const globalPassThroughEnv = ${arr(pass)}`,
-    )
-  }
-  lines.push('')
-  return lines.join('\n')
-}

package/src/cli/prune.ts

@@ -1,291 +0,0 @@
-// `vx prune <project> [--out-dir <dir>] [--docker]` — emit a self-contained
-// SUBSET of the workspace containing one project and its transitive
-// workspace dependencies, for Docker builds (Turbo `turbo prune` parity,
-// comparison gap #10).
-//
-// What lands in the output:
-//   <out>/               the pruned workspace (or <out>/full/ with --docker)
-//     package.json         root manifest, copied as-is
-//     pnpm-workspace.yaml  REWRITTEN to the exact subset dirs (a glob that
-//                          matches dirs absent from the subset would make
-//                          pnpm error on install)
-//     <lockfile>           copied UNPRUNED — pnpm/bun/npm/yarn all tolerate
-//                          a superset lockfile; real lockfile pruning is a
-//                          per-format project (Turbo ships a crate per
-//                          format) and a wrong pruned lockfile is worse
-//                          than a big correct one. Documented, deliberate.
-//     vx.workspace.*       copied when present, together with any WORKSPACE
-//                          package it imports (a plugin lives in the subset
-//                          or `vx run` cannot load the config at all)
-//     .npmrc / .nvmrc      copied when present
-//     <pkg dirs>           full source of the project + every transitive
-//                          workspace dep (node_modules / .git / .vx / .turbo
-//                          excluded)
-//   <out>/json/          with --docker: manifests only (root files + each
-//                          package's package.json) — COPY this layer first
-//                          so `pnpm install` caches independently of source
-//                          edits, then COPY full/ and build.
-//
-// Boundaries note: a package dir is copied WHOLE (minus the exclusions).
-// vx's own nested-project input exclusions do not apply here — prune
-// reproduces the tree, it does not hash it.
-//
-// RUNNABILITY IS NOT GUARANTEED, and this deliberately does not claim it.
-// A config may import any path it likes; only imports that name a workspace
-// PACKAGE can be resolved and pulled in. A relative import escaping its own
-// package dir (`../../src/index.ts`, the shape this repo's own dogfooding
-// configs use) reaches a file prune never copies, and no subset short of the
-// whole tree would contain it. Those are reported at prune time — a warning
-// the user reads now beats a module-not-found inside a docker build.
-// The import scan is STATIC and deliberately simple: it sees `from '…'`,
-// `import '…'` and `import('…')`, and nothing computed.
-
-import { cp, mkdir, stat, writeFile } from 'node:fs/promises'
-import path from 'node:path'
-import {
-  buildPackageGraph,
-  findWorkspaceRoot,
-  loadWorkspace,
-  listProjects,
-} from '../workspace/index.js'
-import { UserError } from '../util/index.js'
-
-interface PruneWorkspaceArgs {
-  project?: string
-  outDir: string
-  docker: boolean
-  error?: string
-}
-
-export function parsePruneWorkspaceArgs(args: readonly string[]): PruneWorkspaceArgs {
-  const out: PruneWorkspaceArgs = { outDir: 'out', docker: false }
-  for (let i = 0; i < args.length; i++) {
-    const a = args[i]!
-    if (a === '--out-dir' || a.startsWith('--out-dir=')) {
-      const v = a === '--out-dir' ? args[++i] : a.slice('--out-dir='.length)
-      if (v === undefined || v === '') return { ...out, error: 'invalid --out-dir: empty' }
-      out.outDir = v
-      continue
-    }
-    if (a === '--docker') {
-      out.docker = true
-      continue
-    }
-    if (a.startsWith('-')) return { ...out, error: `unknown flag: ${a}` }
-    if (out.project !== undefined) return { ...out, error: `unexpected argument: ${a}` }
-    out.project = a
-  }
-  return out
-}
-
-const COPY_EXCLUDES = new Set(['node_modules', '.git', '.vx', '.turbo'])
-
-/** Root-level files worth carrying into the subset, when they exist. */
-const ROOT_FILES = ['package.json', '.npmrc', '.nvmrc']
-const WORKSPACE_CONFIGS = [
-  'vx.workspace.ts',
-  'vx.workspace.mts',
-  'vx.workspace.js',
-  'vx.workspace.mjs',
-]
-const LOCKFILES = ['pnpm-lock.yaml', 'bun.lock', 'bun.lockb', 'package-lock.json', 'yarn.lock']
-
-async function exists(p: string): Promise<boolean> {
-  return stat(p).then(
-    () => true,
-    () => false,
-  )
-}
-
-async function copyDirFiltered(src: string, dest: string): Promise<void> {
-  await cp(src, dest, {
-    recursive: true,
-    filter: (source) => !COPY_EXCLUDES.has(path.basename(source)),
-  })
-}
-
-const PROJECT_CONFIGS = ['vx.config.ts', 'vx.config.mts', 'vx.config.js', 'vx.config.mjs']
-/** `from '…'`, `import '…'`, `import('…')`. Static specifiers only. */
-const SPECIFIER_RE = /(?:from|import)\s*\(?\s*['"]([^'"]+)['"]/g
-
-async function readImports(dir: string, names: readonly string[]): Promise<string[]> {
-  for (const f of names) {
-    const p = path.join(dir, f)
-    if (!(await exists(p))) continue
-    const text = await Bun.file(p).text()
-    return [...text.matchAll(SPECIFIER_RE)].map((m) => m[1]!)
-  }
-  return []
-}
-
-export async function pruneWorkspaceCmd(args: readonly string[]): Promise<number> {
-  const parsed = parsePruneWorkspaceArgs(args)
-  if (parsed.error !== undefined) throw new UserError(`vx prune: ${parsed.error}`)
-  if (parsed.project === undefined) {
-    throw new UserError('vx prune: <project> required (e.g. vx prune @acme/api)')
-  }
-
-  const root = await findWorkspaceRoot(process.cwd())
-  const workspace = await loadWorkspace(root)
-  const projects = await listProjects(workspace)
-  const byName = new Map(projects.map((p) => [p.name, p]))
-
-  const target = byName.get(parsed.project)
-  if (target === undefined) {
-    const names = [...byName.keys()].sort()
-    const q = parsed.project.toLowerCase()
-    const near = names.filter((n) => n.toLowerCase().includes(q)).slice(0, 3)
-    throw new UserError(
-      `vx prune: no project named "${parsed.project}"` +
-        (near.length > 0 ? ` — did you mean ${near.join(', ')}?` : ''),
-    )
-  }
-
-  const graph = buildPackageGraph(projects)
-  const names = new Set([target.name, ...graph.transitiveDeps(target.name)])
-
-  // The workspace config runs BEFORE any task, so a plugin it imports from a
-  // workspace package is as load-bearing as a package dependency — without it
-  // `vx run` in the container fails to load the config at all. Pull those in
-  // (with their own dep closure). The root member is the one that cannot be:
-  // copying it would mean copying the whole tree, so it is reported instead.
-  const projectFor = (spec: string): (typeof projects)[number] | undefined =>
-    projects.find((p) => spec === p.name || spec.startsWith(`${p.name}/`))
-  const uncopyable = new Set<string>()
-  for (const spec of await readImports(root, WORKSPACE_CONFIGS)) {
-    const owner = projectFor(spec)
-    if (owner === undefined || names.has(owner.name)) continue
-    if (owner.dir === root) {
-      uncopyable.add(`${owner.name} (the workspace root itself)`)
-      continue
-    }
-    names.add(owner.name)
-    for (const d of graph.transitiveDeps(owner.name)) names.add(d)
-  }
-
-  const subset = [...names].map((n) => byName.get(n)!).sort((a, b) => a.name.localeCompare(b.name))
-
-  const outAbs = path.resolve(process.cwd(), parsed.outDir)
-  // Three shapes that would eat their own tail: the out dir IS the root
-  // (overwrites the workspace), CONTAINS the root (copies land above the
-  // repo), or sits INSIDE a package being copied (cp would recurse into
-  // its own output). A root-level ./out is fine — only package dirs are
-  // copied wholesale, never the root itself.
-  if (outAbs === root || root.startsWith(outAbs + path.sep)) {
-    throw new UserError('vx prune: --out-dir must not be, or contain, the workspace root')
-  }
-  for (const p of subset) {
-    if (outAbs === p.dir || outAbs.startsWith(p.dir + path.sep)) {
-      throw new UserError(
-        `vx prune: --out-dir is inside ${p.name}, which is being copied — pick a path outside the pruned packages`,
-      )
-    }
-  }
-  const fullDir = parsed.docker ? path.join(outAbs, 'full') : outAbs
-  const jsonDir = path.join(outAbs, 'json')
-  await mkdir(fullDir, { recursive: true })
-  if (parsed.docker) await mkdir(jsonDir, { recursive: true })
-
-  const rels = subset.map((p) => path.relative(root, p.dir).split(path.sep).join('/'))
-  // pnpm-workspace.yaml rewritten to the exact subset — globs that match
-  // nothing in the subset make installs fail.
-  const workspaceYaml = `packages:\n${rels.map((r) => `  - "${r}"\n`).join('')}`
-
-  // package.json's `workspaces` is where bun/npm/yarn read membership, and it
-  // needs the SAME rewrite as pnpm-workspace.yaml for the same reason — except
-  // the failure is sharper: a GLOB matching nothing is tolerated, but an entry
-  // naming an exact dir that the subset does not contain is fatal
-  // (`bun install` → `error: Workspace not found "packages/b"`, exit 1), so the
-  // emitted context would not install at all. A `.` entry is kept when it was
-  // there: it names the root package, whose manifest is copied.
-  const rewriteRootManifest = async (dest: string): Promise<boolean> => {
-    const src = path.join(root, 'package.json')
-    if (!(await exists(src))) return false
-    let pkg: Record<string, unknown>
-    try {
-      pkg = JSON.parse(await Bun.file(src).text()) as Record<string, unknown>
-    } catch {
-      return false // unparseable: copy it verbatim rather than lose it
-    }
-    const field = pkg['workspaces']
-    const list = Array.isArray(field)
-      ? field
-      : typeof field === 'object' && field !== null && Array.isArray((field as never)['packages'])
-        ? ((field as never)['packages'] as string[])
-        : undefined
-    if (list === undefined) return false
-    const next = (list as string[]).includes('.') ? ['.', ...rels] : [...rels]
-    pkg['workspaces'] = Array.isArray(field) ? next : { ...(field as object), packages: next }
-    await writeFile(path.join(dest, 'package.json'), `${JSON.stringify(pkg, null, 2)}\n`)
-    return true
-  }
-
-  const emitRoots = async (dest: string): Promise<void> => {
-    await writeFile(path.join(dest, 'pnpm-workspace.yaml'), workspaceYaml)
-    const manifestWritten = await rewriteRootManifest(dest)
-    for (const f of [...ROOT_FILES, ...WORKSPACE_CONFIGS, ...LOCKFILES]) {
-      if (f === 'package.json' && manifestWritten) continue
-      const src = path.join(root, f)
-      if (await exists(src)) await cp(src, path.join(dest, f))
-    }
-  }
-
-  await emitRoots(fullDir)
-  for (const [i, p] of subset.entries()) {
-    await copyDirFiltered(p.dir, path.join(fullDir, rels[i]!))
-  }
-
-  if (parsed.docker) {
-    await emitRoots(jsonDir)
-    for (const [i, p] of subset.entries()) {
-      const pkgJson = path.join(p.dir, 'package.json')
-      if (await exists(pkgJson)) {
-        const destDir = path.join(jsonDir, rels[i]!)
-        await mkdir(destDir, { recursive: true })
-        await cp(pkgJson, path.join(destDir, 'package.json'))
-      }
-    }
-  }
-
-  // Every copied config is re-read to report what the subset canNOT satisfy:
-  // a relative import reaching outside the copied dirs, or a workspace package
-  // that is not here. Copied root files (the manifest, the lockfile, the
-  // workspace config) count as present — a config importing one of those is
-  // fine, and flagging it would be a false alarm.
-  const copiedRootFiles = new Set([...ROOT_FILES, ...WORKSPACE_CONFIGS, ...LOCKFILES])
-  const escapes: string[] = []
-  for (const p of subset) {
-    for (const spec of await readImports(p.dir, PROJECT_CONFIGS)) {
-      if (spec.startsWith('.')) {
-        const resolved = path.resolve(p.dir, spec)
-        const inSubset = subset.some(
-          (q) => resolved === q.dir || resolved.startsWith(q.dir + path.sep),
-        )
-        const isCopiedRootFile =
-          path.dirname(resolved) === root && copiedRootFiles.has(path.basename(resolved))
-        if (!inSubset && !isCopiedRootFile) {
-          escapes.push(`${p.name}: ${spec} resolves outside the pruned subset`)
-        }
-        continue
-      }
-      const owner = projectFor(spec)
-      if (owner !== undefined && !subset.includes(owner)) {
-        escapes.push(`${p.name}: imports ${owner.name}, which is not in the subset`)
-      }
-    }
-  }
-
-  process.stdout.write(
-    `pruned ${subset.length} package${subset.length === 1 ? '' : 's'} for ${target.name} → ${parsed.outDir}${parsed.docker ? ' (docker layout: json/ + full/)' : ''}\n` +
-      subset.map((p) => `  ${p.name}\n`).join(''),
-  )
-  for (const u of uncopyable) {
-    process.stderr.write(
-      `vx prune: WARNING the workspace config imports ${u} — it cannot be copied into a subset, so \`vx run\` inside the container will not load it\n`,
-    )
-  }
-  for (const e of escapes) {
-    process.stderr.write(`vx prune: WARNING ${e}\n`)
-  }
-  return 0
-}