@vzn/vx-migrate 0.0.0 → 0.0.484

package/src/nx/nx-outputs.ts

@@ -0,0 +1,231 @@
+// An Nx target's `outputs` as vx's cache outputs: project globs and
+// workspace-root globs. Extracted from `buildTask` in item 606.
+
+import path from 'node:path'
+import { minimatchToVx } from '../glob-grammar.js'
+import { takingBack } from '../shared-outputs.js'
+
+interface NxOutputs {
+  readonly outFiles: string[]
+  readonly wsOutFiles: string[]
+}
+
+/**
+ * Nx's `interpolate` for a path, as a workspace-relative one: `{workspaceRoot}`
+ * is the root and `{projectRoot}` / `{projectName}` the project's, ANYWHERE
+ * in the string — `{workspaceRoot}/coverage/{projectRoot}` is `@nx/jest`'s
+ * output. Only a leading token was read before item 912, so that output
+ * 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).
+ */
+export function nxWorkspacePath(s: string, projectRel: string, projectName: string): string | null {
+  const rel = projectRel === '.' ? '' : projectRel
+  const p = s
+    .replaceAll('{workspaceRoot}', '')
+    .replaceAll('{projectRoot}', 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
+  const n = path.posix.normalize(p.replace(/^\/+/, '')).replace(/^\.\//, '')
+  return n === '.' || n === '..' || n.startsWith('../') ? null : n
+}
+
+/** 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
+}
+
+/**
+ * What Nx caches for a target that declares no `outputs`
+ * (`getOutputsForTargetAndConfiguration`): its `options.outputPath`, else,
+ * for `build` and `prepare`, `dist/{root}`, `{root}/dist`, `{root}/build`
+ * and `{root}/public`. Read as no outputs, a cached target's hit restored
+ * nothing (item 1052). vx cleans an output before the task runs, and a
+ * project's `build/` or `public/` is as often its committed sources, which
+ * Nx, never cleaning, leaves alone: with `tops` (the project's tracked
+ * top-level names) one git tracks nothing under is an output, and one it
+ * does is left out with a todo; without `tops`, both are.
+ */
+export function nxDefaultOutputs(
+  targetName: string,
+  options: Record<string, unknown>,
+  projectRel: string,
+  todos: string[],
+  tops?: ReadonlySet<string>,
+): string[] {
+  const outputPath = options['outputPath']
+  if (typeof outputPath === 'string') return [outputPath]
+  // A list is each of its paths, as Nx takes it; read as no `outputPath`,
+  // the build cached the default directories and a hit restored none.
+  if (Array.isArray(outputPath) && outputPath.length > 0) {
+    if (outputPath.every((o) => typeof o === 'string')) return outputPath
+  }
+  if (targetName !== 'build' && targetName !== 'prepare') return []
+  const root = projectRel === '.' ? '' : projectRel
+  const at = (p: string): string => path.posix.join(root, 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`,
+    )
+  // The root project's two are one path.
+  return [
+    ...new Set([path.posix.join('dist', root), at('dist')]),
+    ...['build', 'public'].filter((d) => !held.includes(d)).map(at),
+  ]
+}
+
+/** `outputs` with `{options.x}` resolved against `options`; `projectRel` is the project dir, `.` for the root. */
+export function mapNxOutputs(
+  outputs: readonly string[],
+  options: Record<string, unknown>,
+  projectRel: string,
+  projectName: string,
+  todos: string[],
+): NxOutputs {
+  const outFiles: string[] = []
+  const wsOutFiles: string[] = []
+  outputs: for (const o of outputs) {
+    // A `!` output takes a path back, as Nx's does (A-44); it maps as its
+    // path does and keeps the `!`.
+    const neg = o.startsWith('!') ? '!' : ''
+    let s = o.slice(neg.length)
+    // Every `{options.x}`, not the first: `dist/{options.a}/{options.b}`.
+    for (const optTok of o.matchAll(/\{options\.([^}]+)\}/g)) {
+      // A dotted path walks the options, as Nx's `_interpolate` does:
+      // @nx/angular:application's `{options.outputPath.base}` read as one
+      // key was no output, and a cached build's hit restored nothing.
+      let v: unknown = options
+      for (const k of optTok[1]!.split('.')) {
+        v = v !== null && typeof v === 'object' ? (v as Record<string, unknown>)[k] : undefined
+        if (!v) break
+      }
+      // Nx leaves a falsy option's token in place and drops the output
+      // (`getOutputsForTargetAndConfiguration`): @nx/eslint's
+      // `{options.outputFile}` with no outputFile is no output, not a todo
+      // on every lint target (2026-09-28).
+      if (!v) continue outputs
+      // Nx's template replacement writes a number or a boolean as its text.
+      if (typeof v === 'number' || typeof v === 'boolean') {
+        s = s.replace(optTok[0], String(v))
+        continue
+      }
+      if (typeof v !== 'string') {
+        todos.push(
+          `output ${JSON.stringify(o)}: option ${JSON.stringify(optTok[1])} is not a literal ` +
+            'string — resolve manually',
+        )
+        continue outputs
+      }
+      s = s.replace(optTok[0], v)
+    }
+    if (s.includes('{')) {
+      const p = nxWorkspacePath(s, projectRel, projectName)
+      if (p === null) {
+        todos.push(`output ${JSON.stringify(o)} uses a token vx does not support`)
+        continue
+      }
+      s = p
+    }
+    // Plain paths resolve against the workspace root in nx. One outside
+    // the project dir is Nx's DEFAULT layout (`@nx/js:tsc` writes
+    // `dist/<project>` at the root), so it is the workspace-root output it
+    // is, not a gap: as a todo, every such target hit green and restored
+    // NOTHING (item 593, the bench workspace's 1,000 `build` targets).
+    // As written: core reads a literal as the path or the tree under it
+    // (`asTrees`), and keeps a hit's directory short-circuit for either. The
+    // `<rel>/**` this wrote for an extensionless name matched nothing under
+    // a FILE, so a binary like `dist/bin/tool` was never saved (Next 27).
+    // A path that leaves the workspace (an old generator's
+    // `reportsDirectory: "../../coverage/<lib>"`, read from the workspace
+    // root as Nx 23 reads it) has no place in a config: core refuses `..`,
+    // so the written file failed to load and every task with it.
+    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 — ` +
+          'vx caches only inside it; dropped',
+      )
+      continue
+    }
+    const globs = vxOutputGlobs(neg + s)
+    if (globs === null) {
+      todos.push(`output ${JSON.stringify(o)} has a glob form vx cannot spell — dropped`)
+      continue
+    }
+    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(/^\.\//, ''))
+    }
+  }
+  return { outFiles: takingBack(outFiles), wsOutFiles: takingBack(wsOutFiles) }
+}
+
+/**
+ * An Nx output in vx's glob grammar, or null when it has none. Next's
+ * inferred build writes `.next/!(cache)/**\/*`, which vx read as a literal
+ * `!(cache)` dir: the build saved nothing and a hit restored no `.next`.
+ * A whole-segment `!(a|b)` is `*` with `!` outputs taking `{a,b}` back;
+ * the rest is `minimatchToVx`'s.
+ */
+function vxOutputGlobs(o: string): string[] | null {
+  const negated = o.startsWith('!')
+  const segs = o.slice(negated ? 1 : 0).split('/')
+  const at = segs.findIndex((seg) => /^!\([^()|{},]+(\|[^()|{},]+)*\)$/.test(seg))
+  if (at !== -1) {
+    if (negated) return null
+    const alts = segs[at]!.slice(2, -1).split('|')
+    const back = alts.length === 1 ? alts[0]! : `{${alts.join(',')}}`
+    const pos = vxOutputGlobs([...segs.slice(0, at), '*', ...segs.slice(at + 1)].join('/'))
+    const neg = minimatchToVx([...segs.slice(0, at), back, ...segs.slice(at + 1)].join('/'), true)
+    return pos === null || neg === null ? null : [...pos, `!${neg}`]
+  }
+  const g = minimatchToVx(segs.join('/'), negated)
+  return g === null ? null : [(negated ? '!' : '') + g]
+}
+
+/**
+ * The literal paths a project's targets write, workspace-relative. An input
+ * inside one is generated: Nx hashes it from disk (TanStack/table's
+ * `public` input lists `{projectRoot}/dist` for every `^public`), and vx
+ * refuses a path git does not list.
+ */
+export function nxProjectOutputs(
+  targets:
+    | Readonly<Record<string, { outputs?: string[]; options?: Record<string, unknown> }>>
+    | undefined,
+  projectRel: string,
+  projectName: string,
+): string[] {
+  if (targets === undefined) return []
+  const known = projectOutputsMemo.get(targets)
+  if (known !== undefined) return known
+  const out = new Set<string>()
+  const scratch: string[] = []
+  const rel = projectRel === '.' ? '' : projectRel
+  for (const [name, t] of Object.entries(targets)) {
+    const options = t.options ?? {}
+    const { outFiles, wsOutFiles } = mapNxOutputs(
+      t.outputs ?? nxDefaultOutputs(name, options, projectRel, scratch),
+      options,
+      projectRel,
+      projectName,
+      scratch,
+    )
+    for (const f of [...outFiles.map((f) => path.posix.join(rel, f)), ...wsOutFiles]) {
+      const lit = f.replace(/\/\*\*(\/\*)?$/, '')
+      if (!lit.startsWith('!') && !/[*?[{]/.test(lit)) out.add(lit)
+    }
+  }
+  const r = [...out]
+  projectOutputsMemo.set(targets, r)
+  return r
+}
+
+// Keyed on the node's own targets object: every target of a project asks.
+const projectOutputsMemo = new WeakMap<object, string[]>()

package/src/nx/nx-upstream.ts

@@ -0,0 +1,356 @@
+// Nx's `^name` inputs over the project graph (item 910). Nx hashes a
+// dependency's `name` input for every project the graph reaches, whether or
+// not a task edge exists, so a `test` with `^production` and no `dependsOn`
+// re-keys on a dependency's source. vx folds upstream KEYS along
+// `dependsOn`, so each project gets one `nx-input:<name>` task — `true`,
+// cached, keyed on the project's own `name` input — with an edge to its
+// dependencies' twin. A task that reads `^name` depends on its direct
+// dependencies' twins and folds the whole closure through them: each
+// project's files are hashed once, not once per dependant (listing the
+// closure's globs on every task was 2.5 million globs at 1,000 projects).
+//
+// The edges are the NX graph's, not vx's package graph (`^` in vx follows
+// package.json, and an Nx edge from a tsconfig path has no manifest entry),
+// so they are explicit `pkg#nx-input:<name>`. A graph node with no vx
+// project is transparent: its files join as workspace globs and the walk
+// goes on through it. Nx allows a project cycle and vx's task graph does
+// not: inside a cycle a twin carries its peers' files as workspace globs
+// and edges only out of the cycle.
+import type { GeneratedTask, ProjectMeta } from '@vzn/vx'
+import { emptyNxInputs, expandNxInputs, type NxInputs } from './nx-inputs.js'
+import { nxProjectOutputs } from './nx-outputs.js'
+import { matchNxProjects } from './nx-deps.js'
+
+interface GraphNode {
+  name?: string
+  data?: {
+    root?: string
+    tags?: unknown[]
+    namedInputs?: Record<string, unknown[]>
+    targets?: Record<string, { outputs?: string[]; options?: Record<string, unknown> }>
+  }
+}
+
+/**
+ * Nx reads `^{projectRoot}/…` and `^{workspaceRoot}/…` as each
+ * dependency's FILESET, not a named input
+ * (`splitInputsIntoSelfAndDependencies`), and so is
+ * `{ fileset, dependencies: true }`. Looked up as a named input, it was a
+ * todo and nothing: a dependency's `tsconfig.lib.json` edit re-keyed no
+ * dependant.
+ */
+const isFileset = (name: string): boolean =>
+  name.startsWith('{projectRoot}') || name.startsWith('{workspaceRoot}')
+
+/** A fileset twin is named by its hash: a glob's `*` is no task name. */
+const inputTask = (name: string): string =>
+  isFileset(name)
+    ? `nx-input:fileset-${Bun.hash.xxHash3(name).toString(16).padStart(16, '0')}`
+    : `nx-input:${name}`
+
+function normRel(p: string): string {
+  const s = p.replace(/\/+$/, '')
+  return s === '.' ? '' : s
+}
+
+export interface NxUpstream {
+  /** Nx's merge: an implicit `default` of the whole project, nx.json's, the project's. */
+  namedOf(node: string): Readonly<Record<string, unknown[]>>
+  /**
+   * Folds `into.upstream` for a task of `node`: the `dependsOn` edges it
+   * needs, with a transparent node's files added to `into`.
+   */
+  resolve(node: string, into: NxInputs, todos: string[]): string[]
+  /** Each project's `nx-input:<name>` tasks, for every twin an edge reaches. */
+  inputTasks(): Map<string, GeneratedTask[]>
+}
+
+export function planNxUpstream(
+  nodes: Readonly<Record<string, GraphNode>>,
+  dependencies: unknown,
+  workspaceNamed: Readonly<Record<string, unknown[]>> | null,
+  metaByNode: ReadonlyMap<string, ProjectMeta>,
+): NxUpstream {
+  const isProject = (n: string): boolean => typeof nodes[n]?.data?.root === 'string'
+  const projectTags = Object.entries(nodes).map(([name, n]) => ({
+    name,
+    tags: Array.isArray(n?.data?.tags) ? n.data.tags.filter((t) => typeof t === 'string') : [],
+    ...(typeof n?.data?.root === 'string' ? { root: n.data.root } : {}),
+  }))
+  const direct = new Map<string, string[]>()
+  if (typeof dependencies === 'object' && dependencies !== null) {
+    for (const [source, edges] of Object.entries(
+      dependencies as Record<string, Array<{ target?: unknown }>>,
+    )) {
+      if (!Array.isArray(edges)) continue
+      // An `npm:` node has no root: it is a package, not a project.
+      const to = edges
+        .map((e) => e?.target)
+        .filter((t): t is string => typeof t === 'string' && t !== source && isProject(t))
+      direct.set(source, [...new Set(to)])
+    }
+  }
+
+  // The vx projects a node reaches first, through any transparent nodes,
+  // and the transparent nodes on the way.
+  const reachMemo = new Map<string, { edges: string[]; through: string[] }>()
+  const reach = (node: string): { edges: string[]; through: string[] } => {
+    const known = reachMemo.get(node)
+    if (known !== undefined) return known
+    const edges = new Set<string>()
+    const through = new Set<string>()
+    const stack = [...(direct.get(node) ?? [])]
+    while (stack.length > 0) {
+      const n = stack.pop()!
+      if (n === node || edges.has(n) || through.has(n)) continue
+      if (metaByNode.has(n)) edges.add(n)
+      else {
+        through.add(n)
+        stack.push(...(direct.get(n) ?? []))
+      }
+    }
+    const r = { edges: [...edges].sort(), through: [...through].sort() }
+    reachMemo.set(node, r)
+    return r
+  }
+
+  // Tarjan's strongly connected components over the vx projects.
+  const component = new Map<string, string[]>()
+  {
+    let index = 0
+    const idx = new Map<string, number>()
+    const low = new Map<string, number>()
+    const onStack = new Set<string>()
+    const stack: string[] = []
+    const visit = (root: string): void => {
+      // Iterative: a deep graph must not overflow the call stack.
+      const work: Array<{ node: string; next: number }> = [{ node: root, next: 0 }]
+      idx.set(root, index)
+      low.set(root, index++)
+      stack.push(root)
+      onStack.add(root)
+      while (work.length > 0) {
+        const frame = work[work.length - 1]!
+        const out = reach(frame.node).edges
+        if (frame.next < out.length) {
+          const w = out[frame.next++]!
+          if (!idx.has(w)) {
+            idx.set(w, index)
+            low.set(w, index++)
+            stack.push(w)
+            onStack.add(w)
+            work.push({ node: w, next: 0 })
+          } else if (onStack.has(w)) {
+            low.set(frame.node, Math.min(low.get(frame.node)!, idx.get(w)!))
+          }
+          continue
+        }
+        work.pop()
+        const parent = work[work.length - 1]
+        if (parent !== undefined)
+          low.set(parent.node, Math.min(low.get(parent.node)!, low.get(frame.node)!))
+        if (low.get(frame.node) === idx.get(frame.node)) {
+          const members: string[] = []
+          let w: string
+          do {
+            w = stack.pop()!
+            onStack.delete(w)
+            members.push(w)
+          } while (w !== frame.node)
+          members.sort()
+          for (const m of members) component.set(m, members)
+        }
+      }
+    }
+    for (const n of [...metaByNode.keys()].sort()) if (!idx.has(n)) visit(n)
+  }
+
+  const namedMemo = new Map<string, Readonly<Record<string, unknown[]>>>()
+  const namedOf = (node: string): Readonly<Record<string, unknown[]>> => {
+    let named = namedMemo.get(node)
+    if (named === undefined) {
+      named = {
+        default: ['{projectRoot}/**/*'],
+        ...workspaceNamed,
+        ...nodes[node]?.data?.namedInputs,
+      }
+      namedMemo.set(node, named)
+    }
+    return named
+  }
+
+  // A node's `name` input, its project globs rewritten under its root.
+  const underMemo = new Map<string, { inputs: NxInputs; todos: string[] }>()
+  const under = (node: string, name: string): { inputs: NxInputs; todos: string[] } => {
+    const key = `${node}\0${name}`
+    const known = underMemo.get(key)
+    if (known !== undefined) return known
+    const own = emptyNxInputs()
+    const todos: string[] = []
+    expandOwn(node, name, own, todos)
+    const rel = normRel(nodes[node]?.data?.root ?? '')
+    const inputs = emptyNxInputs()
+    for (const g of own.files) {
+      const neg = g.startsWith('!') ? '!' : ''
+      inputs.wsFiles.push(rel === '' ? g : `${neg}${rel}/${neg === '' ? g : g.slice(1)}`)
+    }
+    inputs.wsFiles.push(...own.wsFiles)
+    inputs.envNames.push(...own.envNames)
+    inputs.runtimeCmds.push(...own.runtimeCmds)
+    inputs.upstream.push(...own.upstream)
+    const r = { inputs, todos }
+    underMemo.set(key, r)
+    return r
+  }
+  const expandOwn = (node: string, name: string, into: NxInputs, todos: string[]): void => {
+    if (!isFileset(name) && namedOf(node)[name] === undefined) {
+      // Its whole project, as `expandNxInputs` keys an unknown own input.
+      into.files.push('**/*')
+      todos.push(
+        `named input ${JSON.stringify(name)} not found for ${JSON.stringify(node)} — keyed on its whole project (\`**/*\`) until its globs are declared`,
+      )
+      return
+    }
+    const rel = normRel(nodes[node]?.data?.root ?? '')
+    const nm = nodes[node]?.name ?? node
+    const at = {
+      rel,
+      name: nm,
+      outputs: nxProjectOutputs(nodes[node]?.data?.targets, rel || '.', nm),
+    }
+    expandNxInputs([name], namedOf(node), at, into, todos)
+  }
+
+  const merge = (from: NxInputs, into: NxInputs): void => {
+    into.wsFiles.push(...from.wsFiles)
+    for (const n of from.envNames) if (!into.envNames.includes(n)) into.envNames.push(n)
+    for (const c of from.runtimeCmds) if (!into.runtimeCmds.includes(c)) into.runtimeCmds.push(c)
+  }
+
+  // The twins some edge reaches, and only those: one per project per name
+  // was a twin no task depends on for every project nothing depends on,
+  // loaded and keyed on every run (Next 25).
+  const wanted = new Set<string>()
+  const queue: Array<readonly [node: string, name: string]> = []
+  const want = (node: string, name: string): void => {
+    const key = `${node}\0${name}`
+    if (wanted.has(key)) return
+    wanted.add(key)
+    queue.push([node, name])
+  }
+
+  // `name` of everything `self` reaches, as edges to twins, except
+  // `peers` — the other members of `self`'s cycle, which a twin carries as
+  // files. `visited` ends the walk of a nested `^` through a cycle of
+  // transparent nodes.
+  const fold = (
+    self: string,
+    name: string,
+    peers: ReadonlySet<string>,
+    into: NxInputs,
+    todos: string[],
+    edges: Set<string>,
+    visited: Set<string> = new Set(),
+  ): void => {
+    const files = new Set<string>()
+    for (const s of peers.size > 0 ? peers : [self]) {
+      const r = reach(s)
+      for (const t of r.through) files.add(t)
+      for (const e of r.edges) {
+        if (peers.has(e)) continue
+        edges.add(`${metaByNode.get(e)!.name}#${inputTask(name)}`)
+        want(e, name)
+      }
+    }
+    for (const p of peers) if (p !== self) files.add(p)
+    for (const f of [...files].sort()) {
+      if (visited.has(`${f}\0${name}`)) continue
+      visited.add(`${f}\0${name}`)
+      const r = under(f, name)
+      merge(r.inputs, into)
+      todos.push(...r.todos)
+      // A folded node's own nested `^other` goes on from it; `^name` itself
+      // is the closure this walk already covers.
+      for (const u of r.inputs.upstream)
+        if (u.of === 'deps' && u.name !== name)
+          fold(f, u.name, new Set(), into, todos, edges, visited)
+    }
+  }
+
+  // `{ input, projects }`: those projects' twins (Nx reads each one's own
+  // input; the twin's closure is a superset, which only costs hits).
+  const foldProjects = (
+    name: string,
+    of: readonly string[],
+    into: NxInputs,
+    todos: string[],
+    edges: Set<string>,
+  ): void => {
+    // Nx reads the list as `dependsOn`'s `projects` (`findMatchingProjects`):
+    // `*` patterns, `tag:` and `!` exclusions. Looked up as names, a
+    // `tag:shared` reader was a todo and its input dropped from the key.
+    const literal = of.filter(
+      (p) =>
+        !/^!|^tag:|\*/.test(p) &&
+        nodes[p] === undefined &&
+        matchNxProjects([p], projectTags).length === 0,
+    )
+    for (const p of literal)
+      todos.push(`input project ${JSON.stringify(p)} is not a graph node — map manually`)
+    for (const p of matchNxProjects(of, projectTags)) {
+      const u = { name }
+      const meta = metaByNode.get(p)
+      if (meta !== undefined) {
+        edges.add(`${meta.name}#${inputTask(u.name)}`)
+        want(p, u.name)
+      } else if (isProject(p)) {
+        const r = under(p, u.name)
+        merge(r.inputs, into)
+        todos.push(...r.todos)
+      }
+    }
+  }
+
+  const resolve = (node: string, into: NxInputs, todos: string[]): string[] => {
+    const edges = new Set<string>()
+    for (const u of into.upstream) {
+      if (u.of === 'deps') fold(node, u.name, new Set(), into, todos, edges)
+      else foldProjects(u.name, u.of, into, todos, edges)
+    }
+    return [...edges]
+  }
+
+  const inputTasks = (): Map<string, GeneratedTask[]> => {
+    const out = new Map<string, GeneratedTask[]>()
+    for (let i = 0; i < queue.length; i++) {
+      const [node, name] = queue[i]!
+      const todos: string[] = []
+      const inputs = emptyNxInputs()
+      expandOwn(node, name, inputs, todos)
+      const members = component.get(node) ?? [node]
+      const peers = new Set(members.length > 1 ? members : [])
+      const edges = new Set<string>()
+      fold(node, name, peers, inputs, todos, edges)
+      // A nested `^other` in this project's `name` input.
+      for (const u of inputs.upstream) {
+        if (u.of !== 'deps') foldProjects(u.name, u.of, inputs, todos, edges)
+        else if (u.name !== name) fold(node, u.name, peers, inputs, todos, edges)
+      }
+      const cacheInputs: Record<string, unknown> = { files: inputs.files }
+      if (inputs.wsFiles.length > 0) cacheInputs.workspaceFiles = inputs.wsFiles
+      if (inputs.envNames.length > 0) cacheInputs.env = inputs.envNames
+      if (inputs.runtimeCmds.length > 0) cacheInputs.workspaceRuntime = inputs.runtimeCmds
+      const task: Record<string, unknown> = { exec: { command: 'true' } }
+      if (isFileset(name))
+        task.description = `Nx fileset ${name} of this project and what it reaches`
+      if (edges.size > 0) task.dependsOn = [...edges].sort()
+      task.cache = { inputs: cacheInputs, outputs: { files: [] } }
+      const list = out.get(node) ?? []
+      list.push({ name: inputTask(name), task, todos })
+      out.set(node, list)
+    }
+    return out
+  }
+
+  return { namedOf, resolve, inputTasks }
+}