@vzn/vx-migrate 0.0.645 → 0.0.648

package/src/adopt.ts

@@ -2,7 +2,7 @@
 // which kind of adoption (native configs, or the runner's config read live),
 // and installing vx with the repo's own package manager (solidjs/solid,
 // 2026-10-04: the configs were written with no vx installed to run them).
-// The repo's own scripts are never edited (owner, 2026-10-06).
+// The repo's own scripts are never edited (2026-10-06).
 
 import { existsSync, readFileSync } from 'node:fs'
 import path from 'node:path'
@@ -63,6 +63,32 @@ export function packageManagerOf(root: string, userAgent?: string): PackageManag
   )
 }
 
+/**
+ * pnpm's `-w` where pnpm-workspace.yaml makes `root` a workspace: pnpm
+ * refuses it in a single-package repo ("--workspace-root may only be used
+ * inside a workspace").
+ */
+function pnpmRoot(root: string): string[] {
+  return existsSync(path.join(root, 'pnpm-workspace.yaml')) ? ['-w'] : []
+}
+
+/**
+ * Yarn 2+: its lockfile carries `__metadata`, and before the first install
+ * there is none, so `packageManager` names it (`-W` was refused there).
+ */
+function berry(root: string): boolean {
+  const lock = readText(path.join(root, 'yarn.lock'))
+  if (lock !== '') return lock.includes('__metadata:')
+  try {
+    const pm = (
+      JSON.parse(readText(path.join(root, 'package.json')) || '{}') as { packageManager?: unknown }
+    ).packageManager
+    return typeof pm === 'string' && /^yarn@([2-9]|\d{2,})/.test(pm)
+  } catch {
+    return false
+  }
+}
+
 /** argv that adds `packages` as root dev dependencies. */
 export function installArgv(
   root: string,
@@ -71,11 +97,11 @@ export function installArgv(
 ): string[] {
   switch (pm) {
     case 'pnpm':
-      return ['pnpm', 'add', '-D', '-w', ...packages]
+      return ['pnpm', 'add', '-D', ...pnpmRoot(root), ...packages]
     case 'yarn':
       // Yarn 1 refuses `add` at a workspace root without `-W`; Berry has no
-      // such flag. A Berry lockfile carries `__metadata`.
-      return readText(path.join(root, 'yarn.lock')).includes('__metadata:')
+      // such flag.
+      return berry(root)
         ? ['yarn', 'add', '-D', ...packages]
         : ['yarn', 'add', '-D', '-W', ...packages]
     case 'bun':
@@ -104,7 +130,7 @@ export function ownVersion(): string | null {
  * (at `version`, given one). Either alone is not adopted: a reset
  * package.json leaves node_modules behind, and a listing is not an
  * install; on solidjs/solid vx-migrate 0.0.512 skipped @vzn/vx that
- * package.json did not list (owner, 2026-10-06).
+ * package.json did not list (2026-10-06).
  */
 export function missingPackages(
   root: string,
@@ -129,11 +155,9 @@ export function removeArgv(
 ): string[] {
   switch (pm) {
     case 'pnpm':
-      return ['pnpm', 'remove', '-w', ...packages]
+      return ['pnpm', 'remove', ...pnpmRoot(root), ...packages]
     case 'yarn':
-      return readText(path.join(root, 'yarn.lock')).includes('__metadata:')
-        ? ['yarn', 'remove', ...packages]
-        : ['yarn', 'remove', '-W', ...packages]
+      return berry(root) ? ['yarn', 'remove', ...packages] : ['yarn', 'remove', '-W', ...packages]
     case 'bun':
       return ['bun', 'remove', ...packages]
     case 'npm':
@@ -156,7 +180,7 @@ export function listedPackages(root: string, packages: readonly string[]): strin
  * The `@vzn/vx-*` plugins the root lists from the registry (a `workspace:`
  * or `file:` link is the repo's own; a platform binary comes with core).
  * Every @vzn package releases together: an install moves them with core,
- * as `vx upgrade` does (M, 2026-10-16: "always install latest and upgrade all").
+ * as `vx upgrade` does (2026-10-16: "always install latest and upgrade all").
  */
 export function listedPlugins(root: string): string[] {
   const pj = JSON.parse(readText(path.join(root, 'package.json')) || '{}') as Record<
@@ -179,7 +203,7 @@ export function listedPlugins(root: string): string[] {
  * The `@vzn/vx*` packages a workspace file imports, parsed, not matched (a
  * formatter's quotes hid a match). Each is installed with core: a file an
  * earlier init wrote imports @vzn/vx-lockfile that package.json need not
- * list, and the lock could not find it (M, 2026-10-16).
+ * list, and the lock could not find it (2026-10-16).
  */
 export function importedPackages(text: string): string[] {
   const out = new Set<string>()
@@ -279,9 +303,26 @@ async function runManager(
   if (live) process.stdout.write('\r\x1b[2K\x1b[1A')
   if (code !== 0) {
     process.stderr.write(said)
+    const missing = notServed(said)
     throw new UserError(
-      `${what} failed (${line} exited ${code}${failed}); run it, then vx-migrate again${code > 0 ? ranHint : ''}`,
+      missing === undefined
+        ? `${what} failed (${line} exited ${code}${failed}); run it, then vx lock${code > 0 ? ranHint : ''}`
+        : `${what} failed: the npm registry does not serve ${missing} yet (404), as a release can take minutes to reach it; run vx init again`,
     )
   }
   return line
 }
+
+/**
+ * The package a manager's output says the registry answered 404 for, as
+ * `name@version` (core's `vx init` reads its installs the same way): a
+ * release's platform tarball stays unserved for minutes after publish.
+ */
+export function notServed(output: string): string | undefined {
+  for (const line of output.split('\n')) {
+    if (!line.includes('404')) continue
+    const m = /https?:\/\/\S+?\/((?:@[^/\s]+\/)?[^/\s]+)\/-\/[^/\s]+?-(\d[^/\s]*?)\.tgz/.exec(line)
+    if (m !== null) return `${decodeURIComponent(m[1]!)}@${m[2]}`
+  }
+  return undefined
+}

package/src/adoption-plugin.ts

@@ -6,7 +6,7 @@
 // skeleton until item 592; what differs is only how the mapping is made.
 
 import { definePlugin, type ProjectHookContext, type VxPlugin } from '@vzn/vx'
-import { type AdoptionMapping, cachedMapping } from './mapping-cache.js'
+import { type AdoptionMapping, cachedMapping, codeId } from './mapping-cache.js'
 import { warnGaps } from './plugin-gaps.js'
 import { headStamp, spareTrackedOutputs, trackedFiles } from './tracked-outputs.js'
 
@@ -76,18 +76,16 @@ export function adoptionPlugin(
     async project(config, ctx) {
       if (mappedFor !== ctx.projects) {
         mappedFor = ctx.projects
+        // The key's other reads overlap the plugin's own.
+        void codeId()
+        const stamp = headStamp(ctx.workspaceRoot)
         mapping = mapRun(ctx).then(async (r) =>
           r.spareTracked === true
-            ? cachedMapping(
-                ctx.cacheDir,
-                r.name,
-                [...r.reads, await headStamp(ctx.workspaceRoot)],
-                async () => {
-                  let read: Promise<readonly string[] | null> | undefined
-                  const tracked = () => (read ??= trackedFiles(ctx.workspaceRoot))
-                  return spare(ctx, await r.map(tracked), await tracked())
-                },
-              )
+            ? cachedMapping(ctx.cacheDir, r.name, [...r.reads, await stamp], async () => {
+                let read: Promise<readonly string[] | null> | undefined
+                const tracked = () => (read ??= trackedFiles(ctx.workspaceRoot))
+                return spare(ctx, await r.map(tracked), await tracked())
+              })
             : cachedMapping(ctx.cacheDir, r.name, r.reads, () =>
                 r.map(() => trackedFiles(ctx.workspaceRoot)),
               ),

package/src/bin.ts

@@ -10,6 +10,7 @@
 // 2026-10-16).
 
 import path from 'node:path'
+import * as core from '@vzn/vx'
 import { isUserError, UserError, VERSION } from '@vzn/vx'
 import { ownVersion } from './adopt.js'
 
@@ -26,8 +27,27 @@ try {
   const { migrateCmd } = await import('./migrate.js')
   process.exitCode = await migrateCmd(process.argv.slice(2))
 } catch (err) {
+  // Asked for JSON (`vx init --dry --format json` hands a Turbo or Nx repo
+  // here), a refusal is core's error document on stdout too
+  // (schemas/error.json): stdout was empty.
+  const args = process.argv.slice(2)
+  if (args.some((a, i) => a === '--format=json' || (a === '--format' && args[i + 1] === 'json'))) {
+    const message = err instanceof Error ? err.message : String(err)
+    const own = isUserError(err) ? (err as { code?: unknown }).code : 'VX_E_INTERNAL'
+    const code = typeof own === 'string' ? own : 'VX_E_REFUSED'
+    const docs = code.startsWith('VX_E_')
+      ? { docs: `https://vznjs.github.io/vx/cli/#${code.toLowerCase()}` }
+      : {}
+    process.stdout.write(
+      `${JSON.stringify({ ok: false, error: { code, message: `vx-migrate: ${message}`, ...docs } })}\n`,
+    )
+  }
   if (isUserError(err)) {
-    process.stderr.write(`vx-migrate: ${err.message}\n`)
+    // `ui` by namespace: a core older than it has none, and its refusal
+    // still reaches the reader.
+    const ui = (core as Partial<typeof core>).ui
+    if (ui === undefined) process.stderr.write(`vx-migrate: ${err.message}\n`)
+    else ui.say('error', `vx-migrate: ${err.message}`)
     process.exitCode = 1
   } else {
     throw err

package/src/glob-grammar.ts

@@ -27,6 +27,51 @@ export function minimatchToVx(glob: string, negated: boolean): string | null {
   return out.includes('\0') || /[?@+*!]\(/.test(out) ? null : out
 }
 
+// A group no extglob kind opens and no backslash escapes.
+const BARE_GROUP = /(?<![\\?@+*!])\(([^()]*)\)/g
+
+/**
+ * An Nx glob's bare groups in vx's grammar, or null when one has no safe
+ * form. Nx's native glob reads `(a|b)` as `{a,b}` and `(a)` as `a`, so
+ * `dist/*.(js|map)` is the two extensions there; vx and minimatch read the
+ * parentheses as literal text, and the glob matched nothing. Turbo's
+ * grammar has no such group, so this is the Nx adapter's alone.
+ */
+export function nxBareGroups(glob: string): string | null {
+  if (!glob.includes('(')) return glob
+  let unsafe = false
+  const out = glob.replace(BARE_GROUP, (_whole, body: string) => {
+    const alts = body.split('|')
+    if (alts.some((a) => /[{},]/.test(a))) unsafe = true
+    return alts.length === 1 ? alts[0]! : `{${alts.join(',')}}`
+  })
+  return unsafe ? null : out
+}
+
+/** A segment (or brace arm) holding `**` and other text: `**.ts`, `a**`. */
+const glued = (seg: string): boolean => seg.includes('**') && /[^*]/.test(seg)
+
+/** Does `glob` glue `**` to other text, which core refuses? */
+export const hasGluedGlobstar = (glob: string): boolean =>
+  glob
+    .replace(/^!/, '')
+    .split(/[/{},]/)
+    .some(glued)
+
+/**
+ * A glued `**` as minimatch and Nx's matcher (globset, literal separator)
+ * read it: `*`, one level.
+ */
+export function gluedGlobstarAsStar(glob: string): string {
+  const neg = glob.startsWith('!') ? '!' : ''
+  return (
+    neg +
+    glob
+      .slice(neg.length)
+      .replace(/[^/{},]+/g, (seg) => (glued(seg) ? seg.replace(/\*{2,}/g, '*') : seg))
+  )
+}
+
 /**
  * `list` without a literal that one of its `!` entries takes back, and
  * without a repeat. Turbo, Nx and vx all subtract an exclusion wherever it
@@ -53,6 +98,43 @@ export function withoutTakenBack<T>(entries: readonly T[]): T[] {
   })
 }
 
+/**
+ * Could a path match both globs? False only when, before either reaches a
+ * wildcard, a segment of one differs from the other's; a literal also
+ * matches its directory's files, as a `!` entry takes them back.
+ */
+function mayOverlap(a: string, b: string): boolean {
+  const wild = /[*?{}[\]\\]/
+  const sa = a.replace(/^\.\//, '').split('/')
+  const sb = b.replace(/^\.\//, '').split('/')
+  for (let i = 0; i < Math.min(sa.length, sb.length); i++) {
+    if (wild.test(sa[i]!) || wild.test(sb[i]!)) return true
+    if (sa[i] !== sb[i]) return false
+  }
+  return true
+}
+
+/**
+ * Two lists core reads as one, each with its own `!` entries: Turbo
+ * subtracts a task's exclusions from the task's own inputs only, and a
+ * `globalDependencies` exclusion from the global hash only. One list in
+ * vx subtracts every `!` from every entry, so each list loses an exclusion
+ * that may reach a positive entry of the other: it keys more files (a
+ * missed hit), where kept it keyed fewer (a stale one).
+ */
+export function apartTakeBacks<T>(a: readonly T[], b: readonly T[]): [T[], T[]] {
+  const positives = (l: readonly T[]) =>
+    l.flatMap((e) => (typeof e === 'string' && !e.startsWith('!') ? [e] : []))
+  const keep = (l: readonly T[], other: readonly string[]) =>
+    l.filter(
+      (e) =>
+        typeof e !== 'string' ||
+        !e.startsWith('!') ||
+        !other.some((p) => mayOverlap(e.slice(1), p)),
+    )
+  return [keep(a, positives(b)), keep(b, positives(a))]
+}
+
 /**
  * A path from the file system as a task glob that names only itself: a dir
  * named `my{app}` read as a brace matched `myapp` instead, and `app/[id]` a

package/src/index.ts

@@ -2,14 +2,40 @@
 // runs unchanged) and the two remote caches speaking Turbo's and Nx's
 // wire. The CLI (`bunx @vzn/vx-migrate`) is `migrate.ts`; mappers and
 // cache clients are internal (1.0 freezes what this file exports).
-export { turbo, type TurboPluginOptions } from './turbo/index.js'
-export {
-  nx,
-  type NxExecutors,
-  type NxExecutorTarget,
-  type NxExecutorTranslation,
-  type NxExecutorTranslator,
-  type NxPluginOptions,
+//
+// Each factory loads its module on first call: a workspace evaluates this
+// file on every run, and a Turbo repo paid ~4 ms per run transpiling nx()
+// and both cache clients it never calls (solid, 2026-10-22).
+import type { VxPlugin } from '@vzn/vx'
+import type * as Turbo from './turbo/index.js'
+import type { TurboPluginOptions } from './turbo/index.js'
+import type { NxPluginOptions } from './nx/index.js'
+import type { TurboCacheOptions } from './turbo-cache/index.js'
+import type { NxCacheOptions } from './nx-cache/index.js'
+import type * as Nx from './nx/index.js'
+import type * as TurboCache from './turbo-cache/index.js'
+import type * as NxCache from './nx-cache/index.js'
+
+export type { TurboPluginOptions } from './turbo/index.js'
+export type {
+  NxExecutors,
+  NxExecutorTarget,
+  NxExecutorTranslation,
+  NxExecutorTranslator,
+  NxPluginOptions,
 } from './nx/index.js'
-export { turboCache, type TurboCacheOptions } from './turbo-cache/index.js'
-export { nxCache, type NxCacheOptions } from './nx-cache/index.js'
+export type { TurboCacheOptions } from './turbo-cache/index.js'
+export type { NxCacheOptions } from './nx-cache/index.js'
+
+export function turbo(options: TurboPluginOptions = {}): VxPlugin {
+  return (require('./turbo/index.js') as typeof Turbo).turbo(options)
+}
+export function nx(options: NxPluginOptions = {}): VxPlugin {
+  return (require('./nx/index.js') as typeof Nx).nx(options)
+}
+export function turboCache(options: TurboCacheOptions = {}): VxPlugin {
+  return (require('./turbo-cache/index.js') as typeof TurboCache).turboCache(options)
+}
+export function nxCache(options: NxCacheOptions = {}): VxPlugin {
+  return (require('./nx-cache/index.js') as typeof NxCache).nxCache(options)
+}

package/src/mapping-cache.ts

@@ -8,6 +8,7 @@
 // package's sources and the core helpers the mappers call: a new
 // `@vzn/vx-migrate` or `@vzn/vx` maps afresh.
 
+import { statSync } from 'node:fs'
 import { mkdir, rename } from 'node:fs/promises'
 import path from 'node:path'
 import { foldScriptHooks, isLiteralPattern, outputsOverlap, VERSION } from '@vzn/vx'
@@ -30,8 +31,8 @@ export interface AdoptionMapping {
 
 let code: Promise<string> | undefined
 
-/** This package's sources and the core helpers the mappers call, hashed once per process. */
-function codeId(): Promise<string> {
+/** This package's sources (by size and mtime) and the core helpers the mappers call, once per process. */
+export function codeId(): Promise<string> {
   code ??= (async () => {
     const parts: string[] = [
       VERSION,
@@ -40,7 +41,13 @@ function codeId(): Promise<string> {
     const files: string[] = []
     for await (const f of new Bun.Glob('**/*.{ts,cjs}').scan(import.meta.dir)) files.push(f)
     files.sort()
-    for (const f of files) parts.push(f, await Bun.file(path.join(import.meta.dir, f)).text())
+    // Size and mtime, not bytes: reading the 650 kB of sources cost ~10 ms
+    // on every run, more than the mapping hit it guards saves on a small
+    // repo (solid, 2026-10-22). An edit moves both.
+    for (const f of files) {
+      const s = statSync(path.join(import.meta.dir, f))
+      parts.push(f, `${s.size}:${s.mtimeMs}`)
+    }
     return hex(parts.join('\0'))
   })()
   return code
@@ -71,11 +78,12 @@ export async function cachedMapping(
   parts: readonly string[],
   map: () => Promise<AdoptionMapping>,
 ): Promise<AdoptionMapping> {
-  const key = hex([await codeId(), ...parts].join('\0'))
   const file = path.join(cacheDir, `vx-migrate-${name}-mapping.json`)
-  const held = (await Bun.file(file)
+  const reading = Bun.file(file)
     .json()
-    .catch(() => null)) as Held | null
+    .catch(() => null) as Promise<Held | null>
+  const key = hex([await codeId(), ...parts].join('\0'))
+  const held = await reading
   if (held?.key === key) {
     return {
       byName: new Map(held.byName),

package/src/migrate-nx.ts

@@ -3,7 +3,12 @@
 
 import { stat } from 'node:fs/promises'
 import path from 'node:path'
-import { type GeneratedProject, type MigrationFormat, type MigrationPlan } from '@vzn/vx'
+import {
+  type GeneratedProject,
+  type MigrationFormat,
+  type MigrationPlan,
+  quoteTsLiteral,
+} from '@vzn/vx'
 import type { PackageMeta } from './packages.js'
 import { mapNxWorkspace, parseNxGraph, readNxJson } from './nx/nx-map.js'
 import { spareTrackedOutputs, trackedFiles, trackedKinds } from './tracked-outputs.js'
@@ -172,8 +177,6 @@ export interface NxWorkspaceField {
   readonly note: string
 }
 
-const quoted = (s: string) => `'${s.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`
-
 /**
  * nx.json's run-wide settings `nx()` applies live: each a field of the
  * written `.vx/workspace.ts`, or a migrated repo that ran one task at a time
@@ -202,7 +205,7 @@ export function nxWorkspaceFields(json: Record<string, unknown> | undefined): Nx
     const branch = base.trim().replace(/^origin\//, '')
     out.push({
       field: 'baseBranch',
-      source: quoted(branch),
+      source: quoteTsLiteral(branch),
       note: `nx.json \`defaultBase\` ${JSON.stringify(base.trim())}: add \`baseBranch: ${JSON.stringify(branch)}\` to .vx/workspace.ts`,
     })
   }

package/src/migrate-scripts.ts

@@ -39,6 +39,7 @@ import {
 } from '@vzn/vx'
 import type { PackageMeta } from './packages.js'
 import { relPosix } from './paths.js'
+import { type Owner, ownerOf, runsScriptHooks } from './script-command.js'
 
 /**
  * Task names that conventionally never exit. Every mapper guesses the same
@@ -128,19 +129,24 @@ const LIFECYCLE = /^(pre|post)(install|publish|pack|version)$|^(prepare|prepubli
 /**
  * The script a command delegates to when it is NOTHING but a package-manager
  * invocation of another script: `npm run x`, `pnpm x`, `yarn run x`, `bun run
- * x`, plus npm's bare `npm test` / `npm start`. Flags, arguments or a chain
- * make it a real command again, which is left verbatim.
+ * x`, plus npm's bare `npm test` / `npm start` / `npm stop`. npm's aliases
+ * (`run-script`, `rum`, `urn`; `t`, `tst`) and pnpm's (`run-script`; `t`,
+ * `tst`) are the same commands: read verbatim, `npm run-script build` built
+ * again beside the `build` task. Flags, arguments or a chain make it a real
+ * command again, which is left verbatim.
  */
 export function delegatedScript(command: string): string | null {
   const m =
-    /^(?:(?:npm run|(pnpm|pn|yarn|bun)(?: (run))?) ([^\s&|;<>()$`'"\\]+)|npm (test|start))$/.exec(
+    /^(?:(?:npm (?:run|run-script|rum|urn)|(pnpm|pn|yarn|bun)(?: (run|run-script))?) ([^\s&|;<>()$`'"\\]+)|npm (test|t|tst|start|stop))$/.exec(
       command.trim(),
     )
   if (m === null) return null
-  if (m[4] !== undefined) return m[4]
+  if (m[4] !== undefined) return m[4] === 't' || m[4] === 'tst' ? 'test' : m[4]
   const [, alias, run, name] = m
   // `pn` is pnpm's own short name (pnpm 11; pnpm/pnpm's scripts run it).
   const manager = alias === 'pn' ? 'pnpm' : alias
+  if (run === 'run-script' && manager !== 'pnpm') return null
+  if (manager === 'pnpm' && run === undefined && (name === 't' || name === 'tst')) return 'test'
   // Bare, the manager's own command wins over a script of that name:
   // `bun test` is Bun's test runner and `bun build` its bundler, never the
   // `test` / `build` script, and a group over the script ran the wrong
@@ -177,104 +183,6 @@ const OWN_COMMANDS: Readonly<Record<string, ReadonlySet<string>>> = {
   ),
 }
 
-/**
- * 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.
- */
-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. */
-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.
- */
-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
-}
-
 /**
  * Yarn 2+ runs a script in its own shell, where `run <script>` is `yarn
  * run <script>`; vx's shell has no `run`, and 23 of berry's scripts

package/src/migrate-turbo.ts

@@ -12,12 +12,8 @@ import {
   quoteTsLiteral as quote,
 } from '@vzn/vx'
 import type { PackageMeta } from './packages.js'
-import {
-  mapTurboWorkspace,
-  rootTaskProject,
-  type TurboGlobal,
-  type TurboMappedProject,
-} from './turbo/turbo-map.js'
+import { mapTurboWorkspace, type TurboGlobal, type TurboMappedProject } from './turbo/turbo-map.js'
+import { rootTaskProject } from './turbo/turbo-reads.js'
 import { relPosix } from './paths.js'
 import { gitIgnored, spareTrackedOutputs, trackedFiles, trackedKinds } from './tracked-outputs.js'
 import { DOTENV_GLOBS_HEAD, DOTENV_PROBE, DOTENV_PROBE_TOP } from './dotenv-probe.js'