@vzn/vx-migrate 0.0.594 → 0.0.596

package/src/migrate.ts

@@ -1,10 +1,12 @@
-// `vx-migrate [--from turbo|nx] [--native|--keep] [--no-install] [--dry]
+// `vx-migrate [--from turbo|nx|vite-task] [--native|--keep] [--no-install] [--dry]
 // [--force] [--mjs]` — one vx.config.ts per workspace package from an
 // existing Turbo or Nx setup (`--keep`: the workspace file that reads it
 // live instead, as `vx init` writes it), and vx installed with the repo's
 // manager.
 // Without either mode flag a terminal is asked; anything else is native. Source auto-detect: turbo.json → Turbo;
-// .nx/workspace-data/project-graph.json or nx.json → Nx (the resolved graph, exported by nx if absent);
+// .nx/workspace-data/project-graph.json, nx.json or a Lerna-on-Nx lerna.json → Nx (the resolved
+// graph, exported by nx if absent); `vite-plus` in the root package.json → Vite Task, last:
+// vite-plus is a whole toolchain, so beside turbo.json or Nx it is not the task runner.
 // The mappers return a plan; core's migration seam
 // (`applyMigration`) renders, guards, writes and reports, so what this
 // package writes reads exactly like what `vx init` writes.
@@ -23,17 +25,20 @@ import {
   type MigrationPlan,
   UserError,
 } from '@vzn/vx'
-import { migrateNx, NX_GRAPH_REL } from './migrate-nx.js'
+import { migrateNx, NX_GRAPH_REL, nxWorkspaceFields } from './migrate-nx.js'
 import { exportGraph } from './nx/export-graph.js'
+import { readNxJson } from './nx/nx-map.js'
 import {
   type AdoptionMode,
   install,
   missingPackages,
   MODE_QUESTION,
   ownVersion,
+  packageManagerOf,
   parseModeAnswer,
 } from './adopt.js'
 import { migrateTurbo } from './migrate-turbo.js'
+import { migrateViteTask } from './migrate-vite-task.js'
 import { turboConfigFile } from './turbo/turbo-map.js'
 import {
   extendWorkspaceFile,
@@ -41,6 +46,7 @@ import {
   renderWorkspaceFile,
   workspaceFileAt,
   workspacePlugins,
+  type WorkspacePlugin,
 } from './workspace-plugins.js'
 
 export interface MigrateArgs {
@@ -48,7 +54,7 @@ export interface MigrateArgs {
   force: boolean
   /** `vx.config.mjs` (and `vx-preset.mjs`) instead of `.ts`. */
   mjs: boolean
-  from?: 'turbo' | 'nx'
+  from?: 'turbo' | 'nx' | 'vite-task'
   /** `--native` / `--keep`; unset asks a terminal and is native elsewhere. */
   mode?: AdoptionMode
   /** `--no-install`: leave package.json's dependencies alone. */
@@ -59,7 +65,7 @@ export interface MigrateArgs {
 }
 
 const USAGE =
-  'usage: vx-migrate [--from turbo|nx] [--native|--keep] [--no-install] [--dry] [--force] [--mjs]'
+  'usage: vx-migrate [--from turbo|nx|vite-task] [--native|--keep] [--no-install] [--dry] [--force] [--mjs]'
 
 export function parseMigrateArgs(args: readonly string[]): MigrateArgs {
   const out: MigrateArgs = { dry: false, force: false, mjs: false }
@@ -77,10 +83,10 @@ export function parseMigrateArgs(args: readonly string[]): MigrateArgs {
       out.mode = mode
     } else if (a === '--from' || a?.startsWith('--from=')) {
       const v = a === '--from' ? args[++i] : a.slice('--from='.length)
-      if (v !== 'turbo' && v !== 'nx') {
+      if (v !== 'turbo' && v !== 'nx' && v !== 'vite-task') {
         return {
           ...out,
-          error: `--from must be turbo or nx (package.json scripts: \`vx init\`)`,
+          error: `--from must be turbo, nx or vite-task (package.json scripts: \`vx init\`)`,
         }
       }
       out.from = v
@@ -124,13 +130,15 @@ export async function migrateCmd(args: readonly string[]): Promise<number> {
   const hasTurbo = turboFile !== null
   const hasGraph = await Bun.file(path.join(root, NX_GRAPH_REL)).exists()
   const hasNxJson = await Bun.file(path.join(root, 'nx.json')).exists()
+  // A Turbo repo's lerna.json publishes; Turbo runs its tasks.
+  const lerna = !hasTurbo && !hasGraph && !hasNxJson && lernaOnNx(root)
 
   // Evaluating teams routinely have two runners checked in — never
   // ask anyone to delete anything; --from disambiguates.
   const found = (
     [
       ['turbo', hasTurbo, 'turbo.json'],
-      ['nx', hasGraph || hasNxJson, 'an nx workspace'],
+      ['nx', hasGraph || hasNxJson || lerna, 'an nx workspace'],
     ] as const
   ).filter(([, present]) => present)
   if (parsed.from === undefined && found.length > 1) {
@@ -147,28 +155,57 @@ export async function migrateCmd(args: readonly string[]): Promise<number> {
     throw new UserError('--from turbo, but no turbo.json at the workspace root')
   }
 
-  const runner: 'turbo' | 'nx' | undefined =
-    parsed.from ?? (hasTurbo ? 'turbo' : hasGraph || hasNxJson ? 'nx' : undefined)
+  const runner: 'turbo' | 'nx' | 'vite-task' | undefined =
+    parsed.from ??
+    (hasTurbo
+      ? 'turbo'
+      : hasGraph || hasNxJson || lerna
+        ? 'nx'
+        : (await hasVitePlus(root))
+          ? 'vite-task'
+          : undefined)
   if (runner === undefined) {
     throw new UserError(
-      'nothing to migrate: no turbo.json and no Nx workspace — ' +
+      'nothing to migrate: no turbo.json, no Nx workspace and no vite-plus — ' +
         'for package.json scripts, run `vx init`',
     )
   }
-  const mode = parsed.mode ?? (await askMode(runner, parsed.dry))
-  if (mode === 'keep') return keep(root, runner, hasTurbo, parsed)
+  if (runner === 'vite-task' && parsed.mode === 'keep') {
+    throw new UserError(
+      '--keep: no plugin runs a Vite Task config live; drop --keep to write vx.config files',
+    )
+  }
+  const mode =
+    runner === 'vite-task'
+      ? 'native'
+      : (parsed.mode ?? (await askMode(runner, lerna ? 'lerna.json' : undefined, parsed.dry)))
+  if (mode === 'keep' && runner !== 'vite-task') return keep(root, runner, hasTurbo, lerna, parsed)
 
   const format: MigrationFormat = parsed.mjs ? 'mjs' : 'ts'
+  // No workspace file yet: this run writes one, declaring the plugins the
+  // repo calls for and the run settings nx.json holds.
+  const writesWorkspace = workspaceFileAt(root) === undefined
   let source: string
   let plan: MigrationPlan
-  if (runner === 'nx') {
+  if (runner === 'vite-task') {
+    source = 'vite.config run.tasks'
+    plan = await migrateViteTask(root, metas, format)
+  } else if (runner === 'nx') {
     if (hasGraph) {
       source = NX_GRAPH_REL
-      plan = await migrateNx(root, metas, format)
+      plan = await migrateNx(root, metas, format, undefined, writesWorkspace)
     } else {
       // Modern Nx stores the graph in SQLite, so the JSON snapshot exists only
       // when exported. The workspace's own nx exports it, as `nx()` does, into
       // a temp file; the user ran that step by hand until 2026-10-01.
+      // A fresh clone: the export's own reason names the plugin's `graph`
+      // option, which the CLI does not take.
+      if (!existsSync(path.join(root, 'node_modules', '.bin', 'nx'))) {
+        throw new UserError(
+          `nx is not installed here (no node_modules/.bin/nx), and vx-migrate reads the graph it exports — ` +
+            `run \`${packageManagerOf(root, process.env['npm_config_user_agent'])} install\`, then vx-migrate again`,
+        )
+      }
       const tmp = await mkdtemp(path.join(os.tmpdir(), 'vx-migrate-nx-'))
       try {
         const snapshot = path.join(tmp, 'project-graph.json')
@@ -180,7 +217,7 @@ export async function migrateCmd(args: readonly string[]): Promise<number> {
           )
         }
         source = 'nx graph'
-        plan = await migrateNx(root, metas, format, snapshot)
+        plan = await migrateNx(root, metas, format, snapshot, writesWorkspace)
       } finally {
         await rm(tmp, { recursive: true, force: true })
       }
@@ -201,22 +238,42 @@ export async function migrateCmd(args: readonly string[]): Promise<number> {
           existsSync(path.join(p.dir, configName))),
     ) ||
       plan.extraFiles.some((f) => existsSync(path.join(root, f.relPath))))
-  // No workspace file yet: write one declaring the plugins the repo calls
-  // for, and drop the note that told the user to declare the lockfile one.
-  const plugins = workspaceFileAt(root) === undefined ? workspacePlugins(root) : []
-  if (plugins.length > 0) {
+  // Drop the note that told the user to declare the lockfile plugin.
+  const plugins = writesWorkspace ? workspacePlugins(root) : []
+  if (writesWorkspace) {
+    const fields =
+      runner === 'nx'
+        ? nxWorkspaceFields((await readNxJson(root).catch(() => null))?.json).flatMap((f) =>
+            f.source === undefined ? [] : [{ field: f.field, source: f.source }],
+          )
+        : []
     plan = {
       ...plan,
       headerNotes: plan.headerNotes.filter((n) => !n.includes('from @vzn/vx-lockfile')),
       extraFiles: [
         ...plan.extraFiles,
-        { relPath: `vx.workspace.${format}`, contents: renderWorkspaceFile(plugins, format) },
+        {
+          relPath: `vx.workspace.${format}`,
+          contents: renderWorkspaceFile(plugins, format, fields),
+        },
       ],
     }
   }
+  // An executor target is an `nx-exec` line and a `.env` one an `nx-env`
+  // line: both bins are this package's, and `bunx` leaves none behind.
+  const runsBins = plan.projects.some((p) =>
+    p.tasks.some((t) => {
+      const cmd = (t.task?.['exec'] as { command?: unknown } | undefined)?.command
+      return typeof cmd === 'string' && /^nx-(exec|env) /.test(cmd)
+    }),
+  )
   const headerNotes = refused
     ? []
-    : await prepareRepo(root, ['@vzn/vx', ...plugins.map((p) => p.pkg)], parsed)
+    : await prepareRepo(
+        root,
+        ['@vzn/vx', ...(runsBins ? ['@vzn/vx-migrate'] : []), ...plugins.map((p) => p.pkg)],
+        parsed,
+      )
   return applyMigration({
     root,
     metas,
@@ -230,10 +287,25 @@ export async function migrateCmd(args: readonly string[]): Promise<number> {
   })
 }
 
+/** vite-plus (`vp run`) in the root package.json's dependencies. */
+async function hasVitePlus(root: string): Promise<boolean> {
+  const pkg = (await Bun.file(path.join(root, 'package.json'))
+    .json()
+    .catch(() => ({}))) as Record<string, unknown>
+  return ['dependencies', 'devDependencies'].some((f) => {
+    const deps = pkg[f]
+    return typeof deps === 'object' && deps !== null && Object.hasOwn(deps, 'vite-plus')
+  })
+}
+
 /** A terminal is asked which adoption it wants; anything else gets native. */
-async function askMode(runner: 'turbo' | 'nx', dry: boolean): Promise<AdoptionMode> {
+async function askMode(
+  runner: 'turbo' | 'nx',
+  file: string | undefined,
+  dry: boolean,
+): Promise<AdoptionMode> {
   if (dry || !process.stdin.isTTY || !process.stdout.isTTY) return 'native'
-  const source = runner === 'turbo' ? 'turbo.json' : 'nx.json'
+  const source = file ?? (runner === 'turbo' ? 'turbo.json' : 'nx.json')
   for (;;) {
     const mode = parseModeAnswer(prompt(MODE_QUESTION(runner, source)))
     if (mode !== undefined) return mode
@@ -268,6 +340,7 @@ async function keep(
   root: string,
   runner: 'turbo' | 'nx',
   hasTurbo: boolean,
+  lerna: boolean,
   args: MigrateArgs,
 ): Promise<number> {
   // `vx init` reads turbo.json first.
@@ -291,6 +364,9 @@ async function keep(
   )) {
     process.stdout.write(`vx-migrate: ${note}\n`)
   }
+  // `vx init` adopts nx() by nx.json, and a Lerna repo may have none: it
+  // would map the scripts instead, so the file is written here.
+  if (lerna) return keepLerna(root, plugins, args)
   // A resolve that misses from a directory with no node_modules is an
   // auto-install under Bun: ask the root only where it has the package.
   const installed = path.join(root, 'node_modules', '@vzn', 'vx')
@@ -316,3 +392,82 @@ async function keep(
   }
   return code
 }
+
+/** `--keep` in a Lerna repo with no nx.json: the workspace file declaring `nx()`. */
+async function keepLerna(
+  root: string,
+  plugins: readonly WorkspacePlugin[],
+  args: MigrateArgs,
+): Promise<number> {
+  const format = args.mjs ? 'mjs' : 'ts'
+  const name = `vx.workspace.${format}`
+  const existing = workspaceFileAt(root)
+  const all = [{ pkg: '@vzn/vx-migrate', factory: 'nx' }, ...plugins]
+  if (existing !== undefined && !args.force) {
+    const text = readFileSync(path.join(root, existing), 'utf8')
+    const extended = extendWorkspaceFile(text, all)
+    if (extended === null) {
+      throw new UserError(
+        `${existing} exists; add nx() from @vzn/vx-migrate to its plugins, or --force replaces it`,
+      )
+    }
+    if (!args.dry && extended !== text) await Bun.write(path.join(root, existing), extended)
+    const names = undeclared(text, all).map((p) => `${p.factory}()`)
+    if (names.length > 0)
+      process.stdout.write(
+        `vx-migrate: ${args.dry ? 'would declare' : 'declared'} ${names.join(', ')} in ${existing}\n`,
+      )
+    return 0
+  }
+  const text = renderWorkspaceFile(all, format)
+  if (args.dry) {
+    process.stdout.write(`── ${name} ──\n${text}\nvx-migrate: would write ${name} (dry run)\n`)
+    return 0
+  }
+  if (existing !== undefined && existing !== name) await rm(path.join(root, existing))
+  await Bun.write(path.join(root, name), text)
+  process.stdout.write(`vx-migrate: lerna.json found — wrote ${name} declaring nx()\n`)
+  return 0
+}
+
+/**
+ * Lerna 6+ runs `lerna run` on Nx's task runner over the graph `nx graph`
+ * exports, nx.json or not, unless lerna.json says `useNx: false`; Lerna 5
+ * ran its own unless it said `useNx: true`. Lerna is the installed one,
+ * else the root manifest's range; with neither, the lerna.json is another
+ * tool's (lerna-lite reads it too, and runs no Nx). A repo whose root
+ * scripts never `lerna run` runs its tasks some other way and publishes
+ * with Lerna (webdriverio: `run-s`, `pnpm -r`): its scripts are the source.
+ */
+const LERNA_RUN = /(?:^|[\s;&|(])lerna\s+run\s/
+
+function lernaOnNx(root: string): boolean {
+  const json = (file: string): Record<string, unknown> | undefined => {
+    try {
+      return JSON.parse(readFileSync(file, 'utf8').replace(/^\uFEFF/, '')) as Record<
+        string,
+        unknown
+      >
+    } catch {
+      return undefined
+    }
+  }
+  const config = json(path.join(root, 'lerna.json'))
+  if (config === undefined) return false
+  const installed = json(path.join(root, 'node_modules', 'lerna', 'package.json'))?.['version']
+  const manifest = json(path.join(root, 'package.json'))
+  const declared = ['devDependencies', 'dependencies']
+    .map((k) => (manifest?.[k] as Record<string, unknown> | undefined)?.['lerna'])
+    .find((v): v is string => typeof v === 'string')
+  const version = typeof installed === 'string' ? installed : declared
+  if (version === undefined) return false
+  const scripts = manifest?.['scripts']
+  const runs =
+    scripts !== null &&
+    typeof scripts === 'object' &&
+    Object.values(scripts).some((v) => typeof v === 'string' && LERNA_RUN.test(v))
+  if (!runs) return false
+  if (typeof config['useNx'] === 'boolean') return config['useNx']
+  const major = /\d+/.exec(version)?.[0]
+  return major === undefined || Number(major) >= 6
+}

package/src/nx/index.ts

@@ -42,6 +42,7 @@ import {
   readNxJson,
 } from './nx-map.js'
 import { exportGraph } from './export-graph.js'
+import { lernaJsonText } from './lerna.js'
 export type {
   NxExecutors,
   NxExecutorTarget,
@@ -295,7 +296,7 @@ const textOf = (file: string): Promise<string> =>
     .catch(() => '\0absent')
 
 /**
- * Everything the mapping reads: the graph, nx.json and its `extends` chain, every package manifest
+ * Everything the mapping reads: the graph, nx.json and its `extends` chain, lerna.json, every package manifest
  * and the package.json of each graph node no package matches (its
  * synthetic project's name), the `.env` names in every project dir,
  * NX_LOAD_DOT_ENV_FILES, whether the bins the tasks run are installed,
@@ -326,6 +327,8 @@ async function nxReads(
   return [
     graphText,
     ...(await Promise.all(chain.map(textOf))),
+    // Its presence orders each target after its dependencies' (`lerna run`).
+    String(await lernaJsonText(root)),
     // A config file added beside mapped tasks changes what an output may cover.
     JSON.stringify(metas.map((m) => [m.name, m.dir, m.packageJson, m.configPath])),
     ...(await Promise.all(unmatched.map((r) => textOf(path.join(root, r, 'package.json'))))),

package/src/nx/lerna.ts

@@ -0,0 +1,60 @@
+// `lerna run <x>` orders each package's <x> after its dependencies' <x>.
+// Lerna 6+ runs it on Nx's task runner and passes that order as the target
+// dependency `^<x>` — and drops every other one — unless the repo
+// configures Nx tasks itself: nx.json `targetDefaults` (or the legacy
+// `targetDependencies`), or an `nx` key in the package.json of a package
+// that has <x> (lerna's `prepNxOptions`, 9.0.7). The exported graph holds
+// none of this, so a Lerna repo mapped from it ran every build at once.
+
+import path from 'node:path'
+
+interface Target {
+  dependsOn?: unknown[]
+}
+interface Node {
+  data?: { root?: string; targets?: Record<string, Target> }
+}
+
+/** The text of `root/lerna.json`, or null when there is none. */
+export async function lernaJsonText(root: string): Promise<string | null> {
+  return Bun.file(path.join(root, 'lerna.json'))
+    .text()
+    .catch(() => null)
+}
+
+/**
+ * The graph's nodes with Lerna's order applied, or `nodes` itself when the
+ * repo has no lerna.json or configures Nx's task dependencies.
+ * `manifest(rel)`: the package.json a root-relative node root holds.
+ */
+export async function withLernaOrder<N extends Node>(
+  root: string,
+  nodes: Record<string, N>,
+  nxJson: Record<string, unknown> | undefined,
+  manifest: (rel: string) => Promise<Record<string, unknown> | undefined>,
+): Promise<Record<string, N>> {
+  if ((await lernaJsonText(root)) === null) return nodes
+  const keys = (v: unknown): number =>
+    v !== null && typeof v === 'object' ? Object.keys(v).length : 0
+  if (keys(nxJson?.['targetDependencies'] || nxJson?.['targetDefaults']) > 0) return nodes
+  const configured = new Set<string>()
+  for (const node of Object.values(nodes)) {
+    const targets = node.data?.targets
+    if (targets === undefined) continue
+    if ((await manifest(node.data?.root ?? '.'))?.['nx'] === undefined) continue
+    for (const name of Object.keys(targets)) configured.add(name)
+  }
+  const out: Record<string, N> = {}
+  for (const [id, node] of Object.entries(nodes)) {
+    const targets = node.data?.targets
+    if (targets === undefined) {
+      out[id] = node
+      continue
+    }
+    const ordered: Record<string, Target> = {}
+    for (const [name, t] of Object.entries(targets))
+      ordered[name] = configured.has(name) ? t : { ...t, dependsOn: [`^${name}`] }
+    out[id] = { ...node, data: { ...node.data, targets: ordered } }
+  }
+  return out
+}

package/src/nx/nx-inputs.ts

@@ -7,7 +7,7 @@
 // (`dependentTasksOutputFiles`) is nothing; `externalDependencies` is a todo saying
 // so. Extracted from `buildTask` in item 606.
 
-import { nxWorkspacePath, underProject } from './nx-outputs.js'
+import { nxWorkspacePath, underProject, withProjectDir } from './nx-outputs.js'
 import { minimatchToVx } from '../glob-grammar.js'
 import { shellQuote } from '../nx-command.js'
 
@@ -68,21 +68,18 @@ export function expandNxInputs(
           todos.push(`input ${JSON.stringify(entry)} uses a token vx does not support`)
           return
         }
-        if (neg === '' && at.outputs?.some((o) => p === o || p.startsWith(`${o}/`))) {
-          todos.push(
-            `input ${JSON.stringify(entry)} is an output of the project's own targets: git does not ` +
-              'list it, so vx cannot key on it — dropped; the task that writes it keys its dependants through dependsOn',
-          )
-          return
-        }
+        // Nx's file map skips gitignored files, so it hashes nothing here
+        // either: a changed `dist` file is a cache hit under Nx 23.3 (YL-1).
+        const lit = withProjectDir(p, at.rel, false)
+        if (neg === '' && at.outputs?.some((o) => lit === o || lit.startsWith(`${o}/`))) return
         const g = minimatchToVx(p, neg !== '')
         if (g === null) {
           todos.push(`input ${JSON.stringify(entry)}: glob syntax vx cannot take — map manually`)
           return
         }
         const own = underProject(g, at.rel)
-        if (own === null) into.wsFiles.push(neg + g)
-        else into.files.push(neg + own)
+        if (own === null) into.wsFiles.push(neg + withProjectDir(g, at.rel, true))
+        else into.files.push(neg + withProjectDir(own, at.rel, true))
         return
       }
       // Bare string = named-input reference.
@@ -197,7 +194,10 @@ export function expandNxInputs(
     }
     // A negation filters only other includeIgnored matches, and a literal
     // reads no others.
-    if (!neg) into.runtimeCmds.push(`cat -- ${shellQuote(p)} 2>/dev/null; echo "$?"`)
+    if (!neg)
+      into.runtimeCmds.push(
+        `cat -- ${shellQuote(withProjectDir(p, at.rel, false))} 2>/dev/null; echo "$?"`,
+      )
   }
   for (const entry of entries) expand(entry, new Set())
   // Nx matches a project fileset with no positive glob against every project

package/src/nx/nx-map.ts

@@ -37,6 +37,7 @@ import {
 } from '../shared-outputs.js'
 import type { TrackedKinds } from '../tracked-outputs.js'
 import { packageScripts, relPosix } from '../paths.js'
+import { withLernaOrder } from './lerna.js'
 import { mapNxDeps, matchNxProjects, type TaskNameFor } from './nx-deps.js'
 import {
   dotenvCandidates,
@@ -304,7 +305,17 @@ export async function mapNxWorkspace(
   graph: NxGraph,
   opts: MapNxOptions,
 ): Promise<NxMapping> {
-  const nodeMap = graph.nodes
+  const byRel = new Map(metas.map((m) => [normRel(relPosix(root, m.dir)), m.packageJson]))
+  const nodeMap = await withLernaOrder(
+    root,
+    graph.nodes,
+    (await readNxJson(root).catch(() => null))?.json,
+    async (rel) =>
+      (byRel.get(normRel(rel)) as Record<string, unknown> | undefined) ??
+      (await Bun.file(path.join(root, rel, 'package.json'))
+        .json()
+        .catch(() => undefined)),
+  )
   const g = graph
 
   const { namedInputs, cacheable, globalSync } = await readNxJsonFacts(root)
@@ -923,7 +934,10 @@ function buildTask(
   }
   const exec: Record<string, unknown> = { command: mapped.command }
   const env: Record<string, unknown> = {}
-  if (inputs.envNames.length > 0) env.passThrough = inputs.envNames
+  // A name that is no shell identifier never reached a task (`sh` drops it)
+  // and core refuses it in passThrough; the key still reads it.
+  const passThrough = inputs.envNames.filter((n) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(n))
+  if (passThrough.length > 0) env.passThrough = passThrough
   // Nx hands every task its target (`getNxEnvVariablesForTask`), and
   // `nx exec -- <cmd>`, a package script's way to run under Nx, reads it:
   // unset, it booted Nx's own task runner, which ran the target and its

package/src/nx/nx-outputs.ts

@@ -2,7 +2,8 @@
 // workspace-root globs. Extracted from `buildTask` in item 606.
 
 import path from 'node:path'
-import { minimatchToVx } from '../glob-grammar.js'
+import { isLiteralPattern } from '@vzn/vx'
+import { literalGlob, minimatchToVx } from '../glob-grammar.js'
 import { takingBack } from '../shared-outputs.js'
 
 interface NxOutputs {
@@ -18,12 +19,13 @@ interface NxOutputs {
  * became the literal glob `coverage/{projectRoot}/**`, saved nothing, and a
  * hit restored nothing. Null when a token is left or the path leaves the
  * workspace; a brace set is no token (item 914 — 912 read one as a gap).
+ * The project dir comes back masked: {@link withProjectDir} writes it in.
  */
 export function nxWorkspacePath(s: string, projectRel: string, projectName: string): string | null {
   const rel = projectRel === '.' ? '' : projectRel
   const p = s
     .replaceAll('{workspaceRoot}', '')
-    .replaceAll('{projectRoot}', rel)
+    .replaceAll('{projectRoot}', masked(rel))
     .replaceAll('{projectName}', projectName)
   // A token left over is a gap; a brace set (`*.{ts,tsx}`) is a glob.
   if (/\{[\w.]+\}/.test(p)) return null
@@ -31,10 +33,38 @@ export function nxWorkspacePath(s: string, projectRel: string, projectName: stri
   return n === '.' || n === '..' || n.startsWith('../') ? null : n
 }
 
+// A project dir is a path, never a glob: `packages/a{b}` read as a token
+// dropped every `{projectRoot}` path, and `packages/[x]` translated as a
+// class reached `packages/x`. Each dir segment stands in as `\uE000<i>\uE001`
+// until the glob is vx's, so `..` still pops one.
+const MASKED = /\uE000(\d+)\uE001/g
+
+function masked(rel: string): string {
+  return rel === ''
+    ? ''
+    : rel
+        .split('/')
+        .map((_, i) => `\uE000${i}\uE001`)
+        .join('/')
+}
+
+/** `p` with the masked project dir written back: as a path, or escaped for a glob. */
+export function withProjectDir(p: string, projectRel: string, asGlob: boolean): string {
+  const segs = projectRel.split('/')
+  return p.replace(MASKED, (_, i: string, at: number) => {
+    const seg = segs[Number(i)]!
+    if (!asGlob) return seg
+    // Only a glob's head reads `!` as a negation.
+    return at === 0 ? literalGlob(seg) : literalGlob(`/${seg}`).slice(1)
+  })
+}
+
 /** A workspace path relative to the project dir, or null when it lies outside. */
 export function underProject(p: string, projectRel: string): string | null {
   if (projectRel === '.' || projectRel === '') return p
-  return p.startsWith(`${projectRel}/`) ? p.slice(projectRel.length + 1) : null
+  for (const dir of [masked(projectRel), projectRel])
+    if (p.startsWith(`${dir}/`)) return p.slice(dir.length + 1)
+  return null
 }
 
 /**
@@ -64,15 +94,16 @@ export function nxDefaultOutputs(
   }
   if (targetName !== 'build' && targetName !== 'prepare') return []
   const root = projectRel === '.' ? '' : projectRel
-  const at = (p: string): string => path.posix.join(root, p)
+  // As tokens, so the dir stays a path whatever its name holds.
+  const at = (p: string): string => (root === '' ? p : `{projectRoot}/${p}`)
   const held = ['build', 'public'].filter((d) => tops === undefined || tops.has(d))
   if (held.length > 0)
     todos.push(
-      `no outputs declared: Nx also caches ${held.map(at).join(' and ')} for this target — vx cleans an output before the run, so add ${held.length === 1 ? 'it' : 'them'} to the outputs by hand only if ${held.length === 1 ? 'it holds' : 'they hold'} nothing committed`,
+      `no outputs declared: Nx also caches ${held.map((d) => path.posix.join(root, d)).join(' and ')} for this target — vx cleans an output before the run, so add ${held.length === 1 ? 'it' : 'them'} to the outputs by hand only if ${held.length === 1 ? 'it holds' : 'they hold'} nothing committed`,
     )
   // The root project's two are one path.
   return [
-    ...new Set([path.posix.join('dist', root), at('dist')]),
+    ...new Set([root === '' ? 'dist' : '{workspaceRoot}/dist/{projectRoot}', at('dist')]),
     ...['build', 'public'].filter((d) => !held.includes(d)).map(at),
   ]
 }
@@ -145,7 +176,7 @@ export function mapNxOutputs(
     const norm = path.posix.normalize(s.replace(/^\/+/, ''))
     if (norm === '..' || norm.startsWith('../')) {
       todos.push(
-        `output ${JSON.stringify(o)} resolves to ${JSON.stringify(norm)}, outside the workspace — ` +
+        `output ${JSON.stringify(o)} resolves to ${JSON.stringify(withProjectDir(norm, projectRel, false))}, outside the workspace — ` +
           'vx caches only inside it; dropped',
       )
       continue
@@ -158,9 +189,18 @@ export function mapNxOutputs(
     for (const g of globs) {
       const gn = g.startsWith('!') ? '!' : ''
       const gs = g.slice(gn.length)
-      if (projectRel === '.') outFiles.push(g)
-      else if (gs.startsWith(`${projectRel}/`)) outFiles.push(gn + gs.slice(projectRel.length + 1))
-      else wsOutFiles.push(gn + path.posix.normalize(gs).replace(/^\.\//, ''))
+      const own = underProject(gs, projectRel)
+      if (own !== null) {
+        outFiles.push(gn + withProjectDir(own, projectRel, true))
+        continue
+      }
+      const m = path.posix.normalize(gs).replace(/^\.\//, '')
+      const w = withProjectDir(m, projectRel, true)
+      wsOutFiles.push(gn + w)
+      // An escaped brace makes a literal a glob, which core matches as the
+      // path alone (`asTrees` adds the tree only to a literal).
+      if (w !== withProjectDir(m, projectRel, false) && isLiteralPattern(m.replace(MASKED, '')))
+        wsOutFiles.push(`${gn}${w}/**`)
     }
   }
   return { outFiles: takingBack(outFiles), wsOutFiles: takingBack(wsOutFiles) }
@@ -217,9 +257,19 @@ export function nxProjectOutputs(
       projectName,
       scratch,
     )
-    for (const f of [...outFiles.map((f) => path.posix.join(rel, f)), ...wsOutFiles]) {
+    const literal = (f: string): string | null => {
       const lit = f.replace(/\/\*\*(\/\*)?$/, '')
-      if (!lit.startsWith('!') && !/[*?[{]/.test(lit)) out.add(lit)
+      return lit.startsWith('!') || /[*?[]|(?<!\\)[{}]/.test(lit)
+        ? null
+        : lit.replace(/\\([{}!])/g, '$1')
+    }
+    for (const f of outFiles) {
+      const lit = literal(f)
+      if (lit !== null) out.add(path.posix.join(rel, lit))
+    }
+    for (const f of wsOutFiles) {
+      const lit = literal(f)
+      if (lit !== null) out.add(lit)
     }
   }
   const r = [...out]