@vzn/vx-migrate 0.0.644 → 0.0.646

package/src/shared-outputs.ts

@@ -192,18 +192,24 @@ function cachedOutputs(t: GeneratedTask, index: number): Cached | null {
 }
 
 /**
- * Can the keeper's `ga` give `gb`'s tree back? Only when `ga` is a
- * directory at any depth (`**\/dist`, `**\/dist/**`) and `gb`'s literal
- * head names no such directory: the two meet only at a `dist` nested in
- * `gb`'s tree, which is the sibling's. solid's build outputs `**\/dist`
- * beside types' `types/**`; Turbo caches both, and uncaching types made
- * vx the slower of the two.
+ * Can the keeper's `ga` give `gb`'s tree back? Only when one of the two is
+ * a directory at any depth (`**\/dist`, `**\/dist/**`) and the other's
+ * literal head names no such directory: they meet only where one tree
+ * nests in the other, which neither task writes. solid's build outputs
+ * `dist/**` and `**\/dist` beside types' `types/**` and `**\/types`; Turbo
+ * caches both, and uncaching types made vx the slower of the two.
  */
-function separable(ga: string, gb: string): boolean {
-  const name = /^\*\*\/([^*?[\]{}()!/\\]+)(?:\/\*\*)?$/.exec(ga)?.[1]
+const DIR_ANYWHERE = /^\*\*\/([^*?[\]{}()!/\\]+)(?:\/\*\*)?$/
+
+const separable = (ga: string, gb: string): boolean => apart(ga, gb) || apart(gb, ga)
+
+function apart(dir: string, other: string): boolean {
+  const name = DIR_ANYWHERE.exec(dir)?.[1]
   if (name === undefined) return false
+  const otherName = DIR_ANYWHERE.exec(other)?.[1]
+  if (otherName !== undefined) return otherName !== name
   const head: string[] = []
-  for (const seg of gb.replace(/^(\.\/)+/, '').split('/')) {
+  for (const seg of other.replace(/^(\.\/)+/, '').split('/')) {
     if (!isLiteralPattern(seg) || seg === '') break
     head.push(seg)
   }
@@ -348,7 +354,7 @@ function prefixIndex(): {
 }
 
 /**
- * A keyed group (`cache`, no `exec`: the `nx-input:<name>` twins, Turbo's
+ * A keyed group (`cache`, no `exec`: the `inputs:<name>` twins, Turbo's
  * transit nodes) runs nothing, so core lets its key read what a task
  * writes (`detectInputOverlaps` exempts it). Uncaching one left `{}`, a
  * task core refuses, and every verb failed.

package/src/tracked-outputs.ts

@@ -11,7 +11,7 @@ import { lstat, readFile } from 'node:fs/promises'
 import path from 'node:path'
 import { isLiteralPattern, outputsOverlap } from '@vzn/vx'
 import { relPosix } from './paths.js'
-import { isKeyedGroup, unkey } from './shared-outputs.js'
+import type * as SharedOutputs from './shared-outputs.js'
 
 /** The files git tracks under `root`, root-relative; null outside a repo or without git. */
 export async function trackedFiles(root: string): Promise<string[] | null> {
@@ -135,11 +135,13 @@ export async function headStamp(root: string): Promise<string> {
         const m = /^gitdir: (.*)$/m.exec(await readFile(dotGit, 'utf8').catch(() => ''))
         if (m !== null) gitDir = path.resolve(dir, m[1]!.trim())
       }
-      const head = await readFile(path.join(gitDir, 'HEAD'), 'utf8').catch(() => '')
-      const log = await lstat(path.join(gitDir, 'logs', 'HEAD')).catch(() => null)
-      const index = await lstat(path.join(gitDir, 'index')).catch(() => null)
-      // A worktree's own stack holds its HEAD; the common one, its branches.
-      const common = await readFile(path.join(gitDir, 'commondir'), 'utf8').catch(() => null)
+      const [head, log, index, common] = await Promise.all([
+        readFile(path.join(gitDir, 'HEAD'), 'utf8').catch(() => ''),
+        lstat(path.join(gitDir, 'logs', 'HEAD')).catch(() => null),
+        lstat(path.join(gitDir, 'index')).catch(() => null),
+        // A worktree's own stack holds its HEAD; the common one, its branches.
+        readFile(path.join(gitDir, 'commondir'), 'utf8').catch(() => null),
+      ])
       const tables = await Promise.all(
         [gitDir, ...(common === null ? [] : [path.resolve(gitDir, common.trim())])].map((d) =>
           readFile(path.join(d, 'reftable', 'tables.list'), 'utf8').catch(() => ''),
@@ -236,6 +238,8 @@ export function spareTrackedOutputs(
   }[],
   tracked: readonly string[],
 ): [string, string][] {
+  // Loaded here, on a remap only: a kept mapping's run never reads it.
+  const { isKeyedGroup, unkey } = require('./shared-outputs.js') as typeof SharedOutputs
   const todos: [string, string][] = []
   const trackedSet = new Set(tracked)
   /** Drop the `!` entries readers carry for a committed file no output names any more. */

package/src/turbo/index.ts

@@ -21,14 +21,14 @@ import { collectGaps } from '../plugin-gaps.js'
 import { gitIgnored, trackedKinds } from '../tracked-outputs.js'
 import { packageScripts, relPosix } from '../paths.js'
 import { onceReader, type ReadText, tscBuildInfo } from '../tsc-buildinfo.js'
+import type * as TurboMap from './turbo-map.js'
+import type { TurboMappedProject } from './turbo-map.js'
 import {
   envNamesThatMap,
-  mapTurboWorkspace,
   microfrontendsConfigs,
   rootTaskProject,
   turboConfigFile,
-  type TurboMappedProject,
-} from './turbo-map.js'
+} from './turbo-reads.js'
 
 /** The note every persistent task carries; like every gap, reported once per run for all its tasks. */
 const PERSISTENT_NOTE =
@@ -192,11 +192,15 @@ const textOf = (file: string): Promise<string> =>
  * `.yarnrc.yml` and the microfrontends configs.
  */
 async function run(root: string, projects: readonly ProjectMeta[]): Promise<AdoptionRun> {
-  const metas = await withManifests(projects)
-  const dirs = [root, ...metas.map((m) => m.dir)]
-  const configs = await Promise.all(
-    dirs.flatMap((d) => ['turbo.json', 'turbo.jsonc'].map((f) => textOf(path.join(d, f)))),
-  )
+  const dirs = [root, ...projects.map((m) => m.dir)]
+  const [metas, configs, yarnrc, rootManifest] = 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')),
+  ])
   const envNames = envNamesThatMap(configs, envNamesNow())
   // The tsconfigs a `tsc` script reads are the mapping's inputs too.
   const tsc = onceReader()
@@ -213,9 +217,9 @@ async function run(root: string, projects: readonly ProjectMeta[]): Promise<Adop
       process.env['TURBO_CI_VENDOR_ENV_KEY'] ?? '',
       process.env['TURBO_ENV_MODE'] ?? '',
       ...configs,
-      await textOf(path.join(root, '.yarnrc.yml')),
+      yarnrc,
       // Its dependencies are global inputs, a member or not.
-      await textOf(path.join(root, 'package.json')),
+      rootManifest,
       JSON.stringify(microfrontendsConfigs(root, dirs)),
       // 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])),
@@ -244,6 +248,8 @@ async function mapAll(
       m.configPath === null ? [] : [[relPosix(root, m.dir), path.basename(m.configPath)] as const],
     ),
   )
+  // Only a mapping the kept one no longer holds loads the mapper.
+  const { mapTurboWorkspace } = require('./turbo-map.js') as typeof TurboMap
   const mapped = await mapTurboWorkspace(root, metas, {
     // Inline: the values themselves, where `bunx @vzn/vx-migrate` splices a preset import.
     splice: (_kind, values) => values,

package/src/turbo/turbo-map.ts

@@ -10,7 +10,6 @@
 //     written.
 // The consumer decides what a global becomes through `splice`.
 
-import { existsSync, readFileSync } from 'node:fs'
 import path from 'node:path'
 import { isLiteralPattern, pruneOrphanPersistentNotes, UserError } from '@vzn/vx'
 import type { PackageMeta } from '../packages.js'
@@ -31,6 +30,13 @@ import {
 } from '../shared-outputs.js'
 import { manifestGraph, type ManifestGraph } from '../manifest-graph.js'
 import { isRecord, packageScripts, relPosix } from '../paths.js'
+import {
+  FRAMEWORK_ENV,
+  keyable,
+  microfrontendsConfigs,
+  ROOT,
+  turboConfigFile,
+} from './turbo-reads.js'
 import type { TrackedKinds } from '../tracked-outputs.js'
 import {
   DOTENV_PROBE,
@@ -69,34 +75,6 @@ interface TurboJson {
 
 const SHELL_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/
 
-/** A name core takes in `inputs.env` and `exec.env.passThrough`. */
-const keyable = (name: string): boolean =>
-  name.length > 0 && !name.startsWith('!') && !/[*?[\]{}=\0]/.test(name)
-
-/**
- * The names of `names` a live mapping can read differently: each a `*` in
- * one of `configs` (turbo.json texts, any string, a superset) or in Turbo's
- * framework table matches, and each core cannot key (a literal one is
- * dropped only when no variable has it). The kept mapping keyed on every
- * name, so any variable that came or went (a CI step's, `VX_DEBUG_TIMING`)
- * remapped the workspace: ~330 ms a run on vercel/ai.
- */
-export function envNamesThatMap(configs: readonly string[], names: readonly string[]): string[] {
-  const patterns = new Set(FRAMEWORK_ENV.flatMap((f) => f.env).filter((e) => e.includes('*')))
-  for (const text of configs)
-    for (const m of text.matchAll(/"((?:[^"\\]|\\.)*)"/g))
-      if (m[1]!.includes('*')) patterns.add(m[1]!)
-  // Backslashes and a leading `!` dropped, every `*` a wildcard: wider
-  // than Turbo's reading, never narrower.
-  const res = [...patterns].map(
-    (p) =>
-      new RegExp(
-        `^${p.replaceAll('\\', '').replace(/^!/, '').split('*').map(RegExp.escape).join('.*')}$`,
-      ),
-  )
-  return names.filter((n) => !keyable(n) || res.some((re) => re.test(n)))
-}
-
 /**
  * A Turbo env list's explicit names, read as Turbo reads them
  * (`wildcard_to_regex_pattern`): `*` is the one wildcard, `\*` a
@@ -195,83 +173,6 @@ const KNOWN_TASK_KEYS = new Set([
 const OUTPUT_LOGS_DEFAULT = 'new-only'
 const OUTPUT_LOGS_RUN_FLAG = new Set(['full', 'hash-only', 'errors-only', 'none'])
 
-// Turbo 2's framework inference: a package that depends on a framework
-// has its variables hashed into its tasks and passed to them, with
-// nothing in turbo.json saying so. vx env names are explicit, so the
-// variables were stripped in silence and a build that inlines them
-// (Next's `NEXT_PUBLIC_*`) read empty values (item 940). A live mapping
-// (`envNames`) infers them as Turbo does; the migrate CLI lists the names
-// the package's own files spell (`sourceNames`) and says so in a note.
-// Turbo's own table (`packages/turbo-types/src/json/frameworks.json`),
-// in its order: a package takes the FIRST framework it matches, `all`
-// needing every dependency and `some` any one.
-const NITRO_ENV = [
-  'NITRO_*',
-  'SERVER_*',
-  'AWS_APP_ID',
-  'INPUT_AZURE_STATIC_WEB_APPS_API_TOKEN',
-  'CLEAVR',
-  'CF_PAGES',
-  'FIREBASE_APP_HOSTING',
-  'NETLIFY',
-  'STORMKIT',
-  'NOW_BUILDER',
-  'ZEABUR',
-  'RENDER',
-]
-const FRAMEWORK_ENV: ReadonlyArray<{
-  slug: string
-  env: readonly string[]
-  all: boolean
-  dependencies: readonly string[]
-}> = [
-  { slug: 'astro', env: ['PUBLIC_*'], all: true, dependencies: ['astro'] },
-  { slug: 'blitzjs', env: ['NEXT_PUBLIC_*'], all: true, dependencies: ['blitz'] },
-  {
-    slug: 'create-react-app',
-    env: ['REACT_APP_*'],
-    all: false,
-    dependencies: ['react-scripts', 'react-dev-utils'],
-  },
-  { slug: 'expo', env: ['EXPO_PUBLIC_*'], all: true, dependencies: ['expo'] },
-  { slug: 'gatsby', env: ['GATSBY_*'], all: true, dependencies: ['gatsby'] },
-  {
-    slug: 'nextjs',
-    env: ['NEXT_PUBLIC_*', 'NEXT_DEPLOYMENT_ID'],
-    all: true,
-    dependencies: ['next'],
-  },
-  {
-    slug: 'nitro',
-    env: NITRO_ENV,
-    all: false,
-    dependencies: ['nitropack', 'nitropack-nightly', 'nitro', 'nitro-nightly'],
-  },
-  {
-    slug: 'nuxtjs',
-    env: ['NUXT_*', 'NUXT_ENV_*', ...NITRO_ENV, 'LAUNCH_EDITOR'],
-    all: false,
-    dependencies: ['nuxt', 'nuxt-edge', 'nuxt3', 'nuxt3-edge'],
-  },
-  { slug: 'redwoodjs', env: ['REDWOOD_ENV_*'], all: true, dependencies: ['@redwoodjs/core'] },
-  {
-    slug: 'remix',
-    env: ['REMIX_*'],
-    all: false,
-    dependencies: ['@remix-run/dev', '@remix-run/react', '@remix-run/serve', '@react-router/dev'],
-  },
-  { slug: 'sanity', env: ['SANITY_STUDIO_*'], all: true, dependencies: ['@sanity/cli'] },
-  { slug: 'solidstart', env: ['VITE_*'], all: true, dependencies: ['solid-js', 'solid-start'] },
-  { slug: 'sveltekit', env: ['VITE_*', 'PUBLIC_*'], all: true, dependencies: ['@sveltejs/kit'] },
-  { slug: 'vite', env: ['VITE_*'], all: true, dependencies: ['vite'] },
-  {
-    slug: 'vue',
-    env: ['VUE_APP_*', 'LAUNCH_EDITOR'],
-    all: true,
-    dependencies: ['@vue/cli-service'],
-  },
-]
-
 /** The three global fields of turbo.json a task may draw on. */
 export type TurboGlobal = 'inputs' | 'env' | 'pass'
 
@@ -424,45 +325,6 @@ function keyIgnored(
   inputs.workspaceRuntime = [...probes, ignoredFilesProbe(hits.map(([rel]) => rel))]
 }
 
-/**
- * A directory's Turbo config: `turbo.json`, else `turbo.jsonc` (Turbo 2.5+
- * reads either). Only `turbo.json` was looked for, so a `turbo.jsonc` root
- * failed the run with ENOENT and a package's `turbo.jsonc` overlay was
- * skipped in silence — its `inputs` then keyed nothing (item 938).
- */
-export async function turboConfigFile(dir: string): Promise<string | null> {
-  for (const name of ['turbo.json', 'turbo.jsonc']) {
-    const file = path.join(dir, name)
-    if (await Bun.file(file).exists()) return file
-  }
-  return null
-}
-
-/**
- * The workspace root as a project to name when turbo.json declares `//#`
- * tasks: its package name and directory. Null with no such task, a
- * nameless root, or a file the mapping refuses (it names the file).
- */
-export async function rootTaskProject(root: string): Promise<{ name: string; dir: string } | null> {
-  const file = await turboConfigFile(root)
-  if (file === null) return null
-  let turbo: { tasks?: unknown; pipeline?: unknown } | null
-  let pkg: { name?: unknown } | null
-  try {
-    turbo = Bun.JSONC.parse(await Bun.file(file).text()) as typeof turbo
-    pkg = (await Bun.file(path.join(root, 'package.json')).json()) as typeof pkg
-  } catch {
-    return null
-  }
-  const tasks = turbo?.tasks ?? turbo?.pipeline
-  const hasRootTask =
-    typeof tasks === 'object' &&
-    tasks !== null &&
-    Object.keys(tasks).some((k) => k.startsWith(`${ROOT}#`))
-  if (!hasRootTask || typeof pkg?.name !== 'string' || pkg.name === '') return null
-  return { name: pkg.name, dir: root }
-}
-
 async function readTurboJson(file: string, root: string): Promise<TurboJson> {
   const text = await Bun.file(file).text()
   let parsed: unknown
@@ -606,7 +468,6 @@ function badCommand(def: TurboTask): boolean {
 
 /** Declared task names for a package: plain root keys, `pkg#name` keys
  * for this package, and per-package turbo.json keys — in that order. */
-const ROOT = '//'
 
 /**
  * A package's turbo.json files, root first and its own last, as Turbo's
@@ -892,36 +753,6 @@ async function rootPackageJson(root: string): Promise<PackageMeta['packageJson']
   return (pkg !== null && typeof pkg === 'object' ? pkg : {}) as PackageMeta['packageJson']
 }
 
-/**
- * The microfrontends configs Turbo hashes into every task: each package's
- * (the root's too) `microfrontends.json`, else `microfrontends.jsonc`, or
- * the one name `VC_MICROFRONTENDS_CONFIG_FILE_NAME` gives, unless it is a
- * child's `{ "partOf": … }` (Turbo's `update_turbo_json` appends them to
- * the root's global deps). Unread, an edit to `web`'s routes replayed every
- * sibling app's build (with-microfrontends, Turbo 2.11's dry run moves all
- * 18 tasks). Paths are root-relative; `text` is what the mapping read.
- */
-export function microfrontendsConfigs(
-  root: string,
-  dirs: readonly string[],
-  custom = process.env['VC_MICROFRONTENDS_CONFIG_FILE_NAME'] ?? '',
-): { rel: string; text: string }[] {
-  const names = custom === '' ? ['microfrontends.json', 'microfrontends.jsonc'] : [custom]
-  const out: { rel: string; text: string }[] = []
-  for (const dir of new Set(dirs.map((d) => path.resolve(d)))) {
-    const file = names.map((n) => path.join(dir, n)).find((f) => existsSync(f))
-    if (file === undefined) continue
-    const text = readFileSync(file, 'utf8')
-    let child = false
-    try {
-      const parsed = Bun.JSONC.parse(text) as { partOf?: unknown } | null
-      child = typeof parsed?.partOf === 'string'
-    } catch {}
-    if (!child) out.push({ rel: relPosix(root, file), text })
-  }
-  return out.sort((a, b) => (a.rel < b.rel ? -1 : 1))
-}
-
 export async function mapTurboWorkspace(
   root: string,
   metas: readonly PackageMeta[],
@@ -1177,7 +1008,7 @@ export async function mapTurboWorkspace(
   // over its files, so `test` keys on its dependencies' sources. Dropped,
   // vx keyed `test` on its own files alone: a dependency's edit was a hit.
   // Each package has it as a key-only task, a keyed group, as nx()'s
-  // `nx-input:*` twins are.
+  // `inputs:*` twins are.
   const withScript = new Set<string>()
   for (const set of runnable.values()) for (const name of set) withScript.add(name)
   const sameRefs = new Set<string>()

package/src/turbo/turbo-reads.ts

@@ -0,0 +1,183 @@
+// What a turbo() run reads before it knows whether its kept mapping still
+// holds: the mapping itself (`turbo-map.ts`, ~240 KB with what it imports)
+// loads only when it does not.
+import { existsSync, readFileSync } from 'node:fs'
+import path from 'node:path'
+import { relPosix } from '../paths.js'
+
+/** Turbo's name for the workspace root in `//#task` and `extends`. */
+export const ROOT = '//'
+
+// Turbo 2's framework inference: a package that depends on a framework
+// has its variables hashed into its tasks and passed to them, with
+// nothing in turbo.json saying so. vx env names are explicit, so the
+// variables were stripped in silence and a build that inlines them
+// (Next's `NEXT_PUBLIC_*`) read empty values (item 940). A live mapping
+// (`envNames`) infers them as Turbo does; the migrate CLI lists the names
+// the package's own files spell (`sourceNames`) and says so in a note.
+// Turbo's own table (`packages/turbo-types/src/json/frameworks.json`),
+// in its order: a package takes the FIRST framework it matches, `all`
+// needing every dependency and `some` any one.
+const NITRO_ENV = [
+  'NITRO_*',
+  'SERVER_*',
+  'AWS_APP_ID',
+  'INPUT_AZURE_STATIC_WEB_APPS_API_TOKEN',
+  'CLEAVR',
+  'CF_PAGES',
+  'FIREBASE_APP_HOSTING',
+  'NETLIFY',
+  'STORMKIT',
+  'NOW_BUILDER',
+  'ZEABUR',
+  'RENDER',
+]
+export const FRAMEWORK_ENV: ReadonlyArray<{
+  slug: string
+  env: readonly string[]
+  all: boolean
+  dependencies: readonly string[]
+}> = [
+  { slug: 'astro', env: ['PUBLIC_*'], all: true, dependencies: ['astro'] },
+  { slug: 'blitzjs', env: ['NEXT_PUBLIC_*'], all: true, dependencies: ['blitz'] },
+  {
+    slug: 'create-react-app',
+    env: ['REACT_APP_*'],
+    all: false,
+    dependencies: ['react-scripts', 'react-dev-utils'],
+  },
+  { slug: 'expo', env: ['EXPO_PUBLIC_*'], all: true, dependencies: ['expo'] },
+  { slug: 'gatsby', env: ['GATSBY_*'], all: true, dependencies: ['gatsby'] },
+  {
+    slug: 'nextjs',
+    env: ['NEXT_PUBLIC_*', 'NEXT_DEPLOYMENT_ID'],
+    all: true,
+    dependencies: ['next'],
+  },
+  {
+    slug: 'nitro',
+    env: NITRO_ENV,
+    all: false,
+    dependencies: ['nitropack', 'nitropack-nightly', 'nitro', 'nitro-nightly'],
+  },
+  {
+    slug: 'nuxtjs',
+    env: ['NUXT_*', 'NUXT_ENV_*', ...NITRO_ENV, 'LAUNCH_EDITOR'],
+    all: false,
+    dependencies: ['nuxt', 'nuxt-edge', 'nuxt3', 'nuxt3-edge'],
+  },
+  { slug: 'redwoodjs', env: ['REDWOOD_ENV_*'], all: true, dependencies: ['@redwoodjs/core'] },
+  {
+    slug: 'remix',
+    env: ['REMIX_*'],
+    all: false,
+    dependencies: ['@remix-run/dev', '@remix-run/react', '@remix-run/serve', '@react-router/dev'],
+  },
+  { slug: 'sanity', env: ['SANITY_STUDIO_*'], all: true, dependencies: ['@sanity/cli'] },
+  { slug: 'solidstart', env: ['VITE_*'], all: true, dependencies: ['solid-js', 'solid-start'] },
+  { slug: 'sveltekit', env: ['VITE_*', 'PUBLIC_*'], all: true, dependencies: ['@sveltejs/kit'] },
+  { slug: 'vite', env: ['VITE_*'], all: true, dependencies: ['vite'] },
+  {
+    slug: 'vue',
+    env: ['VUE_APP_*', 'LAUNCH_EDITOR'],
+    all: true,
+    dependencies: ['@vue/cli-service'],
+  },
+]
+
+/** A name core takes in `inputs.env` and `exec.env.passThrough`. */
+export const keyable = (name: string): boolean =>
+  name.length > 0 && !name.startsWith('!') && !/[*?[\]{}=\0]/.test(name)
+
+/**
+ * The names of `names` a live mapping can read differently: each a `*` in
+ * one of `configs` (turbo.json texts, any string, a superset) or in Turbo's
+ * framework table matches, and each core cannot key (a literal one is
+ * dropped only when no variable has it). The kept mapping keyed on every
+ * name, so any variable that came or went (a CI step's, `VX_DEBUG_TIMING`)
+ * remapped the workspace: ~330 ms a run on vercel/ai.
+ */
+export function envNamesThatMap(configs: readonly string[], names: readonly string[]): string[] {
+  const patterns = new Set(FRAMEWORK_ENV.flatMap((f) => f.env).filter((e) => e.includes('*')))
+  for (const text of configs)
+    for (const m of text.matchAll(/"((?:[^"\\]|\\.)*)"/g))
+      if (m[1]!.includes('*')) patterns.add(m[1]!)
+  // Backslashes and a leading `!` dropped, every `*` a wildcard: wider
+  // than Turbo's reading, never narrower.
+  const res = [...patterns].map(
+    (p) =>
+      new RegExp(
+        `^${p.replaceAll('\\', '').replace(/^!/, '').split('*').map(RegExp.escape).join('.*')}$`,
+      ),
+  )
+  return names.filter((n) => !keyable(n) || res.some((re) => re.test(n)))
+}
+
+/**
+ * A directory's Turbo config: `turbo.json`, else `turbo.jsonc` (Turbo 2.5+
+ * reads either). Only `turbo.json` was looked for, so a `turbo.jsonc` root
+ * failed the run with ENOENT and a package's `turbo.jsonc` overlay was
+ * skipped in silence — its `inputs` then keyed nothing (item 938).
+ */
+export async function turboConfigFile(dir: string): Promise<string | null> {
+  for (const name of ['turbo.json', 'turbo.jsonc']) {
+    const file = path.join(dir, name)
+    if (await Bun.file(file).exists()) return file
+  }
+  return null
+}
+
+/**
+ * The workspace root as a project to name when turbo.json declares `//#`
+ * tasks: its package name and directory. Null with no such task, a
+ * nameless root, or a file the mapping refuses (it names the file).
+ */
+export async function rootTaskProject(root: string): Promise<{ name: string; dir: string } | null> {
+  const file = await turboConfigFile(root)
+  if (file === null) return null
+  let turbo: { tasks?: unknown; pipeline?: unknown } | null
+  let pkg: { name?: unknown } | null
+  try {
+    turbo = Bun.JSONC.parse(await Bun.file(file).text()) as typeof turbo
+    pkg = (await Bun.file(path.join(root, 'package.json')).json()) as typeof pkg
+  } catch {
+    return null
+  }
+  const tasks = turbo?.tasks ?? turbo?.pipeline
+  const hasRootTask =
+    typeof tasks === 'object' &&
+    tasks !== null &&
+    Object.keys(tasks).some((k) => k.startsWith(`${ROOT}#`))
+  if (!hasRootTask || typeof pkg?.name !== 'string' || pkg.name === '') return null
+  return { name: pkg.name, dir: root }
+}
+
+/**
+ * The microfrontends configs Turbo hashes into every task: each package's
+ * (the root's too) `microfrontends.json`, else `microfrontends.jsonc`, or
+ * the one name `VC_MICROFRONTENDS_CONFIG_FILE_NAME` gives, unless it is a
+ * child's `{ "partOf": … }` (Turbo's `update_turbo_json` appends them to
+ * the root's global deps). Unread, an edit to `web`'s routes replayed every
+ * sibling app's build (with-microfrontends, Turbo 2.11's dry run moves all
+ * 18 tasks). Paths are root-relative; `text` is what the mapping read.
+ */
+export function microfrontendsConfigs(
+  root: string,
+  dirs: readonly string[],
+  custom = process.env['VC_MICROFRONTENDS_CONFIG_FILE_NAME'] ?? '',
+): { rel: string; text: string }[] {
+  const names = custom === '' ? ['microfrontends.json', 'microfrontends.jsonc'] : [custom]
+  const out: { rel: string; text: string }[] = []
+  for (const dir of new Set(dirs.map((d) => path.resolve(d)))) {
+    const file = names.map((n) => path.join(dir, n)).find((f) => existsSync(f))
+    if (file === undefined) continue
+    const text = readFileSync(file, 'utf8')
+    let child = false
+    try {
+      const parsed = Bun.JSONC.parse(text) as { partOf?: unknown } | null
+      child = typeof parsed?.partOf === 'string'
+    } catch {}
+    if (!child) out.push({ rel: relPosix(root, file), text })
+  }
+  return out.sort((a, b) => (a.rel < b.rel ? -1 : 1))
+}