@vzn/vx-migrate 0.0.646 → 0.0.649

package/src/script-command.ts

@@ -20,9 +20,10 @@
 //   the shims `yarn run` writes, so inlined, `node -e "require('left-pad')"`
 //   was MODULE_NOT_FOUND (2026-09-28). Every script runs as `yarn run <name>`.
 
-import { readFileSync } from 'node:fs'
+import { existsSync, readFileSync } from 'node:fs'
 import path from 'node:path'
 import { foldScriptHooks } from '@vzn/vx'
+import { shellQuote } from './nx-command.js'
 
 const YARN_RUN_BUILTIN = /(^|&&|\|\||;|\(|\|)\s*run\s/
 const LIFECYCLE = /^(pre|post)(install|publish|pack|version)$|^(prepare|prepublishOnly|install)$/
@@ -36,15 +37,22 @@ export function scriptCommand(
   body: string,
   scripts: Readonly<Record<string, unknown>> = {},
   pnp = false,
+  /** `runsScriptHooks`: false where the manager runs no `pre` / `post` hook. */
+  hooks = true,
 ): string {
-  if (pnp) return `yarn run ${name}`
+  if (pnp) return yarnRun(name)
   const hook = (h: string): string | undefined =>
-    !LIFECYCLE.test(h) && usable(scripts[h]) ? scripts[h] : undefined
+    hooks && !LIFECYCLE.test(h) && usable(scripts[h]) ? scripts[h] : undefined
   const parts = [hook(`pre${name}`), body, hook(`post${name}`)]
-  if (parts.some((p) => p !== undefined && YARN_RUN_BUILTIN.test(p))) return `yarn run ${name}`
+  if (parts.some((p) => p !== undefined && YARN_RUN_BUILTIN.test(p))) return yarnRun(name)
   return foldScriptHooks(parts[0], body, parts[2])
 }
 
+/** `yarn run <name>`, the name one shell word: `a b` ran script `a` with an argument. */
+export function yarnRun(name: string): string {
+  return `yarn run ${shellQuote(name)}`
+}
+
 /**
  * Yarn ≥ 2 links Plug'n'Play unless `.yarnrc.yml` names another `nodeLinker`.
  * Read once per mapping; synchronous so every mapper, the synchronous ones
@@ -67,3 +75,101 @@ export async function yarnrcText(root: string): Promise<string> {
     .text()
     .catch(() => '\0absent')
 }
+
+/**
+ * The package manager that owns `dir`, when it runs `pre` / `post` hooks
+ * around a script; null when it runs none. The manager is the nearest `packageManager` field or
+ * lockfile, and its settings are read beside it, as each reads them for a
+ * member too. Probed with a `prebuild` / `build` / `postbuild` trio: Yarn
+ * 2+ runs none (D-31); npm runs none under `ignore-scripts=true` in
+ * `.npmrc`; pnpm runs none under `enable-pre-post-scripts=false` there or
+ * `enablePrePostScripts: false` in `pnpm-workspace.yaml` (D-33); Bun and
+ * Yarn 1 run them whatever those say. No manager found is npm's default.
+ */
+export function runsScriptHooks(dir: string, memo: Map<string, Owner>): string | null {
+  const { manager, at } = ownerOf(dir, memo)
+  const read = (f: string): string | undefined => {
+    try {
+      return readFileSync(path.join(at, f), 'utf8')
+    } catch {
+      return undefined
+    }
+  }
+  const npmrc = read('.npmrc') ?? ''
+  const set = (key: string, value: string): boolean =>
+    new RegExp(`^\\s*${key}\\s*=\\s*${value}\\s*$`, 'm').test(npmrc)
+  const runs =
+    manager === 'berry'
+      ? false
+      : manager === 'npm'
+        ? !set('ignore-scripts', 'true')
+        : manager === 'pnpm'
+          ? !set('enable-pre-post-scripts', 'false') && !pnpmSkipsHooks(read('pnpm-workspace.yaml'))
+          : true
+  return runs ? manager : null
+}
+
+/**
+ * `enablePrePostScripts: false` in `pnpm-workspace.yaml`, read as pnpm reads
+ * it, as YAML: a line regex missed `false # hooks off` and a flow mapping,
+ * which pnpm 10 honours, and folded hooks pnpm does not run.
+ */
+function pnpmSkipsHooks(yaml: string | undefined): boolean {
+  if (yaml === undefined) return false
+  try {
+    const parsed = Bun.YAML.parse(yaml) as { enablePrePostScripts?: unknown } | null
+    return parsed?.enablePrePostScripts === false
+  } catch {
+    return false
+  }
+}
+
+/** The package manager that owns a directory, and the directory that says so. */
+export interface Owner {
+  manager: string
+  at: string
+}
+
+/**
+ * The nearest `packageManager` field or lockfile from `dir` up: `berry` for
+ * Yarn 2+, `yarn` for Yarn 1, else the manager's name; none found is npm.
+ */
+export function ownerOf(dir: string, memo: Map<string, Owner>): Owner {
+  const known = memo.get(dir)
+  if (known !== undefined) return known
+  const read = (f: string): string | undefined => {
+    try {
+      return readFileSync(path.join(dir, f), 'utf8')
+    } catch {
+      return undefined
+    }
+  }
+  let manager: string | undefined
+  try {
+    // A byte-order mark is stripped, as npm, pnpm and discovery strip it:
+    // JSON.parse threw on one and the field went unread.
+    const manifest = (read('package.json') ?? '').replace(/^\uFEFF/, '')
+    const pm = (JSON.parse(manifest) as { packageManager?: unknown }).packageManager
+    // A manager vx knows nothing of (zod's `nub@0.8.3`) says nothing about
+    // hooks: the lockfile beside it does, and "nub ran `postbuild`" was a
+    // claim nothing had checked (D-96).
+    if (typeof pm === 'string' && /^(npm|pnpm|yarn|bun)@/.test(pm))
+      manager = /^yarn@([2-9]|\d{2,})/.test(pm) ? 'berry' : pm.split('@')[0]
+  } catch {}
+  if (manager === undefined) {
+    const yarnLock = read('yarn.lock')
+    if (yarnLock !== undefined) manager = yarnLock.includes('\n__metadata:') ? 'berry' : 'yarn'
+    else if (existsSync(path.join(dir, 'pnpm-lock.yaml'))) manager = 'pnpm'
+    else if (existsSync(path.join(dir, 'package-lock.json'))) manager = 'npm'
+    else if (['bun.lock', 'bun.lockb'].some((f) => existsSync(path.join(dir, f)))) manager = 'bun'
+  }
+  const up = path.dirname(dir)
+  const owner =
+    manager !== undefined
+      ? { manager, at: dir }
+      : up === dir
+        ? { manager: 'npm', at: dir }
+        : ownerOf(up, memo)
+  memo.set(dir, owner)
+  return owner
+}

package/src/shared-outputs.ts

@@ -23,6 +23,7 @@
 // file exists to prevent (item 445).
 
 import { isLiteralPattern, outputsOverlap, type GeneratedTask } from '@vzn/vx'
+import { withoutTakenBack } from './glob-grammar.js'
 import { relPosix } from './paths.js'
 import type { TrackedKinds } from './tracked-outputs.js'
 
@@ -612,7 +613,12 @@ export function excludeWorkspaceOutputs(
   }
 }
 
-/** A `!` output with no positive beside it takes back nothing, and core refuses a list of them alone. */
+/**
+ * A `!` output with no positive beside it takes back nothing, and core
+ * refuses a list of them alone; a literal one takes back was never saved,
+ * and core refuses it too (trpc's `package.json`, taken back).
+ */
 export function takingBack(globs: readonly string[]): string[] {
-  return globs.some((g) => !g.startsWith('!')) ? [...globs] : []
+  const kept = withoutTakenBack(globs)
+  return kept.some((g) => !g.startsWith('!')) ? kept : []
 }

package/src/tracked-outputs.ts

@@ -222,7 +222,7 @@ interface Outputs {
 /**
  * Fit a mapped task's outputs to the committed files they cover, in place,
  * and return one `[pkg#task, todo]` per task this leaves uncached. Core
- * never cleans a committed file (owner, 2026-10-14), so
+ * never cleans a committed file (2026-10-14), so
  * the outputs keep them; what is left is the readers' `!` that hides one.
  * `tracked` is root-relative.
  */

package/src/turbo/index.ts

@@ -14,7 +14,7 @@ import path from 'node:path'
 import type { ProjectMeta, VxPlugin } from '@vzn/vx'
 import type { PackageMeta } from '../packages.js'
 import { memberProjects, withManifests } from '../manifests.js'
-import { refuseUnknownOptions, type PluginOptionKinds } from '@vzn/vx'
+import { refuseUnknownOptions, UserError, type PluginOptionKinds } from '@vzn/vx'
 import { type AdoptionRun, adoptionPlugin } from '../adoption-plugin.js'
 import type { AdoptionMapping } from '../mapping-cache.js'
 import { collectGaps } from '../plugin-gaps.js'
@@ -38,7 +38,8 @@ const PERSISTENT_NOTE =
 export interface TurboPluginOptions {
   /**
    * Where turbo.json lives. Defaults to the workspace root; a repo whose
-   * turbo.json sits elsewhere names the directory here.
+   * turbo.json sits elsewhere names the directory here, relative to the workspace
+   * root or absolute.
    */
   readonly root?: string
 }
@@ -54,22 +55,27 @@ const TURBO_PLUGIN_KEYS: PluginOptionKinds<TurboPluginOptions> = {
  */
 export function turbo(options: TurboPluginOptions = {}): VxPlugin {
   refuseUnknownOptions('turbo()', options, TURBO_PLUGIN_KEYS)
+  if (options.root === '') throw new UserError('turbo() option "root" is a directory, not empty')
+  // Against the workspace root, as vx reads every path: against the cwd,
+  // `vx run` from a package dir read another directory.
+  const rootOf = (workspaceRoot: string): string =>
+    options.root === undefined ? workspaceRoot : path.resolve(workspaceRoot, options.root)
   return adoptionPlugin(
     import.meta,
-    (ctx) => run(options.root ?? ctx.workspaceRoot, ctx.projects),
+    (ctx) => run(rootOf(ctx.workspaceRoot), ctx.projects),
     // At the workspace root only: a claim is a root name (a `root` elsewhere
     // is not claimed; its edits select as any unowned file does).
     options.root === undefined ? ['turbo.json', 'turbo.jsonc'] : [],
     {
       async config(workspace, ctx) {
-        const keys = await workspaceKeys(options.root ?? ctx.workspaceRoot)
+        const keys = await workspaceKeys(rootOf(ctx.workspaceRoot))
         if (workspace.run?.concurrency === undefined && keys.concurrency !== undefined)
           workspace.run = { ...workspace.run, concurrency: keys.concurrency }
         // `turbo run --affected` compares with TURBO_SCM_BASE when set, and
         // on GitHub Actions with what the event names.
         const base =
           Bun.env['TURBO_SCM_BASE']?.trim() ||
-          githubActionsBase(options.root ?? ctx.workspaceRoot, keys.remoteBaseFallback === true)
+          githubActionsBase(rootOf(ctx.workspaceRoot), keys.remoteBaseFallback === true)
         if (base) ctx.setBranch({ base })
       },
       // Turbo's packages are the package manager's members, each a project
@@ -189,17 +195,19 @@ const textOf = (file: string): Promise<string> =>
 /**
  * Everything the mapping reads: the root's and each package's
  * `turbo.json` / `turbo.jsonc`, every package manifest, the root's,
- * `.yarnrc.yml` and the microfrontends configs.
+ * `.yarnrc.yml`, `.npmrc`, `pnpm-workspace.yaml` and the microfrontends configs.
  */
 async function run(root: string, projects: readonly ProjectMeta[]): Promise<AdoptionRun> {
   const dirs = [root, ...projects.map((m) => m.dir)]
-  const [metas, configs, yarnrc, rootManifest] = await Promise.all([
+  const [metas, configs, yarnrc, rootManifest, hookConfigs] = await Promise.all([
     withManifests(projects),
     Promise.all(
       dirs.flatMap((d) => ['turbo.json', 'turbo.jsonc'].map((f) => textOf(path.join(d, f)))),
     ),
     textOf(path.join(root, '.yarnrc.yml')),
     textOf(path.join(root, 'package.json')),
+    // Whether the manager runs `pre` / `post` hooks, so whether they fold.
+    Promise.all(['.npmrc', 'pnpm-workspace.yaml'].map((f) => textOf(path.join(root, f)))),
   ])
   const envNames = envNamesThatMap(configs, envNamesNow())
   // The tsconfigs a `tsc` script reads are the mapping's inputs too.
@@ -218,7 +226,9 @@ async function run(root: string, projects: readonly ProjectMeta[]): Promise<Adop
       process.env['TURBO_ENV_MODE'] ?? '',
       ...configs,
       yarnrc,
-      // Its dependencies are global inputs, a member or not.
+      // Whether pnpm or npm runs a script's `pre` / `post` hooks (`runsScriptHooks`).
+      ...hookConfigs,
+      // Its dependencies are global inputs, a member or not; its `packageManager` names who runs hooks.
       rootManifest,
       JSON.stringify(microfrontendsConfigs(root, dirs)),
       // A config file added beside mapped tasks changes what an output may cover.

package/src/turbo/turbo-map.ts

@@ -13,9 +13,10 @@
 import path from 'node:path'
 import { isLiteralPattern, pruneOrphanPersistentNotes, UserError } from '@vzn/vx'
 import type { PackageMeta } from '../packages.js'
-import { literalGlob, minimatchToVx, withoutTakenBack } from '../glob-grammar.js'
+import { refuseTaskNames } from '../plugin-gaps.js'
+import { apartTakeBacks, literalGlob, minimatchToVx, withoutTakenBack } from '../glob-grammar.js'
 import { shellQuote } from '../nx-command.js'
-import { scriptCommand, yarnPnp } from '../script-command.js'
+import { type Owner, runsScriptHooks, scriptCommand, yarnPnp } from '../script-command.js'
 import {
   ownFileTakeBacks,
   excludeSiblingOutputs,
@@ -299,6 +300,14 @@ function covers(globs: readonly string[], rel: string): boolean {
   )
 }
 
+/**
+ * Turbo reads `**` glued to text as the deep glob: `**x` as `**\/*x`, `x**`
+ * as `x*\/**` (vercel/turborepo#5431). Core refuses the glued spelling, so
+ * copied verbatim it failed the load.
+ */
+const turboGlobstar = (glob: string): string =>
+  glob.replace(/\*\*([^*/]+)/g, '**/*$1').replace(/(?!^!)([^*/]+)\*\*/g, '$1*/**')
+
 /** No glob syntax: one path, which git may ignore. */
 const isLiteral = (glob: string): boolean => !/[*?[\]{}()!]/.test(glob)
 
@@ -768,6 +777,7 @@ export async function mapTurboWorkspace(
   }
   const rootCfg = withGlobal(await readTurboJson(rootFile, root))
   const pnp = yarnPnp(root)
+  const hookMemo = new Map<string, Owner>()
   const rootTasks = tasksOf(rootCfg)
 
   // Turbo 1 lists an env var as `$NAME` among `globalDependencies` (and a
@@ -820,7 +830,7 @@ export async function mapTurboWorkspace(
   // 1032).
   const rootMeta = metas.find((m) => path.resolve(m.dir) === path.resolve(root))
   const globalFiles = [
-    ...globalDeps.filter((d) => envDependency(d) === null),
+    ...globalDeps.filter((d) => envDependency(d) === null).map(turboGlobstar),
     ...(rootCfg.globalDotEnv ?? []),
     // Turbo 2 added the root's dependencies to its global hash; 1.13.4's
     // leaves them out (trigger.dev: a Prisma migration re-keyed only the
@@ -1165,7 +1175,10 @@ export async function mapTurboWorkspace(
     }
 
   const projects: TurboMappedProject[] = []
-  const literals = { tasks: [] as Literals[], globalIgnored }
+  // Turbo 2.11's `global.inputs` joins each task's own inputs, where its
+  // `!` entries reach them; `globalDependencies` is hashed apart.
+  const globalPrepended = new Set(rootCfg.global?.inputs ?? [])
+  const literals = { tasks: [] as Literals[], globalIgnored, globalPrepended }
   for (const meta of metas) {
     const scripts = packageScripts(meta)
     const own = runnable.get(meta.name)!
@@ -1277,7 +1290,16 @@ export async function mapTurboWorkspace(
         }
         continue
       }
-      const command = override ?? scriptCommand(name, script as string, scripts, pnp)
+      // Turbo runs `<pm> run <name>`: the hooks fold only where the manager runs them.
+      const command =
+        override ??
+        scriptCommand(
+          name,
+          script as string,
+          scripts,
+          pnp,
+          runsScriptHooks(meta.dir, hookMemo) !== null,
+        )
       const mapped = buildTask(
         literals,
         name,
@@ -1311,6 +1333,35 @@ export async function mapTurboWorkspace(
   // not, and a test cached on one platform hit on another. The reader
   // keys those files by a probe at the workspace root.
   const metaNamed = new Map(metas.map((m) => [m.name, m]))
+
+  // An entry group's `//#task` edge is the root's, and the root has no
+  // group of that name (it runs only `//#` tasks): left to `entryEdges`,
+  // `deploy → //#format` ran no format, where `turbo run deploy` runs it.
+  // The root gets the group, edges to its own tasks only, unless it
+  // declares the name itself.
+  const rootProject =
+    rootMeta === undefined || singlePackage
+      ? undefined
+      : projects.find((p) => p.name === rootMeta.name)
+  if (rootProject !== undefined) {
+    const rootRuns = emitted.get(rootProject.name)!
+    const groups = new Map<string, string[]>()
+    for (const id of entry) {
+      const at = id.indexOf('#')
+      const pkg = metaNamed.get(id.slice(0, at))
+      const name = id.slice(at + 1)
+      if (pkg === undefined || pkg === rootMeta || rootRuns.has(name)) continue
+      for (const d of definitions(pkg).defFor(name)?.dependsOn ?? []) {
+        const task = d.slice(ROOT.length + 1)
+        if (!d.startsWith(`${ROOT}#`) || !rootRuns.has(task)) continue
+        const edges = groups.get(name) ?? []
+        if (!edges.includes(task)) edges.push(task)
+        groups.set(name, edges)
+      }
+    }
+    for (const [name, dependsOn] of groups)
+      rootProject.tasks.push({ name, todos: [], task: { dependsOn }, uses: new Set() })
+  }
   for (const meta of metas) {
     const { defFor } = definitions(meta)
     for (const t of projects.find((p) => p.name === meta.name)?.tasks ?? []) {
@@ -1394,6 +1445,7 @@ export async function mapTurboWorkspace(
   excludeWorkspaceOutputs(root, projects, (e) => opaque.get(JSON.stringify(e)) ?? [])
   pruneUnreachedPersistentNotes(projects, metas, opts.persistentTodo)
   pruneOrphanPersistentNotes(projects, opts.persistentTodo)
+  refuseTaskNames(projects, 'task')
   return { projects, notes, globals }
 }
 
@@ -1620,7 +1672,11 @@ function keyOnlyGroup(t: TurboMappedTask): TurboMappedTask {
 }
 
 function buildTask(
-  literals: { readonly tasks: Literals[]; readonly globalIgnored: readonly string[] },
+  literals: {
+    readonly tasks: Literals[]
+    readonly globalIgnored: readonly string[]
+    readonly globalPrepended: ReadonlySet<string>
+  },
   name: string,
   def: TurboTask,
   command: string,
@@ -1836,9 +1892,9 @@ function buildTask(
   let pkgDotenvDeep = false
   // The root-relative `.env` globs, probed at the workspace root.
   const wsDotenv = [...rootDotenv]
-  // globalDependencies are workspace-root-relative by definition —
-  // they map to inputs.workspaceFiles, not project-relative files.
-  const wsFiles: unknown[] = [...global('inputs')]
+  // The task's own root-relative inputs; globalDependencies, root-relative
+  // by definition, join them in inputs.workspaceFiles.
+  const wsFiles: string[] = []
   // Root-relative path → the entry naming it.
   const rels = new Map<string, Named>(literals.globalIgnored.map((f) => [f, [null, f]]))
   const atRoot = pkgDir === '' || pkgDir === '.'
@@ -1848,7 +1904,7 @@ function buildTask(
     // in the package and an edit replayed a stale build (item 936).
     files.push('**/*')
   } else {
-    for (const i of def.inputs) {
+    for (const i of def.inputs.map(turboGlobstar)) {
       if (i === '$TURBO_DEFAULT$') {
         files.push('**/*')
         continue
@@ -1917,9 +1973,27 @@ function buildTask(
   // project's own globs at every member (D-39), so as `files` a root
   // `oxlint` over the repo replayed green after a member file broke.
   // A root task's globs are the workspace's, outputs too.
-  if (atRoot) wsFiles.unshift(...files.splice(0))
+  const head = atRoot ? files.splice(0) : []
+  const joined = (g: string) => literals.globalPrepended.has(g)
+  const [apartKept, ownKept] = apartTakeBacks<unknown>(
+    globals.inputs.filter((g) => !joined(g)),
+    [...globals.inputs.filter(joined), ...head, ...wsFiles],
+  )
+  const kept = new Set([...apartKept, ...ownKept])
+  const globalKept = globals.inputs.filter((g) => kept.has(g))
+  // A global exclusion dropped for this task cannot leave an opaque
+  // preset spread: the task lists the global values itself.
+  const inline = globalKept.length !== globals.inputs.length
+  const allWs = uniq(
+    [
+      ...head.filter((e) => typeof e !== 'string' || kept.has(e)),
+      ...(inline ? globalKept : global('inputs')),
+      ...wsFiles.filter((e) => kept.has(e)),
+    ],
+    inline ? [] : hidden('inputs'),
+  )
   const inputs: Record<string, unknown> = { files: withoutTakenBack(files) }
-  if (wsFiles.length > 0) inputs.workspaceFiles = withoutTakenBack(uniq(wsFiles, hidden('inputs')))
+  if (allWs.length > 0) inputs.workspaceFiles = withoutTakenBack(allWs)
   if (keyEnv.length > 0) inputs.env = keyEnv
   if (pkgDotenv) inputs.runtime = [pkgDotenvDeep ? DOTENV_PROBE : DOTENV_PROBE_TOP]
   if (wsDotenv.length > 0) inputs.workspaceRuntime = [dotenvGlobsProbe(wsDotenv) ?? DOTENV_PROBE]
@@ -1936,7 +2010,7 @@ function buildTask(
   for (const raw of def.outputs ?? []) {
     // Turbo's grammar: an extglob in `dist/**/*.@(js|mjs)` matched
     // nothing, so a hit restored nothing (item 1031).
-    const mapped = minimatchToVx(raw, raw.startsWith('!'))
+    const mapped = minimatchToVx(turboGlobstar(raw), raw.startsWith('!'))
     if (mapped === null) {
       todos.push(
         `output ${JSON.stringify(raw)}: glob syntax vx cannot take — task runs uncached; ` +
@@ -1970,7 +2044,7 @@ function buildTask(
   }
 
   // With git's file list known, a wildcard-first output stays cached as
-  // nx() keeps it (owner, 2026-10-03; turbo() 2026-10-14): core never
+  // nx() keeps it (2026-10-03; turbo() 2026-10-14): core never
   // cleans a committed file. Turbo never cleans, so the untracked files
   // it reaches are named. An X added for `X/**` is judged with it.
   const wild = wildcardOutput(
@@ -1991,7 +2065,7 @@ function buildTask(
       if (!covers(outFiles, rel)) outFiles.push(literalGlob(rel))
   // An output over the project's own package.json (trpc's builds list
   // it: tsdown rewrites `exports`) is taken back and keeps the cache, as
-  // nx() does (owner, 2026-10-03). The build rewrites an input the key
+  // nx() does (2026-10-03). The build rewrites an input the key
   // folds, so its identical rewrite counts as unchanged ('mutable').
   const takeBacks = ownFileTakeBacks(outFiles, opts.ownConfig?.(pkgDir))
   outFiles.push(...takeBacks)