@mnci/cli 4.52.0 → 4.54.0

package/dist/cli.js

@@ -136,8 +136,8 @@ async function promptStack() {
 }
 
 // src/nx-workspace/nx.client.ts
-function runShell(command, arguments_, cwd) {
-  const result = import_cross_spawn.default.sync(command, arguments_, { stdio: "inherit", cwd });
+function runShell(command, arguments_, cwd, environment) {
+  const result = import_cross_spawn.default.sync(command, arguments_, { stdio: "inherit", cwd, env: environment === void 0 ? void 0 : { ...process.env, ...environment } });
   return result.status ?? 1;
 }
 var CAPTURE_TIMEOUT_MS = 6e4;
@@ -199,10 +199,10 @@ function runNpx(arguments_, cwd) {
   }
 }
 function runFormatter(cwd, target = ".") {
-  const status = runShell("npx", ["eslint", target, "--fix"], cwd);
+  const status = runShell("npx", ["eslint", target, "--fix"], cwd, { NODE_OPTIONS: "--max-old-space-size=8192" });
   if (status !== 0) {
     logger.warn(
-      `eslint could not format '${target}' (exit code ${status}). The project was generated; run 'npm run format' to normalise it.`
+      `eslint could not format '${target}' (exit code ${status}), so formatting was SKIPPED and the tree is not normalised. The project was generated; run 'npm run format' to finish it.`
     );
   }
 }
@@ -2236,6 +2236,13 @@ updates:
     directory: "/"
     schedule:
       interval: weekly
+    # The Nx packages are pinned to one exact version and must move together: a PR for one alone fails resolution
+    # (ERESOLVE between @nx/eslint and @nx/jest) or leaves a second copy of nx in the lockfile (#295).
+    groups:
+      nx:
+        patterns:
+          - "nx"
+          - "@nx/*"
 
   - package-ecosystem: github-actions
     directory: "/"
@@ -3187,7 +3194,7 @@ function runPhase(phase, workspaceRoot, dependencies) {
 }
 
 // src/project-scaffolding/add-project.use-case.ts
-var import_node_path35 = require("path");
+var import_node_path37 = require("path");
 var import_prompts3 = require("@inquirer/prompts");
 
 // src/project-name/project-name.validator.ts
@@ -4090,12 +4097,19 @@ function goModulePrefix(workspaceRoot) {
   const result = runCapture("git", ["remote", "get-url", "origin"], workspaceRoot);
   return result.status === 0 ? modulePrefixFromRemoteUrl(result.stdout) : void 0;
 }
+function rootModulePath(workspaceRoot) {
+  try {
+    return /^module\s+(\S+)/m.exec((0, import_node_fs15.readFileSync)((0, import_node_path14.join)(workspaceRoot, "go.mod"), "utf8"))?.[1];
+  } catch {
+    return void 0;
+  }
+}
 function registerNxGoPlugin(workspaceRoot) {
   const nxJsonPath = (0, import_node_path14.join)(workspaceRoot, "nx.json");
   if (!fileExists(nxJsonPath)) {
     return false;
   }
-  const modulePrefix = goModulePrefix(workspaceRoot);
+  const modulePrefix = rootModulePath(workspaceRoot) === void 0 ? goModulePrefix(workspaceRoot) : void 0;
   const entry = modulePrefix === void 0 ? NX_GO_PLUGIN : { plugin: NX_GO_PLUGIN, options: { modulePrefix } };
   const nxJson = readJson(nxJsonPath);
   const plugins = [...nxJson.plugins ?? []];
@@ -4805,11 +4819,11 @@ function addGoInternalLib(workspaceRoot, name) {
   }
 }
 
-// src/project-scaffolding/esm-conversion.use-case.ts
+// src/esm-conversion/esm-conversion.use-case.ts
 var import_node_fs19 = require("fs");
 var import_node_path18 = require("path");
 
-// src/project-scaffolding/esm-specifiers.algorithm.ts
+// src/esm-conversion/esm-specifiers.algorithm.ts
 var RELATIVE_SPECIFIER = /((?:\bfrom|\bimport)\s*)(['"])(\.{1,2}\/[^'"\n]*|\.{1,2})\2/g;
 var HAS_EXTENSION = /\.(?:[cm]?js|json|node)$/;
 function withJsSpecifiers(source, directories = []) {
@@ -4822,7 +4836,7 @@ function withJsSpecifiers(source, directories = []) {
   });
 }
 
-// src/project-scaffolding/esm-conversion.use-case.ts
+// src/esm-conversion/esm-conversion.use-case.ts
 var SAMPLE_DIRECTORIES = ["./hello"];
 var JEST_ANCHOR = "  moduleFileExtensions:";
 var JEST_MAPPER = String.raw`  moduleNameMapper: { '^(\\.{1,2}/.*)\\.js$': '$1' },`;
@@ -6090,9 +6104,75 @@ function refreshContainerScript(workspaceRoot) {
 }
 
 // src/project-scaffolding/react-app.use-case.ts
+var import_node_fs28 = require("fs");
+var import_node_path30 = require("path");
+
+// src/react-app-output/find-react-apps-sharing-output.use-case.ts
 var import_node_fs27 = require("fs");
 var import_node_path28 = require("path");
 
+// src/react-app-output/react-app-output.policy.ts
+var VITE_DEFAULT_OUT_DIR = "dist";
+var VITE_OUT_DIR = /\boutDir:\s*['"]([^'"]+)['"]/;
+function normalise(folder) {
+  return folder.replace(/^\.\//, "").replace(/\/+$/, "");
+}
+function viteOutputFolder(viteConfig) {
+  return normalise(VITE_OUT_DIR.exec(viteConfig)?.[1] ?? VITE_DEFAULT_OUT_DIR);
+}
+function sharesOutputFolder(typescriptOutDir, viteConfig) {
+  return typescriptOutDir !== void 0 && normalise(typescriptOutDir) === viteOutputFolder(viteConfig);
+}
+
+// src/react-app-output/find-react-apps-sharing-output.use-case.ts
+var VITE_CONFIGS = ["vite.config.mts", "vite.config.ts", "vite.config.mjs", "vite.config.js"];
+function appSharesOutputFolder(appRoot) {
+  const config = VITE_CONFIGS.find((name) => fileExists((0, import_node_path28.join)(appRoot, name)));
+  const tsconfigPath = (0, import_node_path28.join)(appRoot, "tsconfig.app.json");
+  if (config === void 0 || !fileExists(tsconfigPath)) {
+    return false;
+  }
+  try {
+    const outDir = readJson(tsconfigPath).compilerOptions?.outDir;
+    return sharesOutputFolder(outDir, (0, import_node_fs27.readFileSync)((0, import_node_path28.join)(appRoot, config), "utf8"));
+  } catch {
+    return false;
+  }
+}
+function findReactAppsSharingOutput(workspaceRoot) {
+  let entries;
+  try {
+    entries = (0, import_node_fs27.readdirSync)((0, import_node_path28.join)(workspaceRoot, "apps"));
+  } catch {
+    return [];
+  }
+  return entries.filter((entry) => appSharesOutputFolder((0, import_node_path28.join)(workspaceRoot, "apps", entry))).map((entry) => `apps/${entry}`).toSorted((a, b) => a.localeCompare(b));
+}
+
+// src/react-app-output/separate-react-app-output.use-case.ts
+var import_node_path29 = require("path");
+function separateReactAppOutput(appRoot) {
+  if (!appSharesOutputFolder(appRoot)) {
+    return false;
+  }
+  const tsconfigPath = (0, import_node_path29.join)(appRoot, "tsconfig.app.json");
+  const tsconfig = readJson(tsconfigPath);
+  writeFileEnsured(tsconfigPath, toJson({
+    ...tsconfig,
+    compilerOptions: { ...tsconfig.compilerOptions, outDir: "out-tsc/app", tsBuildInfoFile: "out-tsc/app/tsconfig.app.tsbuildinfo" }
+  }));
+  return true;
+}
+function separateReactAppsOutput(workspaceRoot) {
+  const repaired = [];
+  for (const dir of findReactAppsSharingOutput(workspaceRoot)) {
+    if (separateReactAppOutput((0, import_node_path29.join)(workspaceRoot, dir))) {
+      repaired.push(dir);
+    }
+  }
+  return repaired;
+}
+
 // src/project-scaffolding/react-app-example.algorithm.ts
 function reactAppExampleFiles(name) {
   return {
@@ -6217,12 +6297,12 @@ function reactAppTargets(name) {
   return targets;
 }
 function allowEnvFiles(workspaceRoot) {
-  const gitignorePath = (0, import_node_path28.join)(workspaceRoot, ".gitignore");
+  const gitignorePath = (0, import_node_path30.join)(workspaceRoot, ".gitignore");
   if (!fileExists(gitignorePath)) {
     return;
   }
   const marker = "# MoNecromanCI: keep the committed per-environment Vite config (public VITE_ values)";
-  const current = (0, import_node_fs27.readFileSync)(gitignorePath, "utf8");
+  const current = (0, import_node_fs28.readFileSync)(gitignorePath, "utf8");
   if (current.includes(marker)) {
     return;
   }
@@ -6249,17 +6329,18 @@ function addReactApp(workspaceRoot, name, stack, e2e = false) {
     workspaceRoot
   );
   ensureAdmZip(workspaceRoot);
-  const reactAppRoot = (0, import_node_path28.join)(workspaceRoot, "apps", name);
+  const reactAppRoot = (0, import_node_path30.join)(workspaceRoot, "apps", name);
   for (const environment of REACT_ENVIRONMENTS) {
-    writeFileEnsured((0, import_node_path28.join)(reactAppRoot, `.env.${environment}`), reactEnvironmentFile(environment));
+    writeFileEnsured((0, import_node_path30.join)(reactAppRoot, `.env.${environment}`), reactEnvironmentFile(environment));
   }
   allowEnvFiles(workspaceRoot);
-  addNxTargets((0, import_node_path28.join)(reactAppRoot, "package.json"), reactAppTargets(name));
+  addNxTargets((0, import_node_path30.join)(reactAppRoot, "package.json"), reactAppTargets(name));
   reshapeReactAppScaffold(reactAppRoot);
-  (0, import_node_fs27.rmSync)((0, import_node_path28.join)(reactAppRoot, "src/app/nx-welcome.component.tsx"), { force: true });
+  separateReactAppOutput(reactAppRoot);
+  (0, import_node_fs28.rmSync)((0, import_node_path30.join)(reactAppRoot, "src/app/nx-welcome.component.tsx"), { force: true });
   const example = reactAppExampleFiles(name);
   for (const [relative, contents] of Object.entries(example)) {
-    writeFileEnsured((0, import_node_path28.join)(reactAppRoot, "src", relative), contents);
+    writeFileEnsured((0, import_node_path30.join)(reactAppRoot, "src", relative), contents);
   }
   removeGeneratedEslintConfig(workspaceRoot, `apps/${name}`);
   registerProjectCommands(workspaceRoot, name, { build: true, start: `nx run ${name}:serve` });
@@ -6269,9 +6350,9 @@ function addReactApp(workspaceRoot, name, stack, e2e = false) {
 }
 function pairE2eProject(workspaceRoot, name) {
   const e2eName = `${name}-e2e`;
-  const e2eRoot = (0, import_node_path28.join)(workspaceRoot, "apps", e2eName);
-  (0, import_node_fs27.rmSync)((0, import_node_path28.join)(e2eRoot, "src/example.spec.ts"), { force: true });
-  writeFileEnsured((0, import_node_path28.join)(e2eRoot, "src/greeting.e2e.spec.ts"), reactAppE2eSpec(name));
+  const e2eRoot = (0, import_node_path30.join)(workspaceRoot, "apps", e2eName);
+  (0, import_node_fs28.rmSync)((0, import_node_path30.join)(e2eRoot, "src/example.spec.ts"), { force: true });
+  writeFileEnsured((0, import_node_path30.join)(e2eRoot, "src/greeting.e2e.spec.ts"), reactAppE2eSpec(name));
   removeGeneratedEslintConfig(workspaceRoot, `apps/${e2eName}`);
   registerProjectCommands(workspaceRoot, e2eName, {
     build: false,
@@ -6280,13 +6361,13 @@ function pairE2eProject(workspaceRoot, name) {
 }
 
 // src/project-scaffolding/react-lib.use-case.ts
-var import_node_path29 = require("path");
+var import_node_path31 = require("path");
 var REACT_LIB_BUNDLER = "rollup";
 async function addReactLib(workspaceRoot, name, options, kindProvided, stack) {
   ensurePlugin(workspaceRoot, "@nx/react");
   const scope = options.scope ?? (kindProvided ? defaultScope(workspaceRoot) : await promptText("npm scope for the published package", defaultScope(workspaceRoot)));
-  const projectRoot = (0, import_node_path29.join)(workspaceRoot, "packages", name);
-  const publishableManifest = (0, import_node_path29.join)(projectRoot, "package.json");
+  const projectRoot = (0, import_node_path31.join)(workspaceRoot, "packages", name);
+  const publishableManifest = (0, import_node_path31.join)(projectRoot, "package.json");
   runGeneratorAndRepair(
     workspaceRoot,
     [
@@ -6330,8 +6411,8 @@ function dropNxProjectName(manifestPath) {
 }
 function addReactInternalLib(workspaceRoot, name, stack, empty = false) {
   ensurePlugin(workspaceRoot, "@nx/react");
-  const projectRoot = (0, import_node_path29.join)(workspaceRoot, "libs", name);
-  const privateManifest = (0, import_node_path29.join)(projectRoot, "package.json");
+  const projectRoot = (0, import_node_path31.join)(workspaceRoot, "libs", name);
+  const privateManifest = (0, import_node_path31.join)(projectRoot, "package.json");
   runGeneratorAndRepair(
     workspaceRoot,
     [
@@ -6358,8 +6439,8 @@ function addReactInternalLib(workspaceRoot, name, stack, empty = false) {
 }
 
 // src/project-scaffolding/vscode-extension.use-case.ts
-var import_node_fs28 = require("fs");
-var import_node_path30 = require("path");
+var import_node_fs29 = require("fs");
+var import_node_path32 = require("path");
 var VSCODE_EXTENSION_SCRIPT_PATH = "tools/vscode-extension.cjs";
 var VSCODE_ENGINE_FLOOR = "1.96.0";
 var VSCODE_SIDECAR_TARGETS = {
@@ -6544,8 +6625,8 @@ export const window = {
 var VSCODE_STUB_PATH = "test/vscode.stub.ts";
 function mapVscodeToStub(projectRoot, testRunner) {
   const [file, anchor, mapping] = testRunner === "jest" ? ["jest.config.cts", "testEnvironment: 'node',", `moduleNameMapper: { '^vscode$': '<rootDir>/${VSCODE_STUB_PATH}' },`] : ["vitest.config.mts", "environment: 'node',", `alias: { vscode: \`\${import.meta.dirname}/${VSCODE_STUB_PATH}\` },`];
-  const path = (0, import_node_path30.join)(projectRoot, file);
-  const content = fileExists(path) ? (0, import_node_fs28.readFileSync)(path, "utf8") : "";
+  const path = (0, import_node_path32.join)(projectRoot, file);
+  const content = fileExists(path) ? (0, import_node_fs29.readFileSync)(path, "utf8") : "";
   const line = content.split("\n").find((candidate) => candidate.trim() === anchor);
   if (line === void 0) {
     throw new Error(`${file} has no "${anchor}" line to map the vscode module after; map 'vscode' to ${VSCODE_STUB_PATH} by hand.`);
@@ -6565,11 +6646,11 @@ function ensureVscodeToolchain(workspaceRoot) {
   }
 }
 function defaultPublisher(workspaceRoot) {
-  const { name } = readJson((0, import_node_path30.join)(workspaceRoot, "package.json"));
+  const { name } = readJson((0, import_node_path32.join)(workspaceRoot, "package.json"));
   return (name ?? "publisher").replace(/^@/, "").split("/", 1)[0];
 }
 function reshapeManifest(projectRoot, name, publisher) {
-  const manifestPath = (0, import_node_path30.join)(projectRoot, "package.json");
+  const manifestPath = (0, import_node_path32.join)(projectRoot, "package.json");
   const manifest = readJson(manifestPath);
   const { nx = {}, ...rest } = manifest;
   const targets = { ...nx.targets };
@@ -6633,11 +6714,11 @@ function vscodeExtensionPublishTarget(name, sidecar) {
   };
 }
 function addDebugLaunch(workspaceRoot, name) {
-  const file = (0, import_node_fs28.readdirSync)(workspaceRoot).find((entry) => entry.endsWith(".code-workspace"));
+  const file = (0, import_node_fs29.readdirSync)(workspaceRoot).find((entry) => entry.endsWith(".code-workspace"));
   if (file === void 0) {
     return;
   }
-  const path = (0, import_node_path30.join)(workspaceRoot, file);
+  const path = (0, import_node_path32.join)(workspaceRoot, file);
   const workspace = readCodeWorkspace(path) ?? {};
   const folder = `\${workspaceFolder:${workspace.folders?.[0]?.name ?? file.replace(/\.code-workspace$/, "")}}`;
   const taskLabel = `${name}: build (development)`;
@@ -6670,39 +6751,39 @@ function addDebugLaunch(workspaceRoot, name) {
   );
 }
 function refreshVscodeExtensionScript(workspaceRoot) {
-  const apps = (0, import_node_path30.join)(workspaceRoot, "apps");
+  const apps = (0, import_node_path32.join)(workspaceRoot, "apps");
   let entries;
   try {
-    entries = (0, import_node_fs28.readdirSync)(apps);
+    entries = (0, import_node_fs29.readdirSync)(apps);
   } catch {
     return false;
   }
   const hasExtension = entries.some((entry) => {
-    const manifestPath = (0, import_node_path30.join)(apps, entry, "package.json");
+    const manifestPath = (0, import_node_path32.join)(apps, entry, "package.json");
     if (!fileExists(manifestPath)) {
       return false;
     }
     const tags = readJson(manifestPath).nx?.tags ?? [];
     return tags.includes(VSCODE_EXTENSION_TAG);
   });
-  const path = (0, import_node_path30.join)(workspaceRoot, VSCODE_EXTENSION_SCRIPT_PATH);
-  if (!hasExtension || fileExists(path) && (0, import_node_fs28.readFileSync)(path, "utf8") === VSCODE_EXTENSION_SCRIPT) {
+  const path = (0, import_node_path32.join)(workspaceRoot, VSCODE_EXTENSION_SCRIPT_PATH);
+  if (!hasExtension || fileExists(path) && (0, import_node_fs29.readFileSync)(path, "utf8") === VSCODE_EXTENSION_SCRIPT) {
     return false;
   }
   writeFileEnsured(path, VSCODE_EXTENSION_SCRIPT);
   return true;
 }
 function pinVscodeExtensionProjectNames(workspaceRoot) {
-  const apps = (0, import_node_path30.join)(workspaceRoot, "apps");
+  const apps = (0, import_node_path32.join)(workspaceRoot, "apps");
   let entries;
   try {
-    entries = (0, import_node_fs28.readdirSync)(apps);
+    entries = (0, import_node_fs29.readdirSync)(apps);
   } catch {
     return [];
   }
   const updated = [];
   for (const entry of entries) {
-    const manifestPath = (0, import_node_path30.join)(apps, entry, "package.json");
+    const manifestPath = (0, import_node_path32.join)(apps, entry, "package.json");
     if (!fileExists(manifestPath)) {
       continue;
     }
@@ -6722,22 +6803,22 @@ function refreshLockFile(workspaceRoot, name) {
 }
 function addVscodeExtension(workspaceRoot, name, stack, options = {}) {
   const { sidecar } = options;
-  if (sidecar !== void 0 && !fileExists((0, import_node_path30.join)(workspaceRoot, "apps", sidecar, "project.json"))) {
+  if (sidecar !== void 0 && !fileExists((0, import_node_path32.join)(workspaceRoot, "apps", sidecar, "project.json"))) {
     throw new Error(`--sidecar ${sidecar}: no Go app at apps/${sidecar}. Add it first with \`mnci add go-app ${sidecar}\`.`);
   }
   runNodeApp(workspaceRoot, name, stack, "none");
   ensureVscodeToolchain(workspaceRoot);
-  const projectRoot = (0, import_node_path30.join)(workspaceRoot, "apps", name);
+  const projectRoot = (0, import_node_path32.join)(workspaceRoot, "apps", name);
   reshapeManifest(projectRoot, name, options.publisher ?? defaultPublisher(workspaceRoot));
-  addVscodeTypes((0, import_node_path30.join)(projectRoot, "tsconfig.app.json"));
-  addVscodeTypes((0, import_node_path30.join)(projectRoot, "tsconfig.spec.json"));
-  writeFileEnsured((0, import_node_path30.join)(projectRoot, "src/main.ts"), vscodeExtensionMain(name));
-  writeFileEnsured((0, import_node_path30.join)(projectRoot, "src/main.spec.ts"), vscodeExtensionMainSpec(name));
-  writeFileEnsured((0, import_node_path30.join)(projectRoot, VSCODE_STUB_PATH), VSCODE_STUB);
+  addVscodeTypes((0, import_node_path32.join)(projectRoot, "tsconfig.app.json"));
+  addVscodeTypes((0, import_node_path32.join)(projectRoot, "tsconfig.spec.json"));
+  writeFileEnsured((0, import_node_path32.join)(projectRoot, "src/main.ts"), vscodeExtensionMain(name));
+  writeFileEnsured((0, import_node_path32.join)(projectRoot, "src/main.spec.ts"), vscodeExtensionMainSpec(name));
+  writeFileEnsured((0, import_node_path32.join)(projectRoot, VSCODE_STUB_PATH), VSCODE_STUB);
   mapVscodeToStub(projectRoot, stack.testRunner);
-  writeFileEnsured((0, import_node_path30.join)(projectRoot, ".vscodeignore"), VSCODE_IGNORE);
-  writeFileEnsured((0, import_node_path30.join)(workspaceRoot, VSCODE_EXTENSION_SCRIPT_PATH), VSCODE_EXTENSION_SCRIPT);
-  addNxTargets((0, import_node_path30.join)(projectRoot, "package.json"), {
+  writeFileEnsured((0, import_node_path32.join)(projectRoot, ".vscodeignore"), VSCODE_IGNORE);
+  writeFileEnsured((0, import_node_path32.join)(workspaceRoot, VSCODE_EXTENSION_SCRIPT_PATH), VSCODE_EXTENSION_SCRIPT);
+  addNxTargets((0, import_node_path32.join)(projectRoot, "package.json"), {
     "package": vscodeExtensionPackageTarget(name, sidecar),
     "nx-release-publish": vscodeExtensionPublishTarget(name, sidecar)
   });
@@ -6748,12 +6829,12 @@ function addVscodeExtension(workspaceRoot, name, stack, options = {}) {
 }
 
 // src/dependency-management/install-dependencies.use-case.ts
-var import_node_fs30 = require("fs");
-var import_node_path32 = require("path");
+var import_node_fs31 = require("fs");
+var import_node_path34 = require("path");
 
 // src/dependency-management/manifest.repository.ts
-var import_node_fs29 = require("fs");
-var import_node_path31 = require("path");
+var import_node_fs30 = require("fs");
+var import_node_path33 = require("path");
 var ECOSYSTEMS = ["npm", "pip", "pub", "nuget", "go"];
 var ROOT_LABEL = "(root)";
 var MANIFEST_GLOBS = {
@@ -6786,23 +6867,23 @@ function projectOf(manifestRelativePath) {
 }
 function hasEcosystem(workspaceRoot, ecosystem) {
   if (ecosystem === "go") {
-    return fileExists((0, import_node_path31.join)(workspaceRoot, "go.mod"));
+    return fileExists((0, import_node_path33.join)(workspaceRoot, "go.mod"));
   }
   if (ecosystem === "nuget") {
-    return (0, import_node_fs29.globSync)(MANIFEST_GLOBS.nuget, { cwd: workspaceRoot }).length > 0;
+    return (0, import_node_fs30.globSync)(MANIFEST_GLOBS.nuget, { cwd: workspaceRoot }).length > 0;
   }
   const rootMarker = {
     npm: "package.json",
     pip: "requirements-dev.txt",
     pub: "pubspec.yaml"
   };
-  return fileExists((0, import_node_path31.join)(workspaceRoot, rootMarker[ecosystem])) || (0, import_node_fs29.globSync)(MANIFEST_GLOBS[ecosystem], { cwd: workspaceRoot }).length > 0;
+  return fileExists((0, import_node_path33.join)(workspaceRoot, rootMarker[ecosystem])) || (0, import_node_fs30.globSync)(MANIFEST_GLOBS[ecosystem], { cwd: workspaceRoot }).length > 0;
 }
 function collectNpm(workspaceRoot) {
   const sites = [];
-  const relativePaths = ["package.json", ...(0, import_node_fs29.globSync)(MANIFEST_GLOBS.npm, { cwd: workspaceRoot })];
+  const relativePaths = ["package.json", ...(0, import_node_fs30.globSync)(MANIFEST_GLOBS.npm, { cwd: workspaceRoot })];
   for (const relativePath of relativePaths) {
-    const manifestPath = (0, import_node_path31.join)(workspaceRoot, relativePath);
+    const manifestPath = (0, import_node_path33.join)(workspaceRoot, relativePath);
     try {
       const manifest = readJson(manifestPath);
       sites.push(...npmManifestSites(manifest, relativePath, manifestPath));
@@ -6863,17 +6944,17 @@ function collectPip(workspaceRoot) {
       name: parsed.name,
       ecosystem: "pip",
       project: projectOf(relativePath),
-      manifestPath: (0, import_node_path31.join)(workspaceRoot, relativePath),
+      manifestPath: (0, import_node_path33.join)(workspaceRoot, relativePath),
       section,
       spec: parsed.spec,
       rewritable: parsed.rewritable && parsed.spec !== ""
     });
   };
-  const pyprojectPaths = (0, import_node_fs29.globSync)(MANIFEST_GLOBS.pip, { cwd: workspaceRoot });
+  const pyprojectPaths = (0, import_node_fs30.globSync)(MANIFEST_GLOBS.pip, { cwd: workspaceRoot });
   for (const relativePath of pyprojectPaths) {
     let content;
     try {
-      content = (0, import_node_fs29.readFileSync)((0, import_node_path31.join)(workspaceRoot, relativePath), "utf8");
+      content = (0, import_node_fs30.readFileSync)((0, import_node_path33.join)(workspaceRoot, relativePath), "utf8");
     } catch {
       continue;
     }
@@ -6884,14 +6965,14 @@ function collectPip(workspaceRoot) {
   }
   const requirementsPaths = [
     "requirements-dev.txt",
-    ...(0, import_node_fs29.globSync)("apps/*/requirements.txt", { cwd: workspaceRoot })
+    ...(0, import_node_fs30.globSync)("apps/*/requirements.txt", { cwd: workspaceRoot })
   ];
   for (const relativePath of requirementsPaths) {
-    if (!fileExists((0, import_node_path31.join)(workspaceRoot, relativePath))) {
+    if (!fileExists((0, import_node_path33.join)(workspaceRoot, relativePath))) {
       continue;
     }
     const section = relativePath === "requirements-dev.txt" ? "devDep" : "dep";
-    const lines = (0, import_node_fs29.readFileSync)((0, import_node_path31.join)(workspaceRoot, relativePath), "utf8").split(/\r?\n/);
+    const lines = (0, import_node_fs30.readFileSync)((0, import_node_path33.join)(workspaceRoot, relativePath), "utf8").split(/\r?\n/);
     for (const line of lines) {
       push(relativePath, section, line);
     }
@@ -6929,11 +7010,11 @@ function pyprojectDependencies(content) {
 }
 function collectPub(workspaceRoot) {
   const sites = [];
-  const pubspecPaths = (0, import_node_fs29.globSync)(MANIFEST_GLOBS.pub, { cwd: workspaceRoot });
+  const pubspecPaths = (0, import_node_fs30.globSync)(MANIFEST_GLOBS.pub, { cwd: workspaceRoot });
   for (const relativePath of pubspecPaths) {
     let content;
     try {
-      content = (0, import_node_fs29.readFileSync)((0, import_node_path31.join)(workspaceRoot, relativePath), "utf8");
+      content = (0, import_node_fs30.readFileSync)((0, import_node_path33.join)(workspaceRoot, relativePath), "utf8");
     } catch {
       continue;
     }
@@ -6943,7 +7024,7 @@ function collectPub(workspaceRoot) {
           name: entry.name,
           ecosystem: "pub",
           project: projectOf(relativePath),
-          manifestPath: (0, import_node_path31.join)(workspaceRoot, relativePath),
+          manifestPath: (0, import_node_path33.join)(workspaceRoot, relativePath),
           section: block === "dependencies" ? "dep" : "devDep",
           spec: entry.spec,
           rewritable: entry.spec !== ""
@@ -6993,11 +7074,11 @@ function stripQuotes(value) {
 }
 function collectNuget(workspaceRoot) {
   const sites = [];
-  const csprojPaths = (0, import_node_fs29.globSync)(MANIFEST_GLOBS.nuget, { cwd: workspaceRoot });
+  const csprojPaths = (0, import_node_fs30.globSync)(MANIFEST_GLOBS.nuget, { cwd: workspaceRoot });
   for (const relativePath of csprojPaths) {
     let content;
     try {
-      content = (0, import_node_fs29.readFileSync)((0, import_node_path31.join)(workspaceRoot, relativePath), "utf8");
+      content = (0, import_node_fs30.readFileSync)((0, import_node_path33.join)(workspaceRoot, relativePath), "utf8");
     } catch {
       continue;
     }
@@ -7006,7 +7087,7 @@ function collectNuget(workspaceRoot) {
         name: entry.name,
         ecosystem: "nuget",
         project: projectOf(relativePath),
-        manifestPath: (0, import_node_path31.join)(workspaceRoot, relativePath),
+        manifestPath: (0, import_node_path33.join)(workspaceRoot, relativePath),
         section: "dep",
         spec: entry.spec,
         // A plain SemVer string is rewritable; an MSBuild property reference
@@ -7031,13 +7112,13 @@ function csprojPackageReferences(content) {
   return entries;
 }
 function collectGo(workspaceRoot) {
-  const manifestPath = (0, import_node_path31.join)(workspaceRoot, "go.mod");
+  const manifestPath = (0, import_node_path33.join)(workspaceRoot, "go.mod");
   if (!fileExists(manifestPath)) {
     return [];
   }
   let content;
   try {
-    content = (0, import_node_fs29.readFileSync)(manifestPath, "utf8");
+    content = (0, import_node_fs30.readFileSync)(manifestPath, "utf8");
   } catch {
     return [];
   }
@@ -7086,7 +7167,7 @@ var PROJECT_GLOBS = {
 function locateProjects(workspaceRoot) {
   const locations = [];
   for (const ecosystem of ECOSYSTEMS) {
-    const relativePaths = (0, import_node_fs29.globSync)(PROJECT_GLOBS[ecosystem], { cwd: workspaceRoot });
+    const relativePaths = (0, import_node_fs30.globSync)(PROJECT_GLOBS[ecosystem], { cwd: workspaceRoot });
     for (const relativePath of relativePaths) {
       const posix = toPosix(relativePath);
       const dir = posix.slice(0, posix.lastIndexOf("/"));
@@ -7094,7 +7175,7 @@ function locateProjects(workspaceRoot) {
         ecosystem,
         dir,
         name: dir.slice(dir.lastIndexOf("/") + 1),
-        manifestPath: (0, import_node_path31.join)(workspaceRoot, relativePath)
+        manifestPath: (0, import_node_path33.join)(workspaceRoot, relativePath)
       });
     }
   }
@@ -7115,7 +7196,7 @@ function rewriteSpec(site, spec) {
     writeFileEnsured(site.manifestPath, toJson(manifest));
     return true;
   }
-  const before = (0, import_node_fs29.readFileSync)(site.manifestPath, "utf8");
+  const before = (0, import_node_fs30.readFileSync)(site.manifestPath, "utf8");
   const after = (() => {
     switch (site.ecosystem) {
       case "pip": {
@@ -7206,13 +7287,13 @@ function escapeForRegex(value) {
 function isWorkspaceProject(workspaceRoot, name) {
   const short = name.includes("/") ? name.split("/").at(-1) : name;
   return ["apps", "libs", "packages"].some(
-    (directory) => fileExists((0, import_node_path31.join)(workspaceRoot, directory, short ?? name, "package.json"))
+    (directory) => fileExists((0, import_node_path33.join)(workspaceRoot, directory, short ?? name, "package.json"))
   );
 }
 function isAliasedInstall(workspaceRoot, name) {
   try {
     const installed = readJson(
-      (0, import_node_path31.join)(workspaceRoot, "node_modules", name, "package.json")
+      (0, import_node_path33.join)(workspaceRoot, "node_modules", name, "package.json")
     );
     return installed.name !== void 0 && installed.name !== name;
   } catch {
@@ -7223,14 +7304,14 @@ function resolvedVersion(workspaceRoot, ecosystem, name) {
   if (ecosystem === "npm") {
     try {
       return readJson(
-        (0, import_node_path31.join)(workspaceRoot, "node_modules", name, "package.json")
+        (0, import_node_path33.join)(workspaceRoot, "node_modules", name, "package.json")
       ).version;
     } catch {
       return void 0;
     }
   }
   if (ecosystem === "pub") {
-    const lockPath = (0, import_node_path31.join)(workspaceRoot, "pubspec.lock");
+    const lockPath = (0, import_node_path33.join)(workspaceRoot, "pubspec.lock");
     if (!fileExists(lockPath)) {
       return void 0;
     }
@@ -7238,7 +7319,7 @@ function resolvedVersion(workspaceRoot, ecosystem, name) {
       const match = new RegExp(
         String.raw`^\s{2}${escapeForRegex(name)}:[^]*?^\s+version:\s*["']?([^"'\s]+)`,
         "m"
-      ).exec((0, import_node_fs29.readFileSync)(lockPath, "utf8"));
+      ).exec((0, import_node_fs30.readFileSync)(lockPath, "utf8"));
       return match?.[1];
     } catch {
       return void 0;
@@ -7304,7 +7385,7 @@ function resolveTarget(locations, target) {
   return byName[0];
 }
 function installInto(workspaceRoot, location, packages, saveDev) {
-  const projectDir = (0, import_node_path32.join)(workspaceRoot, location.dir);
+  const projectDir = (0, import_node_path34.join)(workspaceRoot, location.dir);
   switch (location.ecosystem) {
     case "npm": {
       const flags = saveDev ? ["--save-dev"] : [];
@@ -7357,7 +7438,7 @@ function installInto(workspaceRoot, location, packages, saveDev) {
 function addPythonDependency(manifestPath, specifier) {
   let content;
   try {
-    content = (0, import_node_fs30.readFileSync)(manifestPath, "utf8");
+    content = (0, import_node_fs31.readFileSync)(manifestPath, "utf8");
   } catch {
     logger.warn(`Could not read ${manifestPath} \u2014 skipped ${specifier}`);
     return;
@@ -7386,7 +7467,7 @@ function installEverything(workspaceRoot, only) {
 }
 function ecosystemPresent(workspaceRoot, ecosystem) {
   if (ecosystem === "go") {
-    return fileExists((0, import_node_path32.join)(workspaceRoot, "go.work")) || fileExists((0, import_node_path32.join)(workspaceRoot, "go.mod"));
+    return fileExists((0, import_node_path34.join)(workspaceRoot, "go.work")) || fileExists((0, import_node_path34.join)(workspaceRoot, "go.mod"));
   }
   return hasEcosystem(workspaceRoot, ecosystem);
 }
@@ -7405,7 +7486,7 @@ function splitAtLast(value, separator) {
 }
 
 // src/dependency-management/sync-dependencies.use-case.ts
-var import_node_path33 = require("path");
+var import_node_path35 = require("path");
 
 // src/dependency-management/semver.algorithm.ts
 var UPDATE_KINDS = ["patch", "minor", "major", "non-semver"];
@@ -7582,7 +7663,7 @@ function describe(finding) {
   return `${finding.name} \u2192 ${finding.target} (${finding.reason}); disagreeing: ${sites}`;
 }
 function runSync(workspaceRoot, options) {
-  if (!fileExists((0, import_node_path33.join)(workspaceRoot, "nx.json"))) {
+  if (!fileExists((0, import_node_path35.join)(workspaceRoot, "nx.json"))) {
     throw new Error(
       `No nx.json found in ${workspaceRoot} \u2014 run 'mnci sync' from the workspace root.`
     );
@@ -7632,7 +7713,7 @@ function runSync(workspaceRoot, options) {
 }
 
 // src/dependency-management/update-dependencies.use-case.ts
-var import_node_path34 = require("path");
+var import_node_path36 = require("path");
 var import_prompts2 = require("@inquirer/prompts");
 
 // src/dependency-management/registry.client.ts
@@ -7915,7 +7996,7 @@ function reinstall(workspaceRoot, ecosystems) {
 function hasPythonInstallScript(workspaceRoot) {
   try {
     const manifest = readJson(
-      (0, import_node_path34.join)(workspaceRoot, "package.json")
+      (0, import_node_path36.join)(workspaceRoot, "package.json")
     );
     return manifest.scripts?.["python:install"] !== void 0;
   } catch {
@@ -7931,7 +8012,7 @@ function applyGoUpdates(workspaceRoot, entries) {
   }
 }
 async function runUp(workspaceRoot, options) {
-  if (!fileExists((0, import_node_path34.join)(workspaceRoot, "nx.json"))) {
+  if (!fileExists((0, import_node_path36.join)(workspaceRoot, "nx.json"))) {
     throw new Error(`No nx.json found in ${workspaceRoot} \u2014 run 'mnci up' from the workspace root.`);
   }
   const ecosystems = resolveEcosystems(options.ecosystem);
@@ -8009,7 +8090,7 @@ var PROJECT_KINDS = [
 var EMPTY_KINDS = /* @__PURE__ */ new Set(["npm-lib", "internal-lib", "react-lib", "react-internal-lib", "node-function-app"]);
 async function runAdd(kind, name, options) {
   const workspaceRoot = process.cwd();
-  if (!fileExists((0, import_node_path35.join)(workspaceRoot, "nx.json"))) {
+  if (!fileExists((0, import_node_path37.join)(workspaceRoot, "nx.json"))) {
     throw new Error("No nx.json found here. Run `add` from the workspace root.");
   }
   const stack = readWorkspaceStack(workspaceRoot);
@@ -8094,8 +8175,8 @@ async function runAdd(kind, name, options) {
         ],
         workspaceRoot
       );
-      markPrivate((0, import_node_path35.join)(workspaceRoot, "libs", resolvedName, "package.json"));
-      renameScaffoldPlaceholder((0, import_node_path35.join)(workspaceRoot, "libs", resolvedName), resolvedName, options.empty === true);
+      markPrivate((0, import_node_path37.join)(workspaceRoot, "libs", resolvedName, "package.json"));
+      renameScaffoldPlaceholder((0, import_node_path37.join)(workspaceRoot, "libs", resolvedName), resolvedName, options.empty === true);
       removeGeneratedEslintConfig(workspaceRoot, `libs/${resolvedName}`);
       registerProjectCommands(workspaceRoot, resolvedName, { build: true });
       break;
@@ -8191,7 +8272,7 @@ async function runAdd(kind, name, options) {
 }
 function readWorkspaceStack(workspaceRoot) {
   const nxJson = readJson(
-    (0, import_node_path35.join)(workspaceRoot, "nx.json")
+    (0, import_node_path37.join)(workspaceRoot, "nx.json")
   );
   const stack = nxJson.mnci?.stack;
   return {
@@ -8280,11 +8361,11 @@ function spawnProject(workspaceRoot, project, target, onLine) {
 }
 
 // src/dev-servers/startable-projects.use-case.ts
-var import_node_path36 = require("path");
+var import_node_path38 = require("path");
 var START_SUFFIX = ":start";
 var NX_RUN = /\bnx run [^\s:]+:(\S+)/;
 function listStartableProjects(workspaceRoot) {
-  const manifestPath = (0, import_node_path36.join)(workspaceRoot, "package.json");
+  const manifestPath = (0, import_node_path38.join)(workspaceRoot, "package.json");
   if (!fileExists(manifestPath)) {
     return [];
   }
@@ -8357,14 +8438,43 @@ async function runDev(workspaceRoot, named, options = {}, dependencies = {}) {
 
 // src/workspace-diagnostics/check-invariants.use-case.ts
 var import_node_child_process2 = require("child_process");
-var import_node_fs32 = require("fs");
-var import_node_path38 = require("path");
+var import_node_fs33 = require("fs");
+var import_node_path40 = require("path");
 
-// src/workspace-diagnostics/locate-stranded-release-tags.use-case.ts
-var import_node_fs31 = require("fs");
-var import_node_path37 = require("path");
+// src/workspace-diagnostics/check-react-app-output.use-case.ts
+function checkReactAppOutput(workspaceRoot) {
+  const apps = findReactAppsSharingOutput(workspaceRoot);
+  if (apps.length === 0) {
+    return void 0;
+  }
+  return {
+    check: "React apps' tsc output is not the folder Vite builds into",
+    ok: false,
+    detail: `${apps.join(", ")}: tsconfig.app.json writes to the same folder as the Vite bundle, which Vite empties on each build, so build and typecheck running together fail intermittently with TS6305`,
+    remedy: "run `mnci upgrade`, which moves tsc output to out-tsc/app"
+  };
+}
+
+// src/release-tag-lineage/create-baseline-tags.use-case.ts
+function createBaselineTags(repositoryRoot, stranded) {
+  const result = { created: [], existing: [], failed: [] };
+  for (const entry of stranded) {
+    const present = runCapture("git", ["rev-parse", "--verify", "--quiet", `refs/tags/${entry.newTag}`], repositoryRoot);
+    if (present.status === 0) {
+      result.existing.push(entry.newTag);
+      continue;
+    }
+    const made = runCapture("git", ["tag", entry.newTag, `${entry.oldTag}^{commit}`], repositoryRoot);
+    (made.status === 0 ? result.created : result.failed).push(entry.newTag);
+  }
+  return result;
+}
 
-// src/workspace-diagnostics/stranded-release-tags.algorithm.ts
+// src/release-tag-lineage/locate-stranded-release-tags.use-case.ts
+var import_node_fs32 = require("fs");
+var import_node_path39 = require("path");
+
+// src/release-tag-lineage/stranded-release-tags.algorithm.ts
 function compareVersions2(left, right) {
   const a = left.split(".").map(Number);
   const b = right.split(".").map(Number);
@@ -8389,7 +8499,7 @@ function findStrandedReleaseTags(projects, tags) {
   return stranded;
 }
 
-// src/workspace-diagnostics/locate-stranded-release-tags.use-case.ts
+// src/release-tag-lineage/locate-stranded-release-tags.use-case.ts
 var MNCI_TAG_PATTERN = "{projectName}@{version}";
 function locateStrandedReleaseTags(workspaceRoot, tagPattern) {
   if (tagPattern !== void 0 && tagPattern !== MNCI_TAG_PATTERN) {
@@ -8399,18 +8509,29 @@ function locateStrandedReleaseTags(workspaceRoot, tagPattern) {
   if (listed.status !== 0) {
     return [];
   }
-  const projects = (0, import_node_fs31.globSync)("{apps,libs,packages}/*/package.json", { cwd: workspaceRoot }).map((path) => readJson((0, import_node_path37.join)(workspaceRoot, path))).filter((manifest) => manifest.private !== true && manifest.name !== void 0).map((manifest) => manifest.name);
+  const projects = (0, import_node_fs32.globSync)("{apps,libs,packages}/*/package.json", { cwd: workspaceRoot }).map((path) => readJson((0, import_node_path39.join)(workspaceRoot, path))).filter((manifest) => manifest.private !== true && manifest.name !== void 0).map((manifest) => manifest.name);
   return findStrandedReleaseTags(projects, listed.stdout.split(/\r?\n/).filter(Boolean));
 }
 
+// src/workspace-diagnostics/check-release-tags-resolve.use-case.ts
+function checkReleaseTagsResolve(workspaceRoot, nxJson) {
+  const stranded = locateStrandedReleaseTags(workspaceRoot, nxJson.release?.releaseTag?.pattern);
+  return {
+    check: "release tags resolve under each project's current name",
+    ok: stranded.length === 0,
+    detail: `${stranded.map((entry) => `${entry.project} has only ${entry.oldTag}`).join("; ")} - nx release finds no tag under the new name and would release from the disk version, a downgrade`,
+    remedy: `run \`mnci adopt --tags\` to create the baseline tag for each (${stranded.map((entry) => entry.newTag).join(", ")}) on the commit of its old tag, then push the tags`
+  };
+}
+
 // src/workspace-diagnostics/check-invariants.use-case.ts
 var SUPPORTED_ESLINT_MAJOR = ESLINT_VERSION.replace(/^\D*/, "").split(".", 1)[0];
 function toPosix2(path) {
   return path.replaceAll("\\", "/");
 }
 function checkEslintConfigs(workspaceRoot) {
-  const rootConfigs = (0, import_node_fs32.globSync)("eslint.config.{js,mjs,cjs,ts,mts,cts}", { cwd: workspaceRoot });
-  const projectConfigs = (0, import_node_fs32.globSync)("{apps,libs,packages}/*/eslint.config.{js,mjs,cjs,ts,mts,cts}", {
+  const rootConfigs = (0, import_node_fs33.globSync)("eslint.config.{js,mjs,cjs,ts,mts,cts}", { cwd: workspaceRoot });
+  const projectConfigs = (0, import_node_fs33.globSync)("{apps,libs,packages}/*/eslint.config.{js,mjs,cjs,ts,mts,cts}", {
     cwd: workspaceRoot
   }).map((config) => toPosix2(config));
   return [
@@ -8430,10 +8551,10 @@ function checkEslintConfigs(workspaceRoot) {
   ];
 }
 function checkEslintEntryPointReachesTheRules(workspaceRoot) {
-  const rules = (0, import_node_path38.join)(workspaceRoot, ESLINT_MNCI_FILENAME);
-  if (!(0, import_node_fs32.existsSync)(rules)) return [];
-  const entryPoint = (0, import_node_path38.join)(workspaceRoot, ESLINT_USER_FILENAME);
-  const source = (0, import_node_fs32.existsSync)(entryPoint) ? (0, import_node_fs32.readFileSync)(entryPoint, "utf8") : "";
+  const rules = (0, import_node_path40.join)(workspaceRoot, ESLINT_MNCI_FILENAME);
+  if (!(0, import_node_fs33.existsSync)(rules)) return [];
+  const entryPoint = (0, import_node_path40.join)(workspaceRoot, ESLINT_USER_FILENAME);
+  const source = (0, import_node_fs33.existsSync)(entryPoint) ? (0, import_node_fs33.readFileSync)(entryPoint, "utf8") : "";
   return [
     {
       check: `${ESLINT_USER_FILENAME} imports the mnci rules`,
@@ -8446,7 +8567,7 @@ function checkEslintEntryPointReachesTheRules(workspaceRoot) {
 function declaredDevDependencies(workspaceRoot) {
   try {
     const manifest = readJson(
-      (0, import_node_path38.join)(workspaceRoot, "package.json")
+      (0, import_node_path40.join)(workspaceRoot, "package.json")
     );
     return manifest.devDependencies ?? {};
   } catch {
@@ -8454,7 +8575,7 @@ function declaredDevDependencies(workspaceRoot) {
   }
 }
 function checkNoRetiredFormatter(workspaceRoot) {
-  const files = RETIRED_FORMATTER_FILES.filter((file) => fileExists((0, import_node_path38.join)(workspaceRoot, file)));
+  const files = RETIRED_FORMATTER_FILES.filter((file) => fileExists((0, import_node_path40.join)(workspaceRoot, file)));
   const declared = ["prettier", "eslint-config-prettier", "oxlint", "oxfmt", "@mnci/oxlint-config"].filter((name) => declaredDevDependencies(workspaceRoot)[name] !== void 0);
   const stale = [...files, ...declared];
   if (stale.length === 0) {
@@ -8480,7 +8601,7 @@ function checkEslintPlugin(nxJson) {
   };
 }
 function checkResolvedEslint(workspaceRoot) {
-  const manifestPath = (0, import_node_path38.join)(workspaceRoot, "node_modules/eslint/package.json");
+  const manifestPath = (0, import_node_path40.join)(workspaceRoot, "node_modules/eslint/package.json");
   if (!fileExists(manifestPath)) {
     return void 0;
   }
@@ -8498,11 +8619,11 @@ function checkResolvedEslint(workspaceRoot) {
   }
 }
 function checkNpmrc(workspaceRoot, registry, scope) {
-  const npmrcPath = (0, import_node_path38.join)(workspaceRoot, ".npmrc");
+  const npmrcPath = (0, import_node_path40.join)(workspaceRoot, ".npmrc");
   if (!registry || !fileExists(npmrcPath)) {
     return void 0;
   }
-  const npmrc = (0, import_node_fs32.readFileSync)(npmrcPath, "utf8");
+  const npmrc = (0, import_node_fs33.readFileSync)(npmrcPath, "utf8");
   if (registry.kind === "npm") {
     return {
       check: ".npmrc authenticates the public registry",
@@ -8519,11 +8640,11 @@ function checkNpmrc(workspaceRoot, registry, scope) {
   };
 }
 function checkNpmrcCredentialResolves(workspaceRoot, environment = process.env) {
-  const npmrcPath = (0, import_node_path38.join)(workspaceRoot, ".npmrc");
+  const npmrcPath = (0, import_node_path40.join)(workspaceRoot, ".npmrc");
   if (!fileExists(npmrcPath)) {
     return void 0;
   }
-  const npmrc = (0, import_node_fs32.readFileSync)(npmrcPath, "utf8");
+  const npmrc = (0, import_node_fs33.readFileSync)(npmrcPath, "utf8");
   const credentials = npmrc.split("\n").filter((line) => !line.trimStart().startsWith(";") && !line.trimStart().startsWith("#")).filter((line) => /(?:_authToken|_password|_auth)\s*=/u.test(line));
   const referenced = [
     ...new Set(
@@ -8547,13 +8668,13 @@ function checkNpmrcCredentialResolves(workspaceRoot, environment = process.env)
   };
 }
 function checkNpmAuthMatchesPipeline(workspaceRoot, registry) {
-  const npmrcPath = (0, import_node_path38.join)(workspaceRoot, ".npmrc");
-  const pipelinePath = (0, import_node_path38.join)(workspaceRoot, "azure-pipelines.yml");
+  const npmrcPath = (0, import_node_path40.join)(workspaceRoot, ".npmrc");
+  const pipelinePath = (0, import_node_path40.join)(workspaceRoot, "azure-pipelines.yml");
   if (registry?.kind !== "azure-artifacts" || !fileExists(npmrcPath) || !fileExists(pipelinePath)) {
     return void 0;
   }
-  const holdsCredentials = (0, import_node_fs32.readFileSync)(npmrcPath, "utf8").split("\n").filter((line) => !line.trimStart().startsWith(";") && !line.trimStart().startsWith("#")).some((line) => /(?:_authToken|_password|_auth)\s*=/u.test(line));
-  const runsTask = (0, import_node_fs32.readFileSync)(pipelinePath, "utf8").includes("npmAuthenticate@0");
+  const holdsCredentials = (0, import_node_fs33.readFileSync)(npmrcPath, "utf8").split("\n").filter((line) => !line.trimStart().startsWith(";") && !line.trimStart().startsWith("#")).some((line) => /(?:_authToken|_password|_auth)\s*=/u.test(line));
+  const runsTask = (0, import_node_fs33.readFileSync)(pipelinePath, "utf8").includes("npmAuthenticate@0");
   if (!holdsCredentials && !runsTask) {
     return {
       check: "npm auth: .npmrc and azure-pipelines.yml agree",
@@ -8593,18 +8714,18 @@ function npmjsCredentialShape(credentials, environment) {
     check: "the credential bound for npmjs.org looks like an npm token",
     ok: false,
     detail: `\${${variable}} is set (${value.length} characters) but does not start with '${NPM_TOKEN_PREFIX}' and is not a legacy UUID token, so it is probably a credential for somewhere else \u2014 '${variable}' is a generic name that other tooling also sets, and inside this workspace it is sent to the PUBLIC registry. A write then fails as a 404 on the PUT, which reads like a missing package`,
-    remedy: `\`npm whoami\` to confirm \u2014 it is the only thing that separates a wrong token from an expired one. Then unset \`${variable}\` for local work, or set it to a real npm token`
+    remedy: `find where \`${variable}\` is set (shell profile, CI secret, another tool) and whether it is meant for npm. If it is not, unset \`${variable}\` for local work. If it is meant to be an npm token, check it with \`npm whoami\` run OUTSIDE this workspace (the project .npmrc would send it to the public registry from in here), or set it to a real npm token`
   };
 }
 function checkVersionActions(workspaceRoot) {
   const candidates = [
-    ...(0, import_node_fs32.globSync)("packages/*/pubspec.yaml", { cwd: workspaceRoot }),
-    ...(0, import_node_fs32.globSync)("packages/*/*.csproj", { cwd: workspaceRoot }),
-    ...(0, import_node_fs32.globSync)("python-packages/*/pyproject.toml", { cwd: workspaceRoot })
+    ...(0, import_node_fs33.globSync)("packages/*/pubspec.yaml", { cwd: workspaceRoot }),
+    ...(0, import_node_fs33.globSync)("packages/*/*.csproj", { cwd: workspaceRoot }),
+    ...(0, import_node_fs33.globSync)("python-packages/*/pyproject.toml", { cwd: workspaceRoot })
   ].map((manifest) => toPosix2(manifest));
   return candidates.flatMap((manifest) => {
     const projectRoot = manifest.slice(0, manifest.lastIndexOf("/"));
-    const projectJsonPath = (0, import_node_path38.join)(workspaceRoot, projectRoot, "project.json");
+    const projectJsonPath = (0, import_node_path40.join)(workspaceRoot, projectRoot, "project.json");
     let hasOverride = false;
     try {
       const projectJson = readJson(projectJsonPath);
@@ -8633,7 +8754,7 @@ function declaredTargets(workspaceRoot, projectRoot) {
   ]) {
     try {
       const targets = extract(
-        readJson((0, import_node_path38.join)(workspaceRoot, projectRoot, file))
+        readJson((0, import_node_path40.join)(workspaceRoot, projectRoot, file))
       );
       if (targets && typeof targets === "object") {
         sources.push({
@@ -8649,8 +8770,8 @@ function declaredTargets(workspaceRoot, projectRoot) {
 function checkTargetFilesExist(workspaceRoot) {
   const projectRoots = new Set(
     [
-      ...(0, import_node_fs32.globSync)("{apps,libs,packages}/*/project.json", { cwd: workspaceRoot }),
-      ...(0, import_node_fs32.globSync)("{apps,libs,packages}/*/package.json", { cwd: workspaceRoot })
+      ...(0, import_node_fs33.globSync)("{apps,libs,packages}/*/project.json", { cwd: workspaceRoot }),
+      ...(0, import_node_fs33.globSync)("{apps,libs,packages}/*/package.json", { cwd: workspaceRoot })
     ].map((manifest) => toPosix2(manifest).split("/").slice(0, 2).join("/"))
   );
   return [...projectRoots].flatMap(
@@ -8665,7 +8786,7 @@ function checkOneTargetsFiles(workspaceRoot, source, targetName, target) {
   return TARGET_FILE_OPTIONS.flatMap((option) => {
     const value = target?.options?.[option];
     const checkable = typeof value === "string" && !value.includes("{");
-    if (!checkable || fileExists((0, import_node_path38.join)(workspaceRoot, value))) {
+    if (!checkable || fileExists((0, import_node_path40.join)(workspaceRoot, value))) {
       return [];
     }
     return [
@@ -8704,15 +8825,15 @@ function checkGoPluginRegistered(workspaceRoot) {
   };
 }
 function checkGoWorkInSync(workspaceRoot) {
-  const goWorkPath = (0, import_node_path38.join)(workspaceRoot, "go.work");
+  const goWorkPath = (0, import_node_path40.join)(workspaceRoot, "go.work");
   if (!fileExists(goWorkPath)) {
     return void 0;
   }
-  const contents = (0, import_node_fs32.existsSync)(goWorkPath) ? (0, import_node_fs32.readFileSync)(goWorkPath, "utf8") : "";
+  const contents = (0, import_node_fs33.existsSync)(goWorkPath) ? (0, import_node_fs33.readFileSync)(goWorkPath, "utf8") : "";
   const blockEntries = Array.from(contents.matchAll(/(?:^|\n)\s*use\s+\(([^)]*)\)/g), (match) => match[1].split("\n")).flat();
   const singleEntries = Array.from(contents.matchAll(/(?:^|\n)\s*use\s+(\.\S+)/g), (match) => match[1]);
   const uses = [...blockEntries, ...singleEntries].map((entry) => entry.trim()).filter(Boolean);
-  const stale = uses.filter((entry) => !(0, import_node_fs32.existsSync)((0, import_node_path38.join)(workspaceRoot, entry, "go.mod")));
+  const stale = uses.filter((entry) => !(0, import_node_fs33.existsSync)((0, import_node_path40.join)(workspaceRoot, entry, "go.mod")));
   return {
     check: "every go.work `use` entry points to a module that still exists",
     ok: stale.length === 0,
@@ -8728,9 +8849,9 @@ function checkNativeApps(workspaceRoot) {
     { file: ".github/workflows/ci.yml", marker: "native (${{ matrix.os }})" },
     { file: "azure-pipelines.yml", marker: "- job: native" }
   ];
-  const findings = pipelines.filter(({ file }) => fileExists((0, import_node_path38.join)(workspaceRoot, file))).map(({ file, marker }) => ({
+  const findings = pipelines.filter(({ file }) => fileExists((0, import_node_path40.join)(workspaceRoot, file))).map(({ file, marker }) => ({
     check: `${file} builds the native apps on every OS`,
-    ok: (0, import_node_fs32.readFileSync)((0, import_node_path38.join)(workspaceRoot, file), "utf8").includes(marker),
+    ok: (0, import_node_fs33.readFileSync)((0, import_node_path40.join)(workspaceRoot, file), "utf8").includes(marker),
     detail: `${file} has no native job: CI would verify a cgo app on the one agent that cannot build it`,
     remedy: "run `mnci upgrade`"
   }));
@@ -8743,7 +8864,7 @@ function checkNativeApps(workspaceRoot) {
   return findings;
 }
 function checkNoRootRuntimeDependencies(workspaceRoot) {
-  const manifestPath = (0, import_node_path38.join)(workspaceRoot, "package.json");
+  const manifestPath = (0, import_node_path40.join)(workspaceRoot, "package.json");
   if (!fileExists(manifestPath)) {
     return void 0;
   }
@@ -8763,14 +8884,14 @@ function checkNoRootRuntimeDependencies(workspaceRoot) {
   };
 }
 function checkRollupSourceMaps(workspaceRoot) {
-  const configs = (0, import_node_fs32.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
+  const configs = (0, import_node_fs33.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
     cwd: workspaceRoot
   }).map((config) => toPosix2(config));
   return configs.flatMap((relativePath) => {
-    const configPath = (0, import_node_path38.join)(workspaceRoot, relativePath);
+    const configPath = (0, import_node_path40.join)(workspaceRoot, relativePath);
     let config;
     try {
-      config = (0, import_node_fs32.readFileSync)(configPath, "utf8");
+      config = (0, import_node_fs33.readFileSync)(configPath, "utf8");
     } catch {
       return [];
     }
@@ -8785,11 +8906,11 @@ function checkRollupSourceMaps(workspaceRoot) {
   });
 }
 function checkDeclarationSpecifiers(workspaceRoot) {
-  const configs = (0, import_node_fs32.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
+  const configs = (0, import_node_fs33.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
     cwd: workspaceRoot
   }).map((config) => toPosix2(config));
   return configs.flatMap((relativePath) => {
-    const configPath = (0, import_node_path38.join)(workspaceRoot, relativePath);
+    const configPath = (0, import_node_path40.join)(workspaceRoot, relativePath);
     if (!fileExists(configPath)) {
       return [];
     }
@@ -8804,7 +8925,7 @@ function checkDeclarationSpecifiers(workspaceRoot) {
           // `plugins` array (what @nx/react:library writes). For any other shape it would no-op, and
           // naming a command that silently does nothing is the failure mode the source-map check
           // above goes out of its way to avoid, so the remedy depends on the shape.
-          remedy: canAddDeclarationSpecifierPlugin((0, import_node_fs32.readFileSync)(configPath, "utf8")) ? "run `mnci upgrade`, which adds the plugin to the plugins array of withNx's second argument" : "add the plugin to withNx's second argument by hand (copy it from a freshly `mnci add npm-lib`'d project) \u2014 mnci does not recognise the shape of this config, so `mnci upgrade` cannot add it"
+          remedy: canAddDeclarationSpecifierPlugin((0, import_node_fs33.readFileSync)(configPath, "utf8")) ? "run `mnci upgrade`, which adds the plugin to the plugins array of withNx's second argument" : "add the plugin to withNx's second argument by hand (copy it from a freshly `mnci add npm-lib`'d project) \u2014 mnci does not recognise the shape of this config, so `mnci upgrade` cannot add it"
         }
       ];
     }
@@ -8820,8 +8941,8 @@ function checkDeclarationSpecifiers(workspaceRoot) {
 }
 function checkPipelinePhases(workspaceRoot) {
   const files = ["azure-pipelines.yml", ".github/workflows/ci.yml"];
-  return files.filter((file) => fileExists((0, import_node_path38.join)(workspaceRoot, file))).flatMap((file) => {
-    const { verifyActive, switchedOff } = inspectPipeline((0, import_node_fs32.readFileSync)((0, import_node_path38.join)(workspaceRoot, file), "utf8"));
+  return files.filter((file) => fileExists((0, import_node_path40.join)(workspaceRoot, file))).flatMap((file) => {
+    const { verifyActive, switchedOff } = inspectPipeline((0, import_node_fs33.readFileSync)((0, import_node_path40.join)(workspaceRoot, file), "utf8"));
     const verify = {
       check: `${file} runs the enforced verify phase`,
       ok: verifyActive,
@@ -8862,7 +8983,7 @@ function checkDependencyRangesNotPreserved(nxJson) {
   };
 }
 function checkLockfileHasNoLocalRegistry(workspaceRoot) {
-  if (!fileExists((0, import_node_path38.join)(workspaceRoot, "package-lock.json"))) {
+  if (!fileExists((0, import_node_path40.join)(workspaceRoot, "package-lock.json"))) {
     return void 0;
   }
   return {
@@ -8872,17 +8993,8 @@ function checkLockfileHasNoLocalRegistry(workspaceRoot) {
     remedy: "run `mnci upgrade`, which removes it, then commit package-lock.json"
   };
 }
-function checkReleaseTagsResolve(workspaceRoot, nxJson) {
-  const stranded = locateStrandedReleaseTags(workspaceRoot, nxJson.release?.releaseTag?.pattern);
-  return {
-    check: "release tags resolve under each project's current name",
-    ok: stranded.length === 0,
-    detail: `${stranded.map((entry) => `${entry.project} has only ${entry.oldTag}`).join("; ")} - nx release finds no tag under the new name and would release from the disk version, a downgrade`,
-    remedy: `run \`mnci adopt --tags\` to create the baseline tag for each (${stranded.map((entry) => entry.newTag).join(", ")}) on the commit of its old tag, then push the tags`
-  };
-}
 function collectFindings(workspaceRoot) {
-  const nxJsonPath = (0, import_node_path38.join)(workspaceRoot, "nx.json");
+  const nxJsonPath = (0, import_node_path40.join)(workspaceRoot, "nx.json");
   if (!fileExists(nxJsonPath)) {
     throw new Error(
       `No nx.json found in ${workspaceRoot} \u2014 run 'mnci doctor' from the workspace root.`
@@ -8910,7 +9022,8 @@ function collectFindings(workspaceRoot) {
     ...checkNativeBuildConfig(workspaceRoot),
     checkDependencyRangesNotPreserved(nxJson),
     checkLockfileHasNoLocalRegistry(workspaceRoot),
-    checkReleaseTagsResolve(workspaceRoot, nxJson)
+    checkReleaseTagsResolve(workspaceRoot, nxJson),
+    checkReactAppOutput(workspaceRoot)
   ].filter((finding) => finding !== void 0);
 }
 function runDoctor(workspaceRoot, options = {}) {
@@ -8946,11 +9059,11 @@ function runDoctor(workspaceRoot, options = {}) {
   process.exitCode = 1;
 }
 
-// src/repository-adoption/adopt-dependencies.use-case.ts
-var import_node_fs33 = require("fs");
-var import_node_path39 = require("path");
+// src/dependency-adoption/adopt-dependencies.use-case.ts
+var import_node_fs34 = require("fs");
+var import_node_path41 = require("path");
 
-// src/repository-adoption/clean-working-tree.validator.ts
+// src/clean-working-tree/clean-working-tree.validator.ts
 function requireCleanWorkingTree(repositoryRoot, capture = runCapture) {
   if (capture("git", ["rev-parse", "--is-inside-work-tree"], repositoryRoot).status !== 0) {
     throw new Error("This directory is not a git repository. Every adoption step is one diff to review, so it needs git.");
@@ -8960,7 +9073,7 @@ function requireCleanWorkingTree(repositoryRoot, capture = runCapture) {
   }
 }
 
-// src/repository-adoption/extract-imports.algorithm.ts
+// src/dependency-adoption/extract-imports.algorithm.ts
 var import_node_module = require("module");
 var SPECIFIER2 = /(?:\bfrom\s*|\bimport\s*(?:\(\s*)?|\brequire\s*\(\s*)(['"`])([^'"`\n]+)\1/g;
 var BUILTINS = new Set(import_node_module.builtinModules);
@@ -8986,7 +9099,7 @@ function extractImportedPackages(source) {
   return found;
 }
 
-// src/repository-adoption/plan-dependency-moves.algorithm.ts
+// src/dependency-adoption/plan-dependency-moves.algorithm.ts
 function planDependencyMoves(rootDependencies, usage, declared) {
   const plan = { moves: [], removed: [], keptAtRoot: [], conflicts: [] };
   for (const [name, range] of Object.entries(rootDependencies)) {
@@ -9014,12 +9127,12 @@ function planDependencyMoves(rootDependencies, usage, declared) {
   return plan;
 }
 
-// src/repository-adoption/adopt-dependencies.use-case.ts
+// src/dependency-adoption/adopt-dependencies.use-case.ts
 var SOURCE_FILE = /\.(?:[cm]?[jt]s|[jt]sx)$/;
 var TEST_FILE = /\.(?:spec|test)\.[^.]+$|[\\/](?:__tests__|tests?|e2e)[\\/]/;
 var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "coverage", "out", ".git", ".nx", "tmp"]);
 function sourceFiles(directory, relative = "") {
-  const entries = (0, import_node_fs33.readdirSync)((0, import_node_path39.join)(directory, relative), { withFileTypes: true });
+  const entries = (0, import_node_fs34.readdirSync)((0, import_node_path41.join)(directory, relative), { withFileTypes: true });
   const found = [];
   for (const entry of entries) {
     const path = relative === "" ? entry.name : `${relative}/${entry.name}`;
@@ -9035,7 +9148,7 @@ function sourceFiles(directory, relative = "") {
 }
 function wantedImportsOf(path, wanted) {
   try {
-    const imported = [...extractImportedPackages((0, import_node_fs33.readFileSync)(path, "utf8"))];
+    const imported = [...extractImportedPackages((0, import_node_fs34.readFileSync)(path, "utf8"))];
     return imported.filter((name) => wanted.has(name));
   } catch {
     return [];
@@ -9046,7 +9159,7 @@ function importsOfProject(projectDirectory, wanted) {
   const tested = /* @__PURE__ */ new Set();
   const files = sourceFiles(projectDirectory);
   for (const file of files) {
-    const names = wantedImportsOf((0, import_node_path39.join)(projectDirectory, file), wanted);
+    const names = wantedImportsOf((0, import_node_path41.join)(projectDirectory, file), wanted);
     const target = TEST_FILE.test(file) ? tested : shipped;
     for (const name of names) {
       target.add(name);
@@ -9058,7 +9171,7 @@ function importsOfProject(projectDirectory, wanted) {
 function findUsage(repositoryRoot, projectDirectories, wanted) {
   const usage = {};
   for (const dir of projectDirectories) {
-    const { shipped, testsOnly } = importsOfProject((0, import_node_path39.join)(repositoryRoot, dir), wanted);
+    const { shipped, testsOnly } = importsOfProject((0, import_node_path41.join)(repositoryRoot, dir), wanted);
     for (const name of shipped) {
       usage[name] ??= { runtime: [], testsOnly: [] };
       usage[name].runtime.push(dir);
@@ -9073,7 +9186,7 @@ function findUsage(repositoryRoot, projectDirectories, wanted) {
 function adoptDependencies(repositoryRoot, dependencies = {}) {
   const run = dependencies.run ?? runShell;
   requireCleanWorkingTree(repositoryRoot, dependencies.capture ?? runCapture);
-  const rootPath = (0, import_node_path39.join)(repositoryRoot, "package.json");
+  const rootPath = (0, import_node_path41.join)(repositoryRoot, "package.json");
   if (!fileExists(rootPath)) {
     throw new Error("No package.json at the repository root.");
   }
@@ -9107,11 +9220,11 @@ function adoptDependencies(repositoryRoot, dependencies = {}) {
   return { plan, installed };
 }
 
-// src/repository-adoption/adopt-kinds.use-case.ts
-var import_node_fs34 = require("fs");
-var import_node_path40 = require("path");
+// src/kind-adoption/adopt-kinds.use-case.ts
+var import_node_fs35 = require("fs");
+var import_node_path42 = require("path");
 
-// src/repository-adoption/infer-project-kind.algorithm.ts
+// src/kind-adoption/infer-project-kind.algorithm.ts
 var SERVER_FRAMEWORKS = ["express", "koa", "fastify", "@nestjs/core"];
 function declares(manifest, name) {
   return ["dependencies", "devDependencies", "peerDependencies"].some((key) => {
@@ -9207,35 +9320,35 @@ function inferProjectKind(evidence) {
   }
 }
 
-// src/repository-adoption/adopt-kinds.use-case.ts
+// src/kind-adoption/adopt-kinds.use-case.ts
 var TYPE_TAG = "type:";
 function readEvidence(repositoryRoot, location) {
-  const directory = (0, import_node_path40.join)(repositoryRoot, location.dir);
-  const files = (0, import_node_fs34.readdirSync)(directory);
+  const directory = (0, import_node_path42.join)(repositoryRoot, location.dir);
+  const files = (0, import_node_fs35.readdirSync)(directory);
   const manifest = location.ecosystem === "npm" ? readJson(location.manifestPath) : {};
-  const text = location.ecosystem === "npm" ? "" : (0, import_node_fs34.readFileSync)(location.manifestPath, "utf8");
+  const text = location.ecosystem === "npm" ? "" : (0, import_node_fs35.readFileSync)(location.manifestPath, "utf8");
   let hasProgram = false;
   if (location.ecosystem === "go") {
-    hasProgram = files.filter((file) => file.endsWith(".go")).some((file) => /^package main\b/m.test((0, import_node_fs34.readFileSync)((0, import_node_path40.join)(directory, file), "utf8")));
+    hasProgram = files.filter((file) => file.endsWith(".go")).some((file) => /^package main\b/m.test((0, import_node_fs35.readFileSync)((0, import_node_path42.join)(directory, file), "utf8")));
   } else if (location.ecosystem === "pub") {
-    hasProgram = (0, import_node_fs34.existsSync)((0, import_node_path40.join)(directory, "lib", "main.dart"));
+    hasProgram = (0, import_node_fs35.existsSync)((0, import_node_path42.join)(directory, "lib", "main.dart"));
   }
   return { ecosystem: location.ecosystem, manifest, text, files, hasProgram };
 }
 function existingKind(directory) {
   const sources = [];
-  if (fileExists((0, import_node_path40.join)(directory, "project.json"))) {
-    sources.push(readJson((0, import_node_path40.join)(directory, "project.json")).tags ?? []);
+  if (fileExists((0, import_node_path42.join)(directory, "project.json"))) {
+    sources.push(readJson((0, import_node_path42.join)(directory, "project.json")).tags ?? []);
   }
-  if (fileExists((0, import_node_path40.join)(directory, "package.json"))) {
-    sources.push(readJson((0, import_node_path40.join)(directory, "package.json")).nx?.tags ?? []);
+  if (fileExists((0, import_node_path42.join)(directory, "package.json"))) {
+    sources.push(readJson((0, import_node_path42.join)(directory, "package.json")).nx?.tags ?? []);
   }
   return sources.flat().find((tag) => tag.startsWith(TYPE_TAG))?.slice(TYPE_TAG.length);
 }
 function writeKindTag(directory, name, kind) {
   const tag = `${TYPE_TAG}${kind}`;
-  const projectJson = (0, import_node_path40.join)(directory, "project.json");
-  const packageJson = (0, import_node_path40.join)(directory, "package.json");
+  const projectJson = (0, import_node_path42.join)(directory, "project.json");
+  const packageJson = (0, import_node_path42.join)(directory, "package.json");
   if (fileExists(projectJson)) {
     const project = readJson(projectJson);
     writeFileEnsured(projectJson, toJson({ ...project, tags: [...project.tags ?? [], tag] }));
@@ -9259,7 +9372,7 @@ function adoptKinds(repositoryRoot, overrides = {}, dependencies = {}) {
     }
   }
   return locations.map((location) => {
-    const directory = (0, import_node_path40.join)(repositoryRoot, location.dir);
+    const directory = (0, import_node_path42.join)(repositoryRoot, location.dir);
     const present = existingKind(directory);
     if (present !== void 0) {
       return { dir: location.dir, outcome: "already", kind: present, reason: PROJECT_KINDS.includes(present) ? "it already has a type tag" : "it already has a type tag of its own, which is not an mnci kind name; left as it is" };
@@ -9275,12 +9388,12 @@ function adoptKinds(repositoryRoot, overrides = {}, dependencies = {}) {
 }
 
 // src/repository-adoption/adopt-overlay.use-case.ts
-var import_node_fs36 = require("fs");
-var import_node_path42 = require("path");
+var import_node_fs37 = require("fs");
+var import_node_path44 = require("path");
 
 // src/workspace-upgrade/upgrade-workspace.use-case.ts
-var import_node_fs35 = require("fs");
-var import_node_path41 = require("path");
+var import_node_fs36 = require("fs");
+var import_node_path43 = require("path");
 function resolveRegistry(options, persisted) {
   if (options.registry === "azure-artifacts" || options.organization && options.artifactsFeed) {
     const persistedAzure = persisted?.kind === "azure-artifacts" ? persisted : void 0;
@@ -9309,7 +9422,7 @@ function resolveWorkspaceName(workspaceRoot, persisted) {
     return persisted.workspaceName;
   }
   try {
-    const existing = (0, import_node_fs35.readdirSync)(workspaceRoot).find(
+    const existing = (0, import_node_fs36.readdirSync)(workspaceRoot).find(
       (file) => file.endsWith(".code-workspace") && file !== "undefined.code-workspace"
     );
     if (existing) {
@@ -9317,11 +9430,11 @@ function resolveWorkspaceName(workspaceRoot, persisted) {
     }
   } catch {
   }
-  return (0, import_node_path41.basename)(workspaceRoot);
+  return (0, import_node_path43.basename)(workspaceRoot);
 }
 function detectNpmAuth(workspaceRoot) {
   try {
-    return (0, import_node_fs35.readFileSync)((0, import_node_path41.join)(workspaceRoot, "azure-pipelines.yml"), "utf8").includes("npmAuthenticate@0") ? "build-identity" : void 0;
+    return (0, import_node_fs36.readFileSync)((0, import_node_path43.join)(workspaceRoot, "azure-pipelines.yml"), "utf8").includes("npmAuthenticate@0") ? "build-identity" : void 0;
   } catch {
     return void 0;
   }
@@ -9368,7 +9481,7 @@ function resolveOverlayOptions(workspaceRoot, options, persisted) {
   };
 }
 function runUpgrade(workspaceRoot, options) {
-  if (!fileExists((0, import_node_path41.join)(workspaceRoot, "nx.json"))) {
+  if (!fileExists((0, import_node_path43.join)(workspaceRoot, "nx.json"))) {
     throw new Error(
       `No nx.json found in ${workspaceRoot} \u2014 this does not look like an Nx workspace. Run 'mnci upgrade' from the workspace root.`
     );
@@ -9416,6 +9529,13 @@ function runUpgrade(workspaceRoot, options) {
     logger.step("Updating the VS Code extension packaging script");
     logger.detail(`updated ${VSCODE_EXTENSION_SCRIPT_PATH}`);
   }
+  const separatedApps = separateReactAppsOutput(workspaceRoot);
+  if (separatedApps.length > 0) {
+    logger.step("Moving tsc output out of the folder Vite builds into (build and typecheck raced, TS6305)");
+    for (const dir of separatedApps) {
+      logger.detail(`updated ${dir}/tsconfig.app.json`);
+    }
+  }
   if (refreshContainerScript(workspaceRoot)) {
     logger.step("Updating the container image script");
     logger.detail("updated tools/container-image.cjs");
@@ -9446,7 +9566,7 @@ function runUpgrade(workspaceRoot, options) {
     "Formatting the workspace (eslint --fix) \u2014 the slowest step, minutes on a large workspace"
   );
   runFormatter(workspaceRoot);
-  const nxJson = readJson((0, import_node_path41.join)(workspaceRoot, "nx.json"));
+  const nxJson = readJson((0, import_node_path43.join)(workspaceRoot, "nx.json"));
   const stranded = locateStrandedReleaseTags(workspaceRoot, nxJson.release?.releaseTag?.pattern);
   for (const entry of stranded) {
     logger.warn(`${entry.project} has release tags only under ${entry.oldTag}: nx release would restart it from its disk version. Run \`mnci adopt --tags\` before the next release to create ${entry.newTag} locally (\`mnci doctor\` lists them all).`);
@@ -9457,9 +9577,9 @@ function runUpgrade(workspaceRoot, options) {
 
 // src/repository-adoption/adopt-overlay.use-case.ts
 function detectCiProvider(repositoryRoot) {
-  const azure = (0, import_node_fs36.existsSync)((0, import_node_path42.join)(repositoryRoot, "azure-pipelines.yml"));
-  const workflows = (0, import_node_path42.join)(repositoryRoot, ".github", "workflows");
-  const github = (0, import_node_fs36.existsSync)(workflows) && (0, import_node_fs36.readdirSync)(workflows).some((file) => /\.ya?ml$/.test(file));
+  const azure = (0, import_node_fs37.existsSync)((0, import_node_path44.join)(repositoryRoot, "azure-pipelines.yml"));
+  const workflows = (0, import_node_path44.join)(repositoryRoot, ".github", "workflows");
+  const github = (0, import_node_fs37.existsSync)(workflows) && (0, import_node_fs37.readdirSync)(workflows).some((file) => /\.ya?ml$/.test(file));
   if (azure && github) {
     return "both";
   }
@@ -9469,7 +9589,7 @@ function detectCiProvider(repositoryRoot) {
   return github ? "github" : void 0;
 }
 function detectTestRunner(repositoryRoot) {
-  const manifestPath = (0, import_node_path42.join)(repositoryRoot, "package.json");
+  const manifestPath = (0, import_node_path44.join)(repositoryRoot, "package.json");
   if (!fileExists(manifestPath)) {
     return void 0;
   }
@@ -9482,8 +9602,8 @@ function detectTestRunner(repositoryRoot) {
 }
 function adoptOverlay(repositoryRoot, options, dependencies = {}) {
   requireCleanWorkingTree(repositoryRoot, dependencies.capture ?? runCapture);
-  if (!fileExists((0, import_node_path42.join)(repositoryRoot, "nx.json"))) {
-    throw new Error("There is no nx.json, so Nx is not set up here. Set it up first (`npx nx@latest init`); adopt does not install Nx yet.");
+  if (!fileExists((0, import_node_path44.join)(repositoryRoot, "nx.json"))) {
+    throw new Error("There is no nx.json, so Nx is not set up here. Run `mnci adopt --toolchain` first: it sets Nx up (nx init, then nx add), and the overlay needs that.");
   }
   const persisted = readMnciConfig(repositoryRoot);
   const filled = {
@@ -9494,10 +9614,10 @@ function adoptOverlay(repositoryRoot, options, dependencies = {}) {
   (dependencies.upgrade ?? runUpgrade)(repositoryRoot, filled);
 }
 
-// src/repository-adoption/adopt-toolchain.use-case.ts
-var import_node_path44 = require("path");
+// src/toolchain-adoption/adopt-toolchain.use-case.ts
+var import_node_path47 = require("path");
 
-// src/repository-adoption/align-nx-family.algorithm.ts
+// src/toolchain-adoption/align-nx-family.algorithm.ts
 var VERSION = /^[\^~]?(\d+)\.(\d+)\.(\d+)$/;
 function isNxFamily(name) {
   return name === "nx" || name.startsWith("@nx/");
@@ -9532,25 +9652,56 @@ function alignNxFamily(dependencies, version) {
   return { dependencies: aligned, changed };
 }
 
-// src/repository-adoption/retire-tooling.use-case.ts
-var import_node_fs37 = require("fs");
-var import_node_path43 = require("path");
+// src/toolchain-adoption/bootstrap-nx.use-case.ts
+var import_node_path45 = require("path");
+var BASE_PLUGIN = "@nx/js";
+var TOOL_PLUGINS = [
+  ["eslint", "@nx/eslint"],
+  ["jest", "@nx/jest"],
+  ["vitest", "@nx/vite"]
+];
+function pluginsFor(repositoryRoot) {
+  const manifestPath = (0, import_node_path45.join)(repositoryRoot, "package.json");
+  const manifest = fileExists(manifestPath) ? readJson(manifestPath) : {};
+  const declared = Object.keys({ ...manifest.dependencies, ...manifest.devDependencies });
+  return [BASE_PLUGIN, ...TOOL_PLUGINS.filter(([tool]) => declared.includes(tool)).map(([, plugin]) => plugin)];
+}
+function bootstrapNx(repositoryRoot, nxVersion, dependencies) {
+  if (fileExists((0, import_node_path45.join)(repositoryRoot, "nx.json"))) {
+    return { bootstrapped: false, plugins: [] };
+  }
+  const initialised = dependencies.run("npx", ["--yes", `nx@${nxVersion ?? "latest"}`, "init", "--interactive=false", "--nxCloud=skip", "--plugins=skip"], repositoryRoot);
+  if (initialised !== 0) {
+    throw new Error("`nx init` failed, so Nx could not be set up here. Read its output above; nothing else was changed after it.");
+  }
+  const plugins = pluginsFor(repositoryRoot);
+  for (const plugin of plugins) {
+    if (dependencies.run("npx", ["nx", "add", plugin], repositoryRoot) !== 0) {
+      throw new Error(`\`nx add ${plugin}\` failed. Nx itself is set up (nx.json exists); add the plugin by hand once its error is dealt with.`);
+    }
+  }
+  return { bootstrapped: true, plugins };
+}
+
+// src/toolchain-adoption/retire-tooling.use-case.ts
+var import_node_fs38 = require("fs");
+var import_node_path46 = require("path");
 var RETIRED_COMMAND = /\b(?:prettier|oxfmt|oxlint)\b/;
 function retireTooling(repositoryRoot) {
   const removed = [];
   for (const file of RETIRED_FORMATTER_FILES) {
-    if (!fileExists((0, import_node_path43.join)(repositoryRoot, file))) {
+    if (!fileExists((0, import_node_path46.join)(repositoryRoot, file))) {
       continue;
     }
-    (0, import_node_fs37.rmSync)((0, import_node_path43.join)(repositoryRoot, file), { force: true });
+    (0, import_node_fs38.rmSync)((0, import_node_path46.join)(repositoryRoot, file), { force: true });
     removed.push(file);
   }
-  const hadRegistry = fileExists((0, import_node_path43.join)(repositoryRoot, ".verdaccio"));
+  const hadRegistry = fileExists((0, import_node_path46.join)(repositoryRoot, ".verdaccio"));
   removeLocalRegistryScaffolding(repositoryRoot);
   if (hadRegistry) {
     removed.push(".verdaccio, its dependency and the local-registry target");
   }
-  const manifestPath = (0, import_node_path43.join)(repositoryRoot, "package.json");
+  const manifestPath = (0, import_node_path46.join)(repositoryRoot, "package.json");
   if (!fileExists(manifestPath)) {
     return removed;
   }
@@ -9578,7 +9729,7 @@ function retireTooling(repositoryRoot) {
   return removed;
 }
 
-// src/repository-adoption/adopt-toolchain.use-case.ts
+// src/toolchain-adoption/adopt-toolchain.use-case.ts
 var MAX_AUDIT_FIX_PASSES = 4;
 function publishedNxVersions(repositoryRoot, capture) {
   const answer = capture("npm", ["view", "nx", "versions", "--json"], repositoryRoot);
@@ -9597,10 +9748,14 @@ function adoptToolchain(repositoryRoot, options = {}, dependencies = {}) {
     console.log(message);
   });
   requireCleanWorkingTree(repositoryRoot, capture);
-  const manifestPath = (0, import_node_path44.join)(repositoryRoot, "package.json");
+  const manifestPath = (0, import_node_path47.join)(repositoryRoot, "package.json");
   if (!fileExists(manifestPath)) {
     throw new Error("No package.json at the repository root.");
   }
+  const bootstrap = bootstrapNx(repositoryRoot, options.nxVersion, { run });
+  if (bootstrap.bootstrapped) {
+    log(`Set Nx up (nx init, then nx add ${bootstrap.plugins.join(" ")})`);
+  }
   log("Removing retired tooling");
   const removed = retireTooling(repositoryRoot);
   const manifest = readJson(manifestPath);
@@ -9628,27 +9783,12 @@ function adoptToolchain(repositoryRoot, options = {}, dependencies = {}) {
     run("npm", ["audit", "fix", "--no-fund"], repositoryRoot);
     passes = audit(repositoryRoot) === 0;
   }
-  return { removed, aligned: { names, version }, auditFixes, auditPasses: passes };
-}
-
-// src/repository-adoption/create-baseline-tags.use-case.ts
-function createBaselineTags(repositoryRoot, stranded) {
-  const result = { created: [], existing: [], failed: [] };
-  for (const entry of stranded) {
-    const present = runCapture("git", ["rev-parse", "--verify", "--quiet", `refs/tags/${entry.newTag}`], repositoryRoot);
-    if (present.status === 0) {
-      result.existing.push(entry.newTag);
-      continue;
-    }
-    const made = runCapture("git", ["tag", entry.newTag, `${entry.oldTag}^{commit}`], repositoryRoot);
-    (made.status === 0 ? result.created : result.failed).push(entry.newTag);
-  }
-  return result;
+  return { bootstrapped: bootstrap.plugins, removed, aligned: { names, version }, auditFixes, auditPasses: passes };
 }
 
-// src/repository-adoption/inspect-repository.use-case.ts
-var import_node_fs38 = require("fs");
-var import_node_path45 = require("path");
+// src/adoption-report/inspect-repository.use-case.ts
+var import_node_fs39 = require("fs");
+var import_node_path48 = require("path");
 var LOCKFILES = [
   ["package-lock.json", "npm"],
   ["pnpm-lock.yaml", "pnpm"],
@@ -9669,25 +9809,25 @@ function inspectRepository(repositoryRoot) {
   const isGitRepo = inside.status === 0 && inside.stdout.trim() === "true";
   const dirty = isGitRepo && runCapture("git", ["status", "--porcelain"], repositoryRoot).stdout.trim() !== "";
   const tags = isGitRepo ? runCapture("git", ["tag", "--list"], repositoryRoot).stdout.split(/\r?\n/).filter(Boolean) : [];
-  const manifestPath = (0, import_node_path45.join)(repositoryRoot, "package.json");
+  const manifestPath = (0, import_node_path48.join)(repositoryRoot, "package.json");
   const manifest = fileExists(manifestPath) ? readJson(manifestPath) : {};
-  const nxJsonPath = (0, import_node_path45.join)(repositoryRoot, "nx.json");
+  const nxJsonPath = (0, import_node_path48.join)(repositoryRoot, "nx.json");
   const nxJson = fileExists(nxJsonPath) ? readJson(nxJsonPath) : {};
   const ci = [];
   const pipelines = [];
-  if ((0, import_node_fs38.existsSync)((0, import_node_path45.join)(repositoryRoot, "azure-pipelines.yml"))) {
+  if ((0, import_node_fs39.existsSync)((0, import_node_path48.join)(repositoryRoot, "azure-pipelines.yml"))) {
     ci.push("azure");
-    pipelines.push((0, import_node_path45.join)(repositoryRoot, "azure-pipelines.yml"));
+    pipelines.push((0, import_node_path48.join)(repositoryRoot, "azure-pipelines.yml"));
   }
-  const workflows = (0, import_node_path45.join)(repositoryRoot, ".github", "workflows");
-  if ((0, import_node_fs38.existsSync)(workflows)) {
-    const files = (0, import_node_fs38.readdirSync)(workflows).filter((file) => /\.ya?ml$/.test(file));
+  const workflows = (0, import_node_path48.join)(repositoryRoot, ".github", "workflows");
+  if ((0, import_node_fs39.existsSync)(workflows)) {
+    const files = (0, import_node_fs39.readdirSync)(workflows).filter((file) => /\.ya?ml$/.test(file));
     if (files.length > 0) {
       ci.push("github");
-      pipelines.push(...files.map((file) => (0, import_node_path45.join)(workflows, file)));
+      pipelines.push(...files.map((file) => (0, import_node_path48.join)(workflows, file)));
     }
   }
-  const rootFiles = (0, import_node_fs38.readdirSync)(repositoryRoot);
+  const rootFiles = (0, import_node_fs39.readdirSync)(repositoryRoot);
   return {
     isGitRepo,
     dirty,
@@ -9698,13 +9838,13 @@ function inspectRepository(repositoryRoot) {
     tagCount: tags.length,
     strandedTags: isGitRepo ? locateStrandedReleaseTags(repositoryRoot, nxJson.release?.releaseTag?.pattern) : [],
     ci,
-    pipelineUsesMnci: pipelines.some((file) => /\bmnci ci\b/.test((0, import_node_fs38.readFileSync)(file, "utf8"))),
+    pipelineUsesMnci: pipelines.some((file) => /\bmnci ci\b/.test((0, import_node_fs39.readFileSync)(file, "utf8"))),
     retiredTooling: [.../* @__PURE__ */ new Set([...rootFiles.filter((file) => RETIRED_FILE_PATTERN.test(file) || file === ".verdaccio"), ...retiredNamesIn(manifest)])],
     personalFiles: PERSONAL_FILES.filter((file) => rootFiles.includes(file))
   };
 }
 
-// src/repository-adoption/judge-adoption.policy.ts
+// src/adoption-report/judge-adoption.policy.ts
 function judgeAdoption(facts) {
   const findings = [];
   const blocker = (detail, step) => {
@@ -9728,7 +9868,7 @@ function judgeAdoption(facts) {
     warning("nx.json already carries an mnci block, so this is an mnci workspace", "use `mnci upgrade`; adopt is for repositories mnci has not touched");
   }
   if (facts.nxVersion === void 0) {
-    warning("Nx is not installed", "set Nx up first (`npx nx@latest init`); adopt does not install it yet, and the toolchain and overlay steps need an nx.json");
+    warning("Nx is not installed", "run `mnci adopt --toolchain`, which sets Nx up through nx init and nx add before it does anything else; the overlay step needs the nx.json that makes");
   }
   if (facts.strandedTags.length > 0) {
     warning(
@@ -9749,10 +9889,12 @@ function judgeAdoption(facts) {
   return { ready: ordered.every((finding) => finding.severity !== "blocker"), facts, findings: ordered };
 }
 
-// src/repository-adoption/run-adopt.use-case.ts
+// src/adoption-report/report-adoption.use-case.ts
 function reportAdoption(repositoryRoot) {
   return judgeAdoption(inspectRepository(repositoryRoot));
 }
+
+// src/repository-adoption/run-adopt.use-case.ts
 function runAdopt(repositoryRoot, options = {}) {
   const report = reportAdoption(repositoryRoot);
   if (options.dependencies === true) {
@@ -9833,6 +9975,9 @@ function runToolchain(repositoryRoot, options) {
     const result = adoptToolchain(repositoryRoot, { nxVersion: options.nx }, { log: (message) => {
       logger.step(message);
     } });
+    if (result.bootstrapped.length > 0) {
+      logger.info(`Nx was not set up here, so it is now: ${result.bootstrapped.join(", ")} (nx.json and the plugins; review it with \`git diff\`).`);
+    }
     for (const line of result.removed) {
       logger.info(`removed ${line}`);
     }
@@ -9996,13 +10141,13 @@ function runCommands(program, options) {
 }
 
 // src/workspace-info/list-projects.use-case.ts
-var import_node_path46 = require("path");
+var import_node_path49 = require("path");
 var TYPE_TAG_PREFIX = "type:";
 function listProjects(workspaceRoot) {
   return locateProjects(workspaceRoot).map((location) => {
-    const projectJsonPath = (0, import_node_path46.join)(workspaceRoot, location.dir, "project.json");
+    const projectJsonPath = (0, import_node_path49.join)(workspaceRoot, location.dir, "project.json");
     const project = fileExists(projectJsonPath) ? readJson(projectJsonPath) : {};
-    const manifestPath = (0, import_node_path46.join)(workspaceRoot, location.dir, "package.json");
+    const manifestPath = (0, import_node_path49.join)(workspaceRoot, location.dir, "package.json");
     const manifestTags = fileExists(manifestPath) ? readJson(manifestPath).nx?.tags ?? [] : [];
     const typeTag = [...project.tags ?? [], ...manifestTags].find((tag) => tag.startsWith(TYPE_TAG_PREFIX));
     return {
@@ -10015,7 +10160,7 @@ function listProjects(workspaceRoot) {
   }).toSorted((a, b) => a.dir.localeCompare(b.dir));
 }
 function runProjects(workspaceRoot, options) {
-  if (!fileExists((0, import_node_path46.join)(workspaceRoot, "nx.json"))) {
+  if (!fileExists((0, import_node_path49.join)(workspaceRoot, "nx.json"))) {
     throw new Error("No nx.json found here. Run `projects` from the workspace root.");
   }
   const projects = listProjects(workspaceRoot);
@@ -10029,11 +10174,11 @@ function runProjects(workspaceRoot, options) {
 }
 
 // src/workspace-info/read-workspace-info.use-case.ts
-var import_node_path48 = require("path");
+var import_node_path51 = require("path");
 
 // src/cli-version/check-for-update.use-case.ts
-var import_node_fs39 = require("fs");
-var import_node_path47 = require("path");
+var import_node_fs40 = require("fs");
+var import_node_path50 = require("path");
 var import_cross_spawn4 = __toESM(require("cross-spawn"));
 var PACKAGE_NAME2 = "@mnci/cli";
 var REGISTRY_TIMEOUT_MS = 2e3;
@@ -10092,8 +10237,8 @@ function releaseTriple(version) {
 }
 function readCliVersion(packageDirectory) {
   try {
-    const manifestPath = (0, import_node_path47.join)(packageDirectory, "..", "package.json");
-    const manifest = JSON.parse((0, import_node_fs39.readFileSync)(manifestPath, "utf8"));
+    const manifestPath = (0, import_node_path50.join)(packageDirectory, "..", "package.json");
+    const manifest = JSON.parse((0, import_node_fs40.readFileSync)(manifestPath, "utf8"));
     return manifest.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -10103,7 +10248,7 @@ function readCliVersion(packageDirectory) {
 // src/workspace-info/read-workspace-info.use-case.ts
 function readWorkspaceInfo(workspaceRoot, cliVersion) {
   const latest = fetchLatestVersion() ?? null;
-  const isWorkspace = fileExists((0, import_node_path48.join)(workspaceRoot, "nx.json"));
+  const isWorkspace = fileExists((0, import_node_path51.join)(workspaceRoot, "nx.json"));
   return {
     cli: {
       version: cliVersion,
@@ -10124,7 +10269,7 @@ function runInfo(workspaceRoot, cliVersion, options) {
 }
 
 // src/interactive-wizard/interactive-wizard.use-case.ts
-var import_node_path49 = require("path");
+var import_node_path52 = require("path");
 
 // src/interactive-wizard/adopt-steps.config.ts
 var ADOPT_GLOBAL_OPTIONS = ["json"];
@@ -10305,7 +10450,7 @@ function wizardMenu(commands, inWorkspace) {
 }
 async function runInteractive(program, prompter = createInquirerPrompter(), workingDirectory = process.cwd()) {
   const commands = describeCommands(program);
-  const inWorkspace = fileExists((0, import_node_path49.join)(workingDirectory, "nx.json"));
+  const inWorkspace = fileExists((0, import_node_path52.join)(workingDirectory, "nx.json"));
   const name = await prompter.select("What would you like to do?", wizardMenu(commands, inWorkspace));
   const command = commands.find((candidate) => candidate.name === name);
   const argv = buildArgv(command, await askCommand(command, prompter));
@@ -10332,8 +10477,8 @@ var PRESETS = [
 var PRESET_IDS = PRESETS.map((preset) => preset.id);
 
 // src/workspace-presets/wire-web-api.use-case.ts
-var import_node_fs40 = require("fs");
-var import_node_path50 = require("path");
+var import_node_fs41 = require("fs");
+var import_node_path53 = require("path");
 
 // src/workspace-presets/web-api-wiring.algorithm.ts
 function apiHandler(shared) {
@@ -10505,18 +10650,18 @@ function declareDependency(manifestPath, name) {
 }
 function removeFiles(slice, files) {
   for (const file of files) {
-    (0, import_node_fs40.rmSync)((0, import_node_path50.join)(slice, file), { force: true });
+    (0, import_node_fs41.rmSync)((0, import_node_path53.join)(slice, file), { force: true });
   }
 }
 function replaceOnce(path, anchor, replacement) {
-  const text = (0, import_node_fs40.readFileSync)(path, "utf8");
+  const text = (0, import_node_fs41.readFileSync)(path, "utf8");
   if (!text.includes(anchor)) {
     throw new Error(`${path} has no ${anchor}; the generator's output changed, so the preset cannot wire it.`);
   }
   writeFileEnsured(path, text.replace(anchor, () => replacement));
 }
 function proxyApi(viteConfigPath) {
-  const text = (0, import_node_fs40.readFileSync)(viteConfigPath, "utf8");
+  const text = (0, import_node_fs41.readFileSync)(viteConfigPath, "utf8");
   const proxied = withApiProxy(text, API_ORIGIN);
   if (proxied === text && !text.includes("proxy:")) {
     throw new Error(`${viteConfigPath} has no server block to add the /api proxy to; the generator's output changed, so the preset cannot wire it.`);
@@ -10524,30 +10669,30 @@ function proxyApi(viteConfigPath) {
   writeFileEnsured(viteConfigPath, proxied);
 }
 function wireWebApi(workspaceRoot, projects) {
-  const sharedManifest = (0, import_node_path50.join)(workspaceRoot, "libs", projects.shared, "package.json");
+  const sharedManifest = (0, import_node_path53.join)(workspaceRoot, "libs", projects.shared, "package.json");
   if (!fileExists(sharedManifest)) {
     throw new Error(`The shared library was not added at libs/${projects.shared}, so there is nothing to wire the API and the frontend to.`);
   }
   const shared = readJson(sharedManifest).name;
-  const api = (0, import_node_path50.join)(workspaceRoot, "apps", projects.api);
-  declareDependency((0, import_node_path50.join)(api, "package.json"), shared);
-  const hello = (0, import_node_path50.join)(api, "src", "hello");
-  writeFileEnsured((0, import_node_path50.join)(hello, "hello.handler.ts"), apiHandler(shared));
-  writeFileEnsured((0, import_node_path50.join)(hello, "hello.handler.spec.ts"), apiHandlerSpec(shared));
-  writeFileEnsured((0, import_node_path50.join)(hello, "index.ts"), apiBarrel());
+  const api = (0, import_node_path53.join)(workspaceRoot, "apps", projects.api);
+  declareDependency((0, import_node_path53.join)(api, "package.json"), shared);
+  const hello = (0, import_node_path53.join)(api, "src", "hello");
+  writeFileEnsured((0, import_node_path53.join)(hello, "hello.handler.ts"), apiHandler(shared));
+  writeFileEnsured((0, import_node_path53.join)(hello, "hello.handler.spec.ts"), apiHandlerSpec(shared));
+  writeFileEnsured((0, import_node_path53.join)(hello, "index.ts"), apiBarrel());
   removeFiles(hello, ["greet.use-case.ts", "greet.use-case.spec.ts", "greeting.contract.ts"]);
-  replaceOnce((0, import_node_path50.join)(api, "src", "main.ts"), "app.get('/', helloHandler)", "app.get('/api/greeting', helloHandler)");
-  const web = (0, import_node_path50.join)(workspaceRoot, "apps", projects.web);
-  declareDependency((0, import_node_path50.join)(web, "package.json"), shared);
-  const greeting = (0, import_node_path50.join)(web, "src", "greeting");
-  writeFileEnsured((0, import_node_path50.join)(greeting, "greeting.client.ts"), webGreetingClient(shared));
-  writeFileEnsured((0, import_node_path50.join)(greeting, "greeting.client.spec.ts"), webGreetingClientSpec());
-  writeFileEnsured((0, import_node_path50.join)(greeting, "greeting.component.tsx"), webGreetingComponent(shared));
-  writeFileEnsured((0, import_node_path50.join)(greeting, "greeting.component.spec.tsx"), webGreetingSpec());
-  writeFileEnsured((0, import_node_path50.join)(greeting, "index.ts"), webGreetingBarrel());
+  replaceOnce((0, import_node_path53.join)(api, "src", "main.ts"), "app.get('/', helloHandler)", "app.get('/api/greeting', helloHandler)");
+  const web = (0, import_node_path53.join)(workspaceRoot, "apps", projects.web);
+  declareDependency((0, import_node_path53.join)(web, "package.json"), shared);
+  const greeting = (0, import_node_path53.join)(web, "src", "greeting");
+  writeFileEnsured((0, import_node_path53.join)(greeting, "greeting.client.ts"), webGreetingClient(shared));
+  writeFileEnsured((0, import_node_path53.join)(greeting, "greeting.client.spec.ts"), webGreetingClientSpec());
+  writeFileEnsured((0, import_node_path53.join)(greeting, "greeting.component.tsx"), webGreetingComponent(shared));
+  writeFileEnsured((0, import_node_path53.join)(greeting, "greeting.component.spec.tsx"), webGreetingSpec());
+  writeFileEnsured((0, import_node_path53.join)(greeting, "index.ts"), webGreetingBarrel());
   removeFiles(greeting, ["greet.use-case.ts", "greet.use-case.spec.ts", "greeting.contract.ts"]);
-  writeFileEnsured((0, import_node_path50.join)(web, "src", "app", "app.component.spec.tsx"), webAppSpec());
-  proxyApi((0, import_node_path50.join)(web, "vite.config.mts"));
+  writeFileEnsured((0, import_node_path53.join)(web, "src", "app", "app.component.spec.tsx"), webAppSpec());
+  proxyApi((0, import_node_path53.join)(web, "vite.config.mts"));
 }
 
 // src/workspace-presets/apply-preset.use-case.ts
@@ -10590,8 +10735,8 @@ async function applyPreset(workspaceRoot, presetId, dependencies = {}) {
 }
 
 // src/workspace-creation/adopt-directory.use-case.ts
-var import_node_fs41 = require("fs");
-var import_node_path51 = require("path");
+var import_node_fs42 = require("fs");
+var import_node_path54 = require("path");
 var NEVER_COPIED = /* @__PURE__ */ new Set([".git", "node_modules"]);
 var AGENT_AND_CI_ENTRIES = [
   "AGENTS.md",
@@ -10622,13 +10767,13 @@ var PREFLIGHT_BLOCKERS = [
   "packages"
 ];
 function assertAdoptableDirectory(target) {
-  if (!(0, import_node_fs41.existsSync)(target)) {
+  if (!(0, import_node_fs42.existsSync)(target)) {
     throw new Error(`--into '${target}' does not exist. Create or clone it first.`);
   }
-  if (!(0, import_node_fs41.statSync)(target).isDirectory()) {
+  if (!(0, import_node_fs42.statSync)(target).isDirectory()) {
     throw new Error(`--into '${target}' is not a directory.`);
   }
-  const blockers = PREFLIGHT_BLOCKERS.filter((entry) => (0, import_node_fs41.existsSync)((0, import_node_path51.join)(target, entry)));
+  const blockers = PREFLIGHT_BLOCKERS.filter((entry) => (0, import_node_fs42.existsSync)((0, import_node_path54.join)(target, entry)));
   if (blockers.length > 0) {
     throw new Error(
       `--into '${target}' already holds ${blockers.join(", ")}, so it is a project already. Use \`mnci upgrade\` to re-apply the overlay to an existing workspace, or point --into at an empty checkout.`
@@ -10636,15 +10781,15 @@ function assertAdoptableDirectory(target) {
   }
 }
 function mergeGitignore(generatedFile, targetFile) {
-  const existing = (0, import_node_fs41.readFileSync)(targetFile, "utf8");
+  const existing = (0, import_node_fs42.readFileSync)(targetFile, "utf8");
   const present = new Set(existing.split("\n").map((line) => line.trim()));
-  const additions = (0, import_node_fs41.readFileSync)(generatedFile, "utf8").split("\n").map((line) => line.trimEnd()).filter((line) => {
+  const additions = (0, import_node_fs42.readFileSync)(generatedFile, "utf8").split("\n").map((line) => line.trimEnd()).filter((line) => {
     const trimmed = line.trim();
     return trimmed !== "" && !trimmed.startsWith("#") && !present.has(trimmed);
   });
   if (additions.length === 0) return false;
   const separator = existing.endsWith("\n") ? "" : "\n";
-  (0, import_node_fs41.writeFileSync)(
+  (0, import_node_fs42.writeFileSync)(
     targetFile,
     `${existing}${separator}
 # Added by mnci (Nx workspace)
@@ -10654,9 +10799,9 @@ ${additions.join("\n")}
   return true;
 }
 function adoptGeneratedWorkspace(generatedRoot, target) {
-  const entries = (0, import_node_fs41.readdirSync)(generatedRoot).filter((entry) => !NEVER_COPIED.has(entry));
+  const entries = (0, import_node_fs42.readdirSync)(generatedRoot).filter((entry) => !NEVER_COPIED.has(entry));
   const collisions = entries.filter(
-    (entry) => (0, import_node_fs41.existsSync)((0, import_node_path51.join)(target, entry)) && !EXISTING_WINS.has(entry) && entry !== ".gitignore"
+    (entry) => (0, import_node_fs42.existsSync)((0, import_node_path54.join)(target, entry)) && !EXISTING_WINS.has(entry) && entry !== ".gitignore"
   );
   if (collisions.length > 0) {
     throw new Error(
@@ -10665,28 +10810,28 @@ function adoptGeneratedWorkspace(generatedRoot, target) {
   }
   const result = { copied: [], kept: [], mergedGitignore: false };
   for (const entry of entries) {
-    const from = (0, import_node_path51.join)(generatedRoot, entry);
-    const to = (0, import_node_path51.join)(target, entry);
-    if (entry === ".gitignore" && (0, import_node_fs41.existsSync)(to)) {
+    const from = (0, import_node_path54.join)(generatedRoot, entry);
+    const to = (0, import_node_path54.join)(target, entry);
+    if (entry === ".gitignore" && (0, import_node_fs42.existsSync)(to)) {
       result.mergedGitignore = mergeGitignore(from, to);
       result.kept.push(entry);
       continue;
     }
-    if ((0, import_node_fs41.existsSync)(to)) {
+    if ((0, import_node_fs42.existsSync)(to)) {
       result.kept.push(entry);
       continue;
     }
-    (0, import_node_fs41.cpSync)(from, to, { recursive: true });
+    (0, import_node_fs42.cpSync)(from, to, { recursive: true });
     result.copied.push(entry);
   }
-  (0, import_node_fs41.rmSync)(generatedRoot, { recursive: true, force: true });
+  (0, import_node_fs42.rmSync)(generatedRoot, { recursive: true, force: true });
   return result;
 }
 
 // src/workspace-creation/create-workspace.use-case.ts
-var import_node_fs42 = require("fs");
+var import_node_fs43 = require("fs");
 var import_node_os2 = require("os");
-var import_node_path52 = require("path");
+var import_node_path55 = require("path");
 function nxCloudProviderValue(ci) {
   return ci === "azure" ? "azure" : "github";
 }
@@ -10729,10 +10874,10 @@ async function resolveRegistry2(options) {
   return await promptRegistry();
 }
 async function runNew(name, options) {
-  const adoptTarget = options.into === void 0 ? void 0 : (0, import_node_path52.resolve)(process.cwd(), options.into);
+  const adoptTarget = options.into === void 0 ? void 0 : (0, import_node_path55.resolve)(process.cwd(), options.into);
   if (adoptTarget !== void 0) assertAdoptableDirectory(adoptTarget);
   if (options.preset !== void 0) findPreset(options.preset);
-  const workspaceName = name ?? (adoptTarget === void 0 ? await promptText("Workspace name") : (0, import_node_path52.basename)(adoptTarget));
+  const workspaceName = name ?? (adoptTarget === void 0 ? await promptText("Workspace name") : (0, import_node_path55.basename)(adoptTarget));
   assertValidProjectName(workspaceName, "Workspace name");
   const scope = options.scope ?? (options.yes ? `@${workspaceName}` : await promptText("npm scope for publishable packages", `@${workspaceName}`));
   const registry = await resolveRegistry2(options);
@@ -10745,8 +10890,8 @@ async function runNew(name, options) {
   const npmAuth = resolveNpmAuth(options.npmAuth, registry, ci);
   const stack = await resolveStack(options);
   const nxCloud = options.nxCloud ?? (options.yes ? false : await promptNxCloud());
-  const stagingParent = adoptTarget === void 0 ? process.cwd() : (0, import_node_fs42.mkdtempSync)((0, import_node_path52.join)((0, import_node_os2.tmpdir)(), "mnci-new-"));
-  let workspaceRoot = (0, import_node_path52.join)(stagingParent, workspaceName);
+  const stagingParent = adoptTarget === void 0 ? process.cwd() : (0, import_node_fs43.mkdtempSync)((0, import_node_path55.join)((0, import_node_os2.tmpdir)(), "mnci-new-"));
+  let workspaceRoot = (0, import_node_path55.join)(stagingParent, workspaceName);
   try {
     logger.step(`Creating Nx workspace '${workspaceName}' (preset: ts)`);
     runNpx(
@@ -10769,7 +10914,7 @@ async function runNew(name, options) {
       workspaceRoot = adoptTarget;
     }
   } finally {
-    if (adoptTarget !== void 0) (0, import_node_fs42.rmSync)(stagingParent, { recursive: true, force: true });
+    if (adoptTarget !== void 0) (0, import_node_fs43.rmSync)(stagingParent, { recursive: true, force: true });
   }
   logger.step(
     "Applying MoNecromanCI overlay (VS Code workspace, release config, .npmrc, commitlint, pipeline, stack)"
@@ -10779,8 +10924,8 @@ async function runNew(name, options) {
     { workspaceName, scope, registry, agent, variableGroup, ci, stack, ...npmAuth && { npmAuth } },
     logger.detail
   );
-  (0, import_node_fs42.rmSync)((0, import_node_path52.join)(workspaceRoot, "node_modules"), { recursive: true, force: true });
-  (0, import_node_fs42.rmSync)((0, import_node_path52.join)(workspaceRoot, "package-lock.json"), { force: true });
+  (0, import_node_fs43.rmSync)((0, import_node_path55.join)(workspaceRoot, "node_modules"), { recursive: true, force: true });
+  (0, import_node_fs43.rmSync)((0, import_node_path55.join)(workspaceRoot, "package-lock.json"), { force: true });
   logger.step("Installing the toolchain (commitlint + husky + linting/formatting)");
   const installStatus = runShell(
     "npm",