@mnci/cli 4.38.0 → 4.39.0

package/dist/cli.js

@@ -2376,13 +2376,80 @@ function runPack(workspaceRoot, dependencies = {}) {
   return status;
 }
 
-// src/ci-pipeline/release.use-case.ts
+// src/ci-pipeline/report-phase.use-case.ts
 var import_node_fs8 = require("fs");
+
+// src/ci-pipeline/phase-timing.algorithm.ts
+function formatDuration(milliseconds) {
+  const seconds = Math.max(0, milliseconds) / 1e3;
+  if (seconds < 60) {
+    return `${seconds.toFixed(1)}s`;
+  }
+  const whole = Math.round(seconds);
+  return `${Math.floor(whole / 60)}m ${String(whole % 60).padStart(2, "0")}s`;
+}
+function escapeCommandData(text) {
+  return text.replaceAll("%", "%25").replaceAll("\r", "%0D").replaceAll("\n", "%0A");
+}
+function describePhaseOutcome(host, phase, status, milliseconds) {
+  const took = formatDuration(milliseconds);
+  if (status === 0) {
+    return {
+      log: `mnci ci ${phase}: passed in ${took}`,
+      summary: `- \u2705 **${phase}** passed in ${took}`
+    };
+  }
+  const message = `The ${phase} phase failed with exit status ${status} after ${took}`;
+  let annotation;
+  if (host === "github") {
+    annotation = `::error title=mnci ci ${phase}::${escapeCommandData(message)}`;
+  } else if (host === "azure") {
+    annotation = `##vso[task.logissue type=error;]${message}`;
+  }
+  return {
+    log: `mnci ci ${phase}: failed (exit ${status}) in ${took}`,
+    annotation,
+    summary: `- \u274C **${phase}** failed (exit ${status}) after ${took}`
+  };
+}
+
+// src/ci-pipeline/report-phase.use-case.ts
+async function reportPhase(phase, run, dependencies = {}) {
+  const environment = dependencies.environment ?? process.env;
+  const log = dependencies.log ?? ((message) => {
+    console.log(message);
+  });
+  const clock = dependencies.clock ?? (() => Date.now());
+  const host = detectCiHost(environment);
+  const started = clock();
+  const finish = (status) => {
+    const outcome = describePhaseOutcome(host, phase, status, clock() - started);
+    log(outcome.log);
+    if (outcome.annotation !== void 0) {
+      log(outcome.annotation);
+    }
+    if (host === "github" && environment.GITHUB_STEP_SUMMARY) {
+      (0, import_node_fs8.appendFileSync)(environment.GITHUB_STEP_SUMMARY, `${outcome.summary}
+`);
+    }
+  };
+  try {
+    const status = await run();
+    finish(status);
+    return status;
+  } catch (error) {
+    finish(1);
+    throw error;
+  }
+}
+
+// src/ci-pipeline/release.use-case.ts
+var import_node_fs9 = require("fs");
 var import_node_path7 = require("path");
 var SPECIFIER = /^(?:major|minor|patch|\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)$/;
 function hasTag(workspaceRoot, relativePath, tag) {
   try {
-    const parsed = JSON.parse((0, import_node_fs8.readFileSync)((0, import_node_path7.join)(workspaceRoot, relativePath), "utf8"));
+    const parsed = JSON.parse((0, import_node_fs9.readFileSync)((0, import_node_path7.join)(workspaceRoot, relativePath), "utf8"));
     const tags = relativePath.endsWith("project.json") ? parsed.tags : parsed.nx?.tags;
     return Array.isArray(tags) && tags.includes(tag);
   } catch {
@@ -2391,12 +2458,12 @@ function hasTag(workspaceRoot, relativePath, tag) {
 }
 function releasableCounts(workspaceRoot) {
   return {
-    npm: (0, import_node_fs8.globSync)("packages/*/package.json", { cwd: workspaceRoot }).length,
-    csharp: (0, import_node_fs8.globSync)("packages/*/*.csproj", { cwd: workspaceRoot }).length,
-    python: (0, import_node_fs8.globSync)("python-packages/*/pyproject.toml", { cwd: workspaceRoot }).length,
-    dart: (0, import_node_fs8.globSync)("packages/*/pubspec.yaml", { cwd: workspaceRoot }).length,
-    vscode: (0, import_node_fs8.globSync)("apps/*/package.json", { cwd: workspaceRoot }).filter((path) => hasTag(workspaceRoot, path, VSCODE_EXTENSION_TAG)).length,
-    go: (0, import_node_fs8.globSync)("apps/*/project.json", { cwd: workspaceRoot }).filter((path) => hasTag(workspaceRoot, path, GO_RELEASE_TAG)).length
+    npm: (0, import_node_fs9.globSync)("packages/*/package.json", { cwd: workspaceRoot }).length,
+    csharp: (0, import_node_fs9.globSync)("packages/*/*.csproj", { cwd: workspaceRoot }).length,
+    python: (0, import_node_fs9.globSync)("python-packages/*/pyproject.toml", { cwd: workspaceRoot }).length,
+    dart: (0, import_node_fs9.globSync)("packages/*/pubspec.yaml", { cwd: workspaceRoot }).length,
+    vscode: (0, import_node_fs9.globSync)("apps/*/package.json", { cwd: workspaceRoot }).filter((path) => hasTag(workspaceRoot, path, VSCODE_EXTENSION_TAG)).length,
+    go: (0, import_node_fs9.globSync)("apps/*/project.json", { cwd: workspaceRoot }).filter((path) => hasTag(workspaceRoot, path, GO_RELEASE_TAG)).length
   };
 }
 function shallowCloneGuard(processes, log) {
@@ -2412,7 +2479,7 @@ function shallowCloneGuard(processes, log) {
   return 0;
 }
 function npmPreflight(workspaceRoot, registryKind, environment, processes, log) {
-  if (registryKind !== "npm" || (0, import_node_fs8.globSync)("packages/*/package.json", { cwd: workspaceRoot }).length === 0) {
+  if (registryKind !== "npm" || (0, import_node_fs9.globSync)("packages/*/package.json", { cwd: workspaceRoot }).length === 0) {
     return 0;
   }
   if (!environment.NODE_AUTH_TOKEN) {
@@ -2428,7 +2495,7 @@ function npmPreflight(workspaceRoot, registryKind, environment, processes, log)
   return 0;
 }
 async function pypiPreflight(workspaceRoot, registryKind, environment, log, fetchStatus) {
-  const files = (0, import_node_fs8.globSync)("python-packages/*/pyproject.toml", { cwd: workspaceRoot });
+  const files = (0, import_node_fs9.globSync)("python-packages/*/pyproject.toml", { cwd: workspaceRoot });
   if (registryKind !== "npm" || files.length === 0) {
     return 0;
   }
@@ -2441,7 +2508,7 @@ async function pypiPreflight(workspaceRoot, registryKind, environment, log, fetc
     return 1;
   }
   const names = files.map((file) => {
-    const text = (0, import_node_fs8.readFileSync)((0, import_node_path7.join)(workspaceRoot, file), "utf8");
+    const text = (0, import_node_fs9.readFileSync)((0, import_node_path7.join)(workspaceRoot, file), "utf8");
     const block = text.slice(text.indexOf("[project]"));
     const line = block.split("\n").find((entry) => entry.trimStart().startsWith("name"));
     return line ? line.split("=", 2)[1].replaceAll(/[^\w.-]/gi, "") : "";
@@ -2516,14 +2583,14 @@ function runReleaseCommand(workspaceRoot, registry, counts, environment, process
 }
 function nxPushesTags(workspaceRoot) {
   try {
-    const nx = JSON.parse((0, import_node_fs8.readFileSync)((0, import_node_path7.join)(workspaceRoot, "nx.json"), "utf8"));
+    const nx = JSON.parse((0, import_node_fs9.readFileSync)((0, import_node_path7.join)(workspaceRoot, "nx.json"), "utf8"));
     return nx.release?.git?.push === true;
   } catch {
     return false;
   }
 }
 function afterRelease(workspaceRoot, processes, githubReleases) {
-  if (githubReleases && (0, import_node_fs8.existsSync)((0, import_node_path7.join)(workspaceRoot, "tools", "go-app-release.cjs"))) {
+  if (githubReleases && (0, import_node_fs9.existsSync)((0, import_node_path7.join)(workspaceRoot, "tools", "go-app-release.cjs"))) {
     const assets = processes.run("node", ["tools/go-app-release.cjs", "assets"]);
     if (assets !== 0) {
       return assets;
@@ -2574,17 +2641,17 @@ async function runRelease(workspaceRoot, dependencies = {}) {
 }
 
 // src/ci-pipeline/setup.use-case.ts
-var import_node_fs11 = require("fs");
+var import_node_fs12 = require("fs");
 var import_node_path10 = require("path");
 
 // src/ci-pipeline/flutter-sdk.use-case.ts
-var import_node_fs9 = require("fs");
+var import_node_fs10 = require("fs");
 var import_node_path8 = require("path");
 function flutterSdkDirectory(machine) {
   return (0, import_node_path8.join)(machine.home, `.mnci-flutter-${FLUTTER_SDK_VERSION}`);
 }
 function installFlutterSdk(workspaceRoot, processes, log, machine) {
-  if (!(0, import_node_fs9.existsSync)((0, import_node_path8.join)(workspaceRoot, "pubspec.yaml"))) {
+  if (!(0, import_node_fs10.existsSync)((0, import_node_path8.join)(workspaceRoot, "pubspec.yaml"))) {
     log("No Flutter projects - skipping.");
     return 0;
   }
@@ -2593,26 +2660,26 @@ function installFlutterSdk(workspaceRoot, processes, log, machine) {
     return 0;
   }
   const sdk = flutterSdkDirectory(machine);
-  if ((0, import_node_fs9.existsSync)(sdk)) {
+  if ((0, import_node_fs10.existsSync)(sdk)) {
     log(`Flutter SDK already installed at ${sdk} - skipping.`);
     return 0;
   }
   return processes.run("git", ["clone", "--depth", "1", "--branch", FLUTTER_SDK_VERSION, "https://github.com/flutter/flutter.git", sdk]);
 }
 function publishFlutterSdk(workspaceRoot, host, environment, log, machine) {
-  if (!(0, import_node_fs9.existsSync)((0, import_node_path8.join)(workspaceRoot, "pubspec.yaml"))) {
+  if (!(0, import_node_fs10.existsSync)((0, import_node_path8.join)(workspaceRoot, "pubspec.yaml"))) {
     log("No Flutter projects - skipping.");
     return;
   }
   const sdk = flutterSdkDirectory(machine);
-  if (!(0, import_node_fs9.existsSync)(sdk)) {
+  if (!(0, import_node_fs10.existsSync)(sdk)) {
     log("Flutter SDK was not installed by mnci (already on PATH) - skipping.");
     return;
   }
   addToPath(host, environment, (0, import_node_path8.join)(sdk, "bin"), log);
 }
 function resolveDartDependencies(workspaceRoot, processes, log) {
-  if (!(0, import_node_fs9.existsSync)((0, import_node_path8.join)(workspaceRoot, "pubspec.yaml"))) {
+  if (!(0, import_node_fs10.existsSync)((0, import_node_path8.join)(workspaceRoot, "pubspec.yaml"))) {
     log("No Flutter projects - skipping.");
     return 0;
   }
@@ -2621,7 +2688,7 @@ function resolveDartDependencies(workspaceRoot, processes, log) {
 
 // src/ci-pipeline/go-tools.use-case.ts
 var import_node_crypto = require("crypto");
-var import_node_fs10 = require("fs");
+var import_node_fs11 = require("fs");
 var import_node_os = require("os");
 var import_node_path9 = require("path");
 function currentMachine() {
@@ -2629,7 +2696,7 @@ function currentMachine() {
 }
 var GOLANGCI_LINT_MODULE = "github.com/golangci/golangci-lint/v2/cmd/golangci-lint";
 function downloadGoModules(workspaceRoot, processes, log) {
-  if (!(0, import_node_fs10.existsSync)((0, import_node_path9.join)(workspaceRoot, "go.mod"))) {
+  if (!(0, import_node_fs11.existsSync)((0, import_node_path9.join)(workspaceRoot, "go.mod"))) {
     log("No Go projects - skipping.");
     return 0;
   }
@@ -2637,7 +2704,7 @@ function downloadGoModules(workspaceRoot, processes, log) {
 }
 async function installGolangciLint(workspaceRoot, dependencies, machine) {
   const { processes, log, fetchBytes } = dependencies;
-  if (!(0, import_node_fs10.existsSync)((0, import_node_path9.join)(workspaceRoot, "go.mod"))) {
+  if (!(0, import_node_fs11.existsSync)((0, import_node_path9.join)(workspaceRoot, "go.mod"))) {
     log("No Go projects - skipping.");
     return 0;
   }
@@ -2674,30 +2741,30 @@ async function installGolangciLint(workspaceRoot, dependencies, machine) {
     if ((0, import_node_crypto.createHash)("sha256").update(archive).digest("hex") !== entry[0]) {
       throw new Error(`checksum mismatch for ${file}`);
     }
-    temporary = (0, import_node_fs10.mkdtempSync)((0, import_node_path9.join)((0, import_node_os.tmpdir)(), "golangci-lint-"));
+    temporary = (0, import_node_fs11.mkdtempSync)((0, import_node_path9.join)((0, import_node_os.tmpdir)(), "golangci-lint-"));
     const archivePath = (0, import_node_path9.join)(temporary, file);
-    (0, import_node_fs10.writeFileSync)(archivePath, archive);
+    (0, import_node_fs11.writeFileSync)(archivePath, archive);
     const tar = platform === "windows" ? (0, import_node_path9.join)(process.env.SystemRoot ?? "", "System32", "tar.exe") : "tar";
     if (processes.run(tar, ["-xf", archivePath, "-C", temporary]) !== 0) {
       throw new Error(`could not extract ${file}`);
     }
     const executable = `golangci-lint${platform === "windows" ? ".exe" : ""}`;
     const bin = (0, import_node_path9.join)(gopath.stdout.trim(), "bin");
-    (0, import_node_fs10.mkdirSync)(bin, { recursive: true });
-    (0, import_node_fs10.copyFileSync)((0, import_node_path9.join)(temporary, name, executable), (0, import_node_path9.join)(bin, executable));
-    (0, import_node_fs10.chmodSync)((0, import_node_path9.join)(bin, executable), 493);
+    (0, import_node_fs11.mkdirSync)(bin, { recursive: true });
+    (0, import_node_fs11.copyFileSync)((0, import_node_path9.join)(temporary, name, executable), (0, import_node_path9.join)(bin, executable));
+    (0, import_node_fs11.chmodSync)((0, import_node_path9.join)(bin, executable), 493);
     log(`golangci-lint ${version} installed from its checksum-verified prebuilt release into ${bin}`);
     return 0;
   } catch (error) {
     return fallback(error instanceof Error ? error.message : String(error));
   } finally {
     if (temporary !== void 0) {
-      (0, import_node_fs10.rmSync)(temporary, { recursive: true, force: true });
+      (0, import_node_fs11.rmSync)(temporary, { recursive: true, force: true });
     }
   }
 }
 function publishGoTools(workspaceRoot, host, environment, processes, log) {
-  if (!(0, import_node_fs10.existsSync)((0, import_node_path9.join)(workspaceRoot, "go.mod"))) {
+  if (!(0, import_node_fs11.existsSync)((0, import_node_path9.join)(workspaceRoot, "go.mod"))) {
     log("No Go projects - skipping.");
     return;
   }
@@ -2714,15 +2781,15 @@ function pythonCommand(machine) {
   return machine.platform === "win32" ? "python" : "python3";
 }
 function installPythonToolchain(workspaceRoot, processes, log, machine) {
-  if (!(0, import_node_fs11.existsSync)((0, import_node_path10.join)(workspaceRoot, "requirements-dev.txt"))) {
+  if (!(0, import_node_fs12.existsSync)((0, import_node_path10.join)(workspaceRoot, "requirements-dev.txt"))) {
     log("No Python projects - skipping.");
     return 0;
   }
   return processes.run(pythonCommand(machine), ["-m", "pip", "install", "-r", "requirements-dev.txt"]);
 }
 function installPythonProjects(workspaceRoot, processes, log, machine) {
-  const editable = ["apps/*/pyproject.toml", "python-packages/*/pyproject.toml", "libs/*/pyproject.toml"].flatMap((pattern) => (0, import_node_fs11.globSync)(pattern, { cwd: workspaceRoot })).map((path) => (0, import_node_path10.dirname)(path));
-  const requirements = (0, import_node_fs11.globSync)("apps/*/requirements.txt", { cwd: workspaceRoot });
+  const editable = ["apps/*/pyproject.toml", "python-packages/*/pyproject.toml", "libs/*/pyproject.toml"].flatMap((pattern) => (0, import_node_fs12.globSync)(pattern, { cwd: workspaceRoot })).map((path) => (0, import_node_path10.dirname)(path));
+  const requirements = (0, import_node_fs12.globSync)("apps/*/requirements.txt", { cwd: workspaceRoot });
   if (editable.length === 0 && requirements.length === 0) {
     log("No Python projects - skipping.");
     return 0;
@@ -2841,6 +2908,9 @@ function runVerify(workspaceRoot, dependencies = {}) {
 // src/ci-pipeline/index.ts
 var CI_PHASES = ["setup", "audit", "verify", "pack", "release", "native"];
 function runCiPhase(phase, workspaceRoot, dependencies = {}) {
+  return reportPhase(phase, () => runPhase(phase, workspaceRoot, dependencies), dependencies);
+}
+function runPhase(phase, workspaceRoot, dependencies) {
   switch (phase) {
     case "verify": {
       return runVerify(workspaceRoot, dependencies);
@@ -2877,7 +2947,7 @@ function assertValidProjectName(name, label) {
 }
 
 // src/project-scaffolding/csharp.use-case.ts
-var import_node_fs13 = require("fs");
+var import_node_fs14 = require("fs");
 var import_node_path12 = require("path");
 
 // src/project-scaffolding/csharp-example.algorithm.ts
@@ -2919,7 +2989,7 @@ public class GreetUseCaseTests
 }
 
 // src/project-scaffolding/post-generation.use-case.ts
-var import_node_fs12 = require("fs");
+var import_node_fs13 = require("fs");
 var import_node_path11 = require("path");
 function hasPlugin(workspaceRoot, packageName) {
   const manifest = readJson((0, import_node_path11.join)(workspaceRoot, "package.json"));
@@ -2982,11 +3052,11 @@ function removeStaleGitkeeps(workspaceRoot) {
   for (const scaffold of ["apps", "libs", "packages"]) {
     const directory = (0, import_node_path11.join)(workspaceRoot, scaffold);
     try {
-      const holdsAProject = (0, import_node_fs12.readdirSync)(directory, { withFileTypes: true }).some(
+      const holdsAProject = (0, import_node_fs13.readdirSync)(directory, { withFileTypes: true }).some(
         (entry) => entry.isDirectory()
       );
       if (holdsAProject) {
-        (0, import_node_fs12.rmSync)((0, import_node_path11.join)(directory, ".gitkeep"), { force: true });
+        (0, import_node_fs13.rmSync)((0, import_node_path11.join)(directory, ".gitkeep"), { force: true });
       }
     } catch {
     }
@@ -3034,13 +3104,13 @@ var ESLINT_CONFIG_FILENAMES = [
 ];
 function removeGeneratedEslintConfig(workspaceRoot, projectRoot) {
   for (const filename of ESLINT_CONFIG_FILENAMES) {
-    (0, import_node_fs12.rmSync)((0, import_node_path11.join)(workspaceRoot, projectRoot, filename), { force: true });
+    (0, import_node_fs13.rmSync)((0, import_node_path11.join)(workspaceRoot, projectRoot, filename), { force: true });
   }
-  (0, import_node_fs12.rmSync)((0, import_node_path11.join)(workspaceRoot, ".vscode"), { recursive: true, force: true });
+  (0, import_node_fs13.rmSync)((0, import_node_path11.join)(workspaceRoot, ".vscode"), { recursive: true, force: true });
 }
 function findCodeWorkspaceFile(workspaceRoot) {
   try {
-    const entry = (0, import_node_fs12.readdirSync)(workspaceRoot).find((file) => file.endsWith(".code-workspace"));
+    const entry = (0, import_node_fs13.readdirSync)(workspaceRoot).find((file) => file.endsWith(".code-workspace"));
     return entry ? (0, import_node_path11.join)(workspaceRoot, entry) : void 0;
   } catch {
     return void 0;
@@ -3059,7 +3129,7 @@ function reshapeReactScaffold(projectRoot, name, empty = false) {
 }
 function reshapeReactAppScaffold(projectRoot) {
   const appDir = (0, import_node_path11.join)(projectRoot, "src", "app");
-  if (!(0, import_node_fs12.existsSync)((0, import_node_path11.join)(appDir, "app.tsx"))) {
+  if (!(0, import_node_fs13.existsSync)((0, import_node_path11.join)(appDir, "app.tsx"))) {
     return;
   }
   for (const [from, to] of [
@@ -3067,13 +3137,13 @@ function reshapeReactAppScaffold(projectRoot) {
     ["app.spec.tsx", "app.component.spec.tsx"],
     ["nx-welcome.tsx", "nx-welcome.component.tsx"]
   ]) {
-    if ((0, import_node_fs12.existsSync)((0, import_node_path11.join)(appDir, from))) {
-      (0, import_node_fs12.renameSync)((0, import_node_path11.join)(appDir, from), (0, import_node_path11.join)(appDir, to));
+    if ((0, import_node_fs13.existsSync)((0, import_node_path11.join)(appDir, from))) {
+      (0, import_node_fs13.renameSync)((0, import_node_path11.join)(appDir, from), (0, import_node_path11.join)(appDir, to));
     }
   }
   const rewrite = (file, from, to) => {
-    if ((0, import_node_fs12.existsSync)(file)) {
-      writeFileEnsured(file, repointSpecifier((0, import_node_fs12.readFileSync)(file, "utf8"), from, to));
+    if ((0, import_node_fs13.existsSync)(file)) {
+      writeFileEnsured(file, repointSpecifier((0, import_node_fs13.readFileSync)(file, "utf8"), from, to));
     }
   };
   rewrite((0, import_node_path11.join)(appDir, "app.component.tsx"), "./nx-welcome", "./nx-welcome.component");
@@ -3085,8 +3155,8 @@ function reshapeReactAppScaffold(projectRoot) {
   );
 }
 function emptySlice(projectRoot, sliceDir) {
-  for (const entry of (0, import_node_fs12.readdirSync)(sliceDir)) {
-    (0, import_node_fs12.rmSync)((0, import_node_path11.join)(sliceDir, entry), { recursive: true, force: true });
+  for (const entry of (0, import_node_fs13.readdirSync)(sliceDir)) {
+    (0, import_node_fs13.rmSync)((0, import_node_path11.join)(sliceDir, entry), { recursive: true, force: true });
   }
   writeFileEnsured((0, import_node_path11.join)(sliceDir, "index.ts"), "export {}\n");
   addNxTargets((0, import_node_path11.join)(projectRoot, "package.json"), { test: { options: { passWithNoTests: true } } });
@@ -3094,33 +3164,33 @@ function emptySlice(projectRoot, sliceDir) {
 function reshapeScaffoldSlice(projectRoot, name, extension, role, empty) {
   const sourceDir = (0, import_node_path11.join)(projectRoot, "src");
   const libDir = (0, import_node_path11.join)(sourceDir, "lib");
-  if (!(0, import_node_fs12.existsSync)((0, import_node_path11.join)(libDir, `${name}.${extension}`))) {
+  if (!(0, import_node_fs13.existsSync)((0, import_node_path11.join)(libDir, `${name}.${extension}`))) {
     return;
   }
   const sliceDir = (0, import_node_path11.join)(sourceDir, name);
-  (0, import_node_fs12.mkdirSync)(sliceDir, { recursive: true });
-  for (const entry of (0, import_node_fs12.readdirSync)(libDir)) {
+  (0, import_node_fs13.mkdirSync)(sliceDir, { recursive: true });
+  for (const entry of (0, import_node_fs13.readdirSync)(libDir)) {
     if (entry === `${name}.${extension}`) {
-      (0, import_node_fs12.renameSync)((0, import_node_path11.join)(libDir, entry), (0, import_node_path11.join)(sliceDir, `${name}.${role}.${extension}`));
+      (0, import_node_fs13.renameSync)((0, import_node_path11.join)(libDir, entry), (0, import_node_path11.join)(sliceDir, `${name}.${role}.${extension}`));
     } else if (entry === `${name}.spec.${extension}`) {
       const renamed = (0, import_node_path11.join)(sliceDir, `${name}.${role}.spec.${extension}`);
-      (0, import_node_fs12.renameSync)((0, import_node_path11.join)(libDir, entry), renamed);
-      writeFileEnsured(renamed, repointSpecifier((0, import_node_fs12.readFileSync)(renamed, "utf8"), `./${name}`, `./${name}.${role}`));
+      (0, import_node_fs13.renameSync)((0, import_node_path11.join)(libDir, entry), renamed);
+      writeFileEnsured(renamed, repointSpecifier((0, import_node_fs13.readFileSync)(renamed, "utf8"), `./${name}`, `./${name}.${role}`));
     } else {
-      (0, import_node_fs12.renameSync)((0, import_node_path11.join)(libDir, entry), (0, import_node_path11.join)(sliceDir, entry));
+      (0, import_node_fs13.renameSync)((0, import_node_path11.join)(libDir, entry), (0, import_node_path11.join)(sliceDir, entry));
     }
   }
   const barrel = (0, import_node_path11.join)(sourceDir, "index.ts");
-  const esm = (0, import_node_fs12.existsSync)(barrel) && (0, import_node_fs12.readFileSync)(barrel, "utf8").includes(`./lib/${name}.js'`);
+  const esm = (0, import_node_fs13.existsSync)(barrel) && (0, import_node_fs13.readFileSync)(barrel, "utf8").includes(`./lib/${name}.js'`);
   writeFileEnsured((0, import_node_path11.join)(sliceDir, "index.ts"), `export * from './${name}.${role}${esm ? ".js" : ""}'
 `);
-  if ((0, import_node_fs12.existsSync)(barrel)) {
+  if ((0, import_node_fs13.existsSync)(barrel)) {
     writeFileEnsured(
       barrel,
-      (0, import_node_fs12.readFileSync)(barrel, "utf8").replaceAll(`./lib/${name}.js'`, () => `./${name}/index.js'`).replaceAll(`./lib/${name}'`, () => `./${name}'`)
+      (0, import_node_fs13.readFileSync)(barrel, "utf8").replaceAll(`./lib/${name}.js'`, () => `./${name}/index.js'`).replaceAll(`./lib/${name}'`, () => `./${name}'`)
     );
   }
-  (0, import_node_fs12.rmSync)(libDir, { recursive: true, force: true });
+  (0, import_node_fs13.rmSync)(libDir, { recursive: true, force: true });
   if (empty) {
     emptySlice(projectRoot, sliceDir);
   } else if (role === "use-case") {
@@ -3183,7 +3253,7 @@ function repointSpecifier(source, from, to) {
 }
 function ensureNxPeerOverrides(workspaceRoot) {
   const manifestPath = (0, import_node_path11.join)(workspaceRoot, "package.json");
-  if (!(0, import_node_fs12.existsSync)(manifestPath)) {
+  if (!(0, import_node_fs13.existsSync)(manifestPath)) {
     return;
   }
   const manifest = readJson(manifestPath);
@@ -3207,7 +3277,7 @@ function registerProjectCommands(workspaceRoot, name, commands) {
     scripts[`${name}:start`] = commands.start;
   }
   const dependabotPath = (0, import_node_path11.join)(workspaceRoot, ".github/dependabot.yml");
-  if ((0, import_node_fs12.existsSync)(dependabotPath)) {
+  if ((0, import_node_fs13.existsSync)(dependabotPath)) {
     writeFileEnsured(dependabotPath, dependabotConfig(workspaceRoot));
   }
   const manifestPath = (0, import_node_path11.join)(workspaceRoot, "package.json");
@@ -3314,7 +3384,7 @@ function scaffoldDotnetProject(workspaceRoot, projectRoot, identity, template) {
 }
 function writeCsharpExample(absoluteRoot, identity, kind) {
   if (kind === "classlib") {
-    (0, import_node_fs13.rmSync)((0, import_node_path12.join)(absoluteRoot, "Class1.cs"), { force: true });
+    (0, import_node_fs14.rmSync)((0, import_node_path12.join)(absoluteRoot, "Class1.cs"), { force: true });
   }
   const files = csharpExampleFiles(identity);
   for (const [file, contents] of Object.entries(files)) {
@@ -3328,7 +3398,7 @@ function addCsharpTestProject(workspaceRoot, projectRoot, identity) {
   const name = (0, import_node_path12.basename)(projectRoot);
   const testRoot = `tests/${name}`;
   scaffoldDotnetProject(workspaceRoot, testRoot, `${identity}.Tests`, "xunit");
-  (0, import_node_fs13.rmSync)((0, import_node_path12.join)(workspaceRoot, testRoot, "UnitTest1.cs"), { force: true });
+  (0, import_node_fs14.rmSync)((0, import_node_path12.join)(workspaceRoot, testRoot, "UnitTest1.cs"), { force: true });
   writeFileEnsured((0, import_node_path12.join)(workspaceRoot, testRoot, "GreetUseCaseTests.cs"), csharpExampleTest(identity));
   writeFileEnsured(
     (0, import_node_path12.join)(workspaceRoot, testRoot, "project.json"),
@@ -3472,7 +3542,7 @@ function addProjectJsonReleaseVersionActions(projectJsonPath) {
   );
 }
 function addInitialVersion(csprojPath) {
-  const contents = (0, import_node_fs13.readFileSync)(csprojPath, "utf8");
+  const contents = (0, import_node_fs14.readFileSync)(csprojPath, "utf8");
   writeFileEnsured(csprojPath, contents.replace("<PropertyGroup>", "<PropertyGroup>\n    <Version>0.1.0</Version>"));
 }
 function csharpLibPublishTarget(projectRoot) {
@@ -3648,7 +3718,7 @@ function addFlutterInternalLib(workspaceRoot, name) {
 }
 
 // src/project-scaffolding/go.use-case.ts
-var import_node_fs17 = require("fs");
+var import_node_fs18 = require("fs");
 var import_node_path17 = require("path");
 
 // src/project-scaffolding/go-example.algorithm.ts
@@ -3718,14 +3788,14 @@ function goAppExampleFiles(modulePath) {
 }
 
 // src/go-workspace/go-plugin.use-case.ts
-var import_node_fs14 = require("fs");
+var import_node_fs15 = require("fs");
 var import_node_path14 = require("path");
 var NX_GO_PLUGIN = "@nx-go/nx-go";
 function hasGoProject(workspaceRoot) {
-  const projectFiles = ["apps", "libs", "packages"].flatMap((directory) => (0, import_node_fs14.globSync)(`${directory}/*/project.json`, { cwd: workspaceRoot }));
+  const projectFiles = ["apps", "libs", "packages"].flatMap((directory) => (0, import_node_fs15.globSync)(`${directory}/*/project.json`, { cwd: workspaceRoot }));
   return projectFiles.some((projectFile) => {
     try {
-      const { tags } = JSON.parse((0, import_node_fs14.readFileSync)((0, import_node_path14.join)(workspaceRoot, projectFile), "utf8"));
+      const { tags } = JSON.parse((0, import_node_fs15.readFileSync)((0, import_node_path14.join)(workspaceRoot, projectFile), "utf8"));
       return (tags ?? []).some((tag) => tag.startsWith("type:go-"));
     } catch {
       return false;
@@ -3784,7 +3854,7 @@ function registerNxGoPlugin(workspaceRoot) {
 }
 
 // src/project-scaffolding/go-release.use-case.ts
-var import_node_fs15 = require("fs");
+var import_node_fs16 = require("fs");
 var import_node_path15 = require("path");
 var GO_RELEASE_SCRIPT_PATH = "tools/go-app-release.cjs";
 var GO_RELEASE_SCRIPT = String.raw`#!/usr/bin/env node
@@ -3938,7 +4008,7 @@ function refreshGoReleaseScript(workspaceRoot) {
   const apps = (0, import_node_path15.join)(workspaceRoot, "apps");
   let entries;
   try {
-    entries = (0, import_node_fs15.readdirSync)(apps);
+    entries = (0, import_node_fs16.readdirSync)(apps);
   } catch {
     return false;
   }
@@ -3947,7 +4017,7 @@ function refreshGoReleaseScript(workspaceRoot) {
     return fileExists(projectJsonPath) && (readJson(projectJsonPath).tags ?? []).includes(GO_RELEASE_TAG);
   });
   const path = (0, import_node_path15.join)(workspaceRoot, GO_RELEASE_SCRIPT_PATH);
-  if (!hasReleasableApp || fileExists(path) && (0, import_node_fs15.readFileSync)(path, "utf8") === GO_RELEASE_SCRIPT) {
+  if (!hasReleasableApp || fileExists(path) && (0, import_node_fs16.readFileSync)(path, "utf8") === GO_RELEASE_SCRIPT) {
     return false;
   }
   writeFileEnsured(path, GO_RELEASE_SCRIPT);
@@ -3955,7 +4025,7 @@ function refreshGoReleaseScript(workspaceRoot) {
 }
 
 // src/project-scaffolding/go-web.use-case.ts
-var import_node_fs16 = require("fs");
+var import_node_fs17 = require("fs");
 var import_node_path16 = require("path");
 var TARGETS_NEEDING_THE_FRONTEND = ["build", "test", "lint", "start", "build-all", "build-native"];
 var DEFAULT_ADDRESS = "127.0.0.1:8080";
@@ -4035,7 +4105,7 @@ func TestWebHandlerServesTheBuiltFrontend(t *testing.T) {
 `;
 function assertWebApp(workspaceRoot, web) {
   const directory = (0, import_node_path16.join)(workspaceRoot, "apps", web);
-  const isReactApp = fileExists((0, import_node_path16.join)(directory, "package.json")) && (0, import_node_fs16.readdirSync)(directory).some((entry) => entry.startsWith("vite.config."));
+  const isReactApp = fileExists((0, import_node_path16.join)(directory, "package.json")) && (0, import_node_fs17.readdirSync)(directory).some((entry) => entry.startsWith("vite.config."));
   if (!isReactApp) {
     throw new Error(`--web ${web}: no React app at apps/${web}. Add it first with \`mnci add react-app ${web}\`.`);
   }
@@ -4045,7 +4115,7 @@ function webProjectName(workspaceRoot, web) {
   return manifest.nx?.name ?? manifest.name ?? web;
 }
 function addApiProxy(viteConfigPath) {
-  const source = (0, import_node_fs16.readFileSync)(viteConfigPath, "utf8");
+  const source = (0, import_node_fs17.readFileSync)(viteConfigPath, "utf8");
   if (source.includes("'/api'") || source.includes('"/api"')) {
     return false;
   }
@@ -4089,7 +4159,7 @@ function wireGoAppToWeb(workspaceRoot, name, web) {
   writeFileEnsured((0, import_node_path16.join)(directory, "web.go"), GO_WEB_SOURCE);
   writeFileEnsured((0, import_node_path16.join)(directory, "main.go"), GO_WEB_MAIN);
   writeFileEnsured((0, import_node_path16.join)(directory, "main_test.go"), GO_WEB_MAIN_TEST);
-  const viteConfig = (0, import_node_fs16.readdirSync)((0, import_node_path16.join)(workspaceRoot, "apps", web)).find((entry) => entry.startsWith("vite.config."));
+  const viteConfig = (0, import_node_fs17.readdirSync)((0, import_node_path16.join)(workspaceRoot, "apps", web)).find((entry) => entry.startsWith("vite.config."));
   if (viteConfig === void 0 || !addApiProxy((0, import_node_path16.join)(workspaceRoot, "apps", web, viteConfig))) {
     logger.warn(
       `Could not add the /api proxy to apps/${web}'s Vite config: add \`server: { proxy: { '/api': 'http://${DEFAULT_ADDRESS}' } }\` yourself, so \`nx run ${name}:dev\` reaches the Go server.`
@@ -4132,7 +4202,7 @@ function ensureGoModule(workspaceRoot) {
 }
 function readGoModModule(goModPath) {
   try {
-    return /^module\s+(\S+)/m.exec((0, import_node_fs17.readFileSync)(goModPath, "utf8"))?.[1];
+    return /^module\s+(\S+)/m.exec((0, import_node_fs18.readFileSync)(goModPath, "utf8"))?.[1];
   } catch {
     return void 0;
   }
@@ -4151,16 +4221,16 @@ function setGoModulePath(workspaceRoot, projectDir) {
   if (prefix === void 0 || !fileExists(goModPath)) {
     return;
   }
-  const rewritten = (0, import_node_fs17.readFileSync)(goModPath, "utf8").replace(/^module\s+\S+/m, () => `module ${prefix}/${projectDir}`);
+  const rewritten = (0, import_node_fs18.readFileSync)(goModPath, "utf8").replace(/^module\s+\S+/m, () => `module ${prefix}/${projectDir}`);
   writeFileEnsured(goModPath, rewritten);
 }
 function writeGoAppExample(workspaceRoot, projectDir) {
   const goModPath = (0, import_node_path17.join)(workspaceRoot, projectDir, "go.mod");
-  const modulePath = fileExists(goModPath) ? /^module\s+(\S+)/m.exec((0, import_node_fs17.readFileSync)(goModPath, "utf8"))?.[1] : void 0;
+  const modulePath = fileExists(goModPath) ? /^module\s+(\S+)/m.exec((0, import_node_fs18.readFileSync)(goModPath, "utf8"))?.[1] : void 0;
   if (modulePath === void 0) {
     return;
   }
-  (0, import_node_fs17.rmSync)((0, import_node_path17.join)(workspaceRoot, projectDir, "main_test.go"), { force: true });
+  (0, import_node_fs18.rmSync)((0, import_node_path17.join)(workspaceRoot, projectDir, "main_test.go"), { force: true });
   const example = goAppExampleFiles(modulePath);
   for (const [relative, contents] of Object.entries(example)) {
     writeFileEnsured((0, import_node_path17.join)(workspaceRoot, projectDir, relative), contents);
@@ -4245,12 +4315,12 @@ function addGoPlatformTargets(workspaceRoot) {
   if (!fileExists(apps)) {
     return changed;
   }
-  for (const name of (0, import_node_fs17.readdirSync)(apps)) {
+  for (const name of (0, import_node_fs18.readdirSync)(apps)) {
     const projectJsonPath = (0, import_node_path17.join)(apps, name, "project.json");
     if (!fileExists(projectJsonPath)) {
       continue;
     }
-    const project = JSON.parse((0, import_node_fs17.readFileSync)(projectJsonPath, "utf8"));
+    const project = JSON.parse((0, import_node_fs18.readFileSync)(projectJsonPath, "utf8"));
     const tag = (project.tags ?? []).find((each) => each === "type:go-app" || each === "type:go-function-app")?.slice("type:".length);
     if (tag === void 0 || (project.tags ?? []).includes(GO_CGO_TAG)) {
       continue;
@@ -4286,8 +4356,8 @@ function goLibraryIdentifiers(projectName) {
 }
 function reshapeGoLibraryScaffold(projectRoot, projectName) {
   const { packageName, fileStem } = goLibraryIdentifiers(projectName);
-  (0, import_node_fs17.rmSync)((0, import_node_path17.join)(projectRoot, `${projectName}.go`), { force: true });
-  (0, import_node_fs17.rmSync)((0, import_node_path17.join)(projectRoot, `${projectName}_test.go`), { force: true });
+  (0, import_node_fs18.rmSync)((0, import_node_path17.join)(projectRoot, `${projectName}.go`), { force: true });
+  (0, import_node_fs18.rmSync)((0, import_node_path17.join)(projectRoot, `${projectName}_test.go`), { force: true });
   const files = [
     [
       "doc.go",
@@ -4775,7 +4845,7 @@ function addNodeFunctionApp(workspaceRoot, name, stack, empty = false) {
 var import_node_path22 = require("path");
 
 // src/rollup-library/repair-publishable-manifest.use-case.ts
-var import_node_fs18 = require("fs");
+var import_node_fs19 = require("fs");
 var import_node_path19 = require("path");
 var WRONG_TYPES_PATH = "./dist/index.esm.d.ts";
 var ACTUAL_TYPES_PATH = "./dist/src/index.d.ts";
@@ -4799,14 +4869,14 @@ function repairPublishableManifest(manifestPath) {
 }
 function repairPublishableManifests(workspaceRoot) {
   const changed = [];
-  const manifests = (0, import_node_fs18.globSync)(["packages/*/package.json", "libs/*/package.json"], {
+  const manifests = (0, import_node_fs19.globSync)(["packages/*/package.json", "libs/*/package.json"], {
     cwd: workspaceRoot
   });
   for (const relativePath of manifests) {
     const manifestPath = (0, import_node_path19.join)(workspaceRoot, relativePath);
-    const before = (0, import_node_fs18.readFileSync)(manifestPath, "utf8");
+    const before = (0, import_node_fs19.readFileSync)(manifestPath, "utf8");
     repairPublishableManifest(manifestPath);
-    const after = (0, import_node_fs18.readFileSync)(manifestPath, "utf8");
+    const after = (0, import_node_fs19.readFileSync)(manifestPath, "utf8");
     if (after !== before) {
       changed.push(relativePath.replaceAll("\\", "/"));
     }
@@ -4815,7 +4885,7 @@ function repairPublishableManifests(workspaceRoot) {
 }
 
 // src/rollup-library/repair-rollup-config.use-case.ts
-var import_node_fs19 = require("fs");
+var import_node_fs20 = require("fs");
 var import_node_path20 = require("path");
 
 // src/rollup-library/rollup-config.algorithm.ts
@@ -5018,12 +5088,12 @@ function withUpgradedDeclarationSpecifierPlugin(config) {
 // src/rollup-library/repair-rollup-config.use-case.ts
 function repairRollupSourceMaps(workspaceRoot) {
   const changed = [];
-  const configs = (0, import_node_fs19.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
+  const configs = (0, import_node_fs20.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
     cwd: workspaceRoot
   });
   for (const relativePath of configs) {
     const configPath = (0, import_node_path20.join)(workspaceRoot, relativePath);
-    const before = (0, import_node_fs19.readFileSync)(configPath, "utf8");
+    const before = (0, import_node_fs20.readFileSync)(configPath, "utf8");
     const after = withRollupSourceMaps(before);
     if (after !== before) {
       writeFileEnsured(configPath, after);
@@ -5034,12 +5104,12 @@ function repairRollupSourceMaps(workspaceRoot) {
 }
 function upgradeDeclarationSpecifierPlugins(workspaceRoot) {
   const changed = [];
-  const configs = (0, import_node_fs19.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
+  const configs = (0, import_node_fs20.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
     cwd: workspaceRoot
   });
   for (const relativePath of configs) {
     const configPath = (0, import_node_path20.join)(workspaceRoot, relativePath);
-    const before = (0, import_node_fs19.readFileSync)(configPath, "utf8");
+    const before = (0, import_node_fs20.readFileSync)(configPath, "utf8");
     const after = withUpgradedDeclarationSpecifierPlugin(before);
     if (after !== before) {
       writeFileEnsured(configPath, after);
@@ -5053,7 +5123,7 @@ function repairDeclarationSpecifiers(projectRoot) {
   if (!fileExists(configPath)) {
     return;
   }
-  const config = (0, import_node_fs19.readFileSync)(configPath, "utf8");
+  const config = (0, import_node_fs20.readFileSync)(configPath, "utf8");
   if (!config.includes(ROLLUP_CONFIG_PLACEHOLDER)) {
     return;
   }
@@ -5062,7 +5132,7 @@ function repairDeclarationSpecifiers(projectRoot) {
 }
 
 // src/rollup-library/rollup-config.repository.ts
-var import_node_fs20 = require("fs");
+var import_node_fs21 = require("fs");
 var import_node_path21 = require("path");
 function resolveRequireTarget(fromDir, specifier) {
   const base = (0, import_node_path21.join)(fromDir, specifier);
@@ -5075,7 +5145,7 @@ function resolveRollupConfigText(configPath, visited = /* @__PURE__ */ new Set()
   visited.add(configPath);
   let text;
   try {
-    text = (0, import_node_fs20.readFileSync)(configPath, "utf8");
+    text = (0, import_node_fs21.readFileSync)(configPath, "utf8");
   } catch {
     return "";
   }
@@ -5120,7 +5190,7 @@ async function addNpmLib(workspaceRoot, name, options, kindProvided, stack) {
 }
 
 // src/project-scaffolding/python.use-case.ts
-var import_node_fs21 = require("fs");
+var import_node_fs22 = require("fs");
 var import_node_path23 = require("path");
 function ensurePython(workspaceRoot) {
   const hasPython = runShell("python3", ["--version"], workspaceRoot) === 0 || runShell("python", ["--version"], workspaceRoot) === 0;
@@ -5339,7 +5409,7 @@ async function addPythonVendor(workspaceRoot, consumer, options, kindProvided) {
     throw new Error(`'${consumer}' cannot vendor itself.`);
   }
   const pyprojectPath = (0, import_node_path23.join)(workspaceRoot, consumerDirectory, consumer, "pyproject.toml");
-  const pyprojectToml = (0, import_node_fs21.readFileSync)(pyprojectPath, "utf8");
+  const pyprojectToml = (0, import_node_fs22.readFileSync)(pyprojectPath, "utf8");
   if (parseVendorEntries(pyprojectToml).includes(lib)) {
     logger.info(`'${consumer}' already vendors '${lib}' \u2014 nothing to do.`);
     return;
@@ -5351,7 +5421,7 @@ async function addPythonVendor(workspaceRoot, consumer, options, kindProvided) {
 }
 
 // src/project-scaffolding/react-app.use-case.ts
-var import_node_fs22 = require("fs");
+var import_node_fs23 = require("fs");
 var import_node_path24 = require("path");
 
 // src/project-scaffolding/react-app-example.algorithm.ts
@@ -5474,7 +5544,7 @@ function allowEnvFiles(workspaceRoot) {
     return;
   }
   const marker = "# MoNecromanCI: keep the committed per-environment Vite config (public VITE_ values)";
-  const current = (0, import_node_fs22.readFileSync)(gitignorePath, "utf8");
+  const current = (0, import_node_fs23.readFileSync)(gitignorePath, "utf8");
   if (current.includes(marker)) {
     return;
   }
@@ -5508,7 +5578,7 @@ function addReactApp(workspaceRoot, name, stack) {
   allowEnvFiles(workspaceRoot);
   addNxTargets((0, import_node_path24.join)(reactAppRoot, "package.json"), reactAppTargets(name));
   reshapeReactAppScaffold(reactAppRoot);
-  (0, import_node_fs22.rmSync)((0, import_node_path24.join)(reactAppRoot, "src/app/nx-welcome.component.tsx"), { force: true });
+  (0, import_node_fs23.rmSync)((0, import_node_path24.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_path24.join)(reactAppRoot, "src", relative), contents);
@@ -5582,7 +5652,7 @@ function addReactInternalLib(workspaceRoot, name, stack, empty = false) {
 }
 
 // src/project-scaffolding/vscode-extension.use-case.ts
-var import_node_fs23 = require("fs");
+var import_node_fs24 = require("fs");
 var import_node_path26 = require("path");
 var VSCODE_EXTENSION_SCRIPT_PATH = "tools/vscode-extension.cjs";
 var VSCODE_ENGINE_FLOOR = "1.96.0";
@@ -5769,7 +5839,7 @@ 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_path26.join)(projectRoot, file);
-  const content = fileExists(path) ? (0, import_node_fs23.readFileSync)(path, "utf8") : "";
+  const content = fileExists(path) ? (0, import_node_fs24.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.`);
@@ -5857,7 +5927,7 @@ function vscodeExtensionPublishTarget(name, sidecar) {
   };
 }
 function addDebugLaunch(workspaceRoot, name) {
-  const file = (0, import_node_fs23.readdirSync)(workspaceRoot).find((entry) => entry.endsWith(".code-workspace"));
+  const file = (0, import_node_fs24.readdirSync)(workspaceRoot).find((entry) => entry.endsWith(".code-workspace"));
   if (file === void 0) {
     return;
   }
@@ -5897,7 +5967,7 @@ function refreshVscodeExtensionScript(workspaceRoot) {
   const apps = (0, import_node_path26.join)(workspaceRoot, "apps");
   let entries;
   try {
-    entries = (0, import_node_fs23.readdirSync)(apps);
+    entries = (0, import_node_fs24.readdirSync)(apps);
   } catch {
     return false;
   }
@@ -5910,7 +5980,7 @@ function refreshVscodeExtensionScript(workspaceRoot) {
     return tags.includes(VSCODE_EXTENSION_TAG);
   });
   const path = (0, import_node_path26.join)(workspaceRoot, VSCODE_EXTENSION_SCRIPT_PATH);
-  if (!hasExtension || fileExists(path) && (0, import_node_fs23.readFileSync)(path, "utf8") === VSCODE_EXTENSION_SCRIPT) {
+  if (!hasExtension || fileExists(path) && (0, import_node_fs24.readFileSync)(path, "utf8") === VSCODE_EXTENSION_SCRIPT) {
     return false;
   }
   writeFileEnsured(path, VSCODE_EXTENSION_SCRIPT);
@@ -5920,7 +5990,7 @@ function pinVscodeExtensionProjectNames(workspaceRoot) {
   const apps = (0, import_node_path26.join)(workspaceRoot, "apps");
   let entries;
   try {
-    entries = (0, import_node_fs23.readdirSync)(apps);
+    entries = (0, import_node_fs24.readdirSync)(apps);
   } catch {
     return [];
   }
@@ -5972,11 +6042,11 @@ function addVscodeExtension(workspaceRoot, name, stack, options = {}) {
 }
 
 // src/dependency-management/install-dependencies.use-case.ts
-var import_node_fs25 = require("fs");
+var import_node_fs26 = require("fs");
 var import_node_path28 = require("path");
 
 // src/dependency-management/manifest.repository.ts
-var import_node_fs24 = require("fs");
+var import_node_fs25 = require("fs");
 var import_node_path27 = require("path");
 var ECOSYSTEMS = ["npm", "pip", "pub", "nuget", "go"];
 var ROOT_LABEL = "(root)";
@@ -6013,18 +6083,18 @@ function hasEcosystem(workspaceRoot, ecosystem) {
     return fileExists((0, import_node_path27.join)(workspaceRoot, "go.mod"));
   }
   if (ecosystem === "nuget") {
-    return (0, import_node_fs24.globSync)(MANIFEST_GLOBS.nuget, { cwd: workspaceRoot }).length > 0;
+    return (0, import_node_fs25.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_path27.join)(workspaceRoot, rootMarker[ecosystem])) || (0, import_node_fs24.globSync)(MANIFEST_GLOBS[ecosystem], { cwd: workspaceRoot }).length > 0;
+  return fileExists((0, import_node_path27.join)(workspaceRoot, rootMarker[ecosystem])) || (0, import_node_fs25.globSync)(MANIFEST_GLOBS[ecosystem], { cwd: workspaceRoot }).length > 0;
 }
 function collectNpm(workspaceRoot) {
   const sites = [];
-  const relativePaths = ["package.json", ...(0, import_node_fs24.globSync)(MANIFEST_GLOBS.npm, { cwd: workspaceRoot })];
+  const relativePaths = ["package.json", ...(0, import_node_fs25.globSync)(MANIFEST_GLOBS.npm, { cwd: workspaceRoot })];
   for (const relativePath of relativePaths) {
     const manifestPath = (0, import_node_path27.join)(workspaceRoot, relativePath);
     try {
@@ -6093,11 +6163,11 @@ function collectPip(workspaceRoot) {
       rewritable: parsed.rewritable && parsed.spec !== ""
     });
   };
-  const pyprojectPaths = (0, import_node_fs24.globSync)(MANIFEST_GLOBS.pip, { cwd: workspaceRoot });
+  const pyprojectPaths = (0, import_node_fs25.globSync)(MANIFEST_GLOBS.pip, { cwd: workspaceRoot });
   for (const relativePath of pyprojectPaths) {
     let content;
     try {
-      content = (0, import_node_fs24.readFileSync)((0, import_node_path27.join)(workspaceRoot, relativePath), "utf8");
+      content = (0, import_node_fs25.readFileSync)((0, import_node_path27.join)(workspaceRoot, relativePath), "utf8");
     } catch {
       continue;
     }
@@ -6108,14 +6178,14 @@ function collectPip(workspaceRoot) {
   }
   const requirementsPaths = [
     "requirements-dev.txt",
-    ...(0, import_node_fs24.globSync)("apps/*/requirements.txt", { cwd: workspaceRoot })
+    ...(0, import_node_fs25.globSync)("apps/*/requirements.txt", { cwd: workspaceRoot })
   ];
   for (const relativePath of requirementsPaths) {
     if (!fileExists((0, import_node_path27.join)(workspaceRoot, relativePath))) {
       continue;
     }
     const section = relativePath === "requirements-dev.txt" ? "devDep" : "dep";
-    const lines = (0, import_node_fs24.readFileSync)((0, import_node_path27.join)(workspaceRoot, relativePath), "utf8").split(/\r?\n/);
+    const lines = (0, import_node_fs25.readFileSync)((0, import_node_path27.join)(workspaceRoot, relativePath), "utf8").split(/\r?\n/);
     for (const line of lines) {
       push(relativePath, section, line);
     }
@@ -6153,11 +6223,11 @@ function pyprojectDependencies(content) {
 }
 function collectPub(workspaceRoot) {
   const sites = [];
-  const pubspecPaths = (0, import_node_fs24.globSync)(MANIFEST_GLOBS.pub, { cwd: workspaceRoot });
+  const pubspecPaths = (0, import_node_fs25.globSync)(MANIFEST_GLOBS.pub, { cwd: workspaceRoot });
   for (const relativePath of pubspecPaths) {
     let content;
     try {
-      content = (0, import_node_fs24.readFileSync)((0, import_node_path27.join)(workspaceRoot, relativePath), "utf8");
+      content = (0, import_node_fs25.readFileSync)((0, import_node_path27.join)(workspaceRoot, relativePath), "utf8");
     } catch {
       continue;
     }
@@ -6217,11 +6287,11 @@ function stripQuotes(value) {
 }
 function collectNuget(workspaceRoot) {
   const sites = [];
-  const csprojPaths = (0, import_node_fs24.globSync)(MANIFEST_GLOBS.nuget, { cwd: workspaceRoot });
+  const csprojPaths = (0, import_node_fs25.globSync)(MANIFEST_GLOBS.nuget, { cwd: workspaceRoot });
   for (const relativePath of csprojPaths) {
     let content;
     try {
-      content = (0, import_node_fs24.readFileSync)((0, import_node_path27.join)(workspaceRoot, relativePath), "utf8");
+      content = (0, import_node_fs25.readFileSync)((0, import_node_path27.join)(workspaceRoot, relativePath), "utf8");
     } catch {
       continue;
     }
@@ -6261,7 +6331,7 @@ function collectGo(workspaceRoot) {
   }
   let content;
   try {
-    content = (0, import_node_fs24.readFileSync)(manifestPath, "utf8");
+    content = (0, import_node_fs25.readFileSync)(manifestPath, "utf8");
   } catch {
     return [];
   }
@@ -6310,7 +6380,7 @@ var PROJECT_GLOBS = {
 function locateProjects(workspaceRoot) {
   const locations = [];
   for (const ecosystem of ECOSYSTEMS) {
-    const relativePaths = (0, import_node_fs24.globSync)(PROJECT_GLOBS[ecosystem], { cwd: workspaceRoot });
+    const relativePaths = (0, import_node_fs25.globSync)(PROJECT_GLOBS[ecosystem], { cwd: workspaceRoot });
     for (const relativePath of relativePaths) {
       const posix = toPosix(relativePath);
       const dir = posix.slice(0, posix.lastIndexOf("/"));
@@ -6339,7 +6409,7 @@ function rewriteSpec(site, spec) {
     writeFileEnsured(site.manifestPath, toJson(manifest));
     return true;
   }
-  const before = (0, import_node_fs24.readFileSync)(site.manifestPath, "utf8");
+  const before = (0, import_node_fs25.readFileSync)(site.manifestPath, "utf8");
   const after = (() => {
     switch (site.ecosystem) {
       case "pip": {
@@ -6462,7 +6532,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_fs24.readFileSync)(lockPath, "utf8"));
+      ).exec((0, import_node_fs25.readFileSync)(lockPath, "utf8"));
       return match?.[1];
     } catch {
       return void 0;
@@ -6581,7 +6651,7 @@ function installInto(workspaceRoot, location, packages, saveDev) {
 function addPythonDependency(manifestPath, specifier) {
   let content;
   try {
-    content = (0, import_node_fs25.readFileSync)(manifestPath, "utf8");
+    content = (0, import_node_fs26.readFileSync)(manifestPath, "utf8");
   } catch {
     logger.warn(`Could not read ${manifestPath} \u2014 skipped ${specifier}`);
     return;
@@ -7437,15 +7507,15 @@ function runKinds(options) {
 
 // src/workspace-diagnostics/check-invariants.use-case.ts
 var import_node_child_process = require("child_process");
-var import_node_fs26 = require("fs");
+var import_node_fs27 = require("fs");
 var import_node_path32 = require("path");
 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_fs26.globSync)("eslint.config.{js,mjs,cjs,ts,mts,cts}", { cwd: workspaceRoot });
-  const projectConfigs = (0, import_node_fs26.globSync)("{apps,libs,packages}/*/eslint.config.{js,mjs,cjs,ts,mts,cts}", {
+  const rootConfigs = (0, import_node_fs27.globSync)("eslint.config.{js,mjs,cjs,ts,mts,cts}", { cwd: workspaceRoot });
+  const projectConfigs = (0, import_node_fs27.globSync)("{apps,libs,packages}/*/eslint.config.{js,mjs,cjs,ts,mts,cts}", {
     cwd: workspaceRoot
   }).map((config) => toPosix2(config));
   return [
@@ -7466,9 +7536,9 @@ function checkEslintConfigs(workspaceRoot) {
 }
 function checkEslintEntryPointReachesTheRules(workspaceRoot) {
   const rules = (0, import_node_path32.join)(workspaceRoot, ESLINT_MNCI_FILENAME);
-  if (!(0, import_node_fs26.existsSync)(rules)) return [];
+  if (!(0, import_node_fs27.existsSync)(rules)) return [];
   const entryPoint = (0, import_node_path32.join)(workspaceRoot, ESLINT_USER_FILENAME);
-  const source = (0, import_node_fs26.existsSync)(entryPoint) ? (0, import_node_fs26.readFileSync)(entryPoint, "utf8") : "";
+  const source = (0, import_node_fs27.existsSync)(entryPoint) ? (0, import_node_fs27.readFileSync)(entryPoint, "utf8") : "";
   return [
     {
       check: `${ESLINT_USER_FILENAME} imports the mnci rules`,
@@ -7537,7 +7607,7 @@ function checkNpmrc(workspaceRoot, registry, scope) {
   if (!registry || !fileExists(npmrcPath)) {
     return void 0;
   }
-  const npmrc = (0, import_node_fs26.readFileSync)(npmrcPath, "utf8");
+  const npmrc = (0, import_node_fs27.readFileSync)(npmrcPath, "utf8");
   if (registry.kind === "npm") {
     return {
       check: ".npmrc authenticates the public registry",
@@ -7558,7 +7628,7 @@ function checkNpmrcCredentialResolves(workspaceRoot, environment = process.env)
   if (!fileExists(npmrcPath)) {
     return void 0;
   }
-  const npmrc = (0, import_node_fs26.readFileSync)(npmrcPath, "utf8");
+  const npmrc = (0, import_node_fs27.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(
@@ -7587,8 +7657,8 @@ function checkNpmAuthMatchesPipeline(workspaceRoot, registry) {
   if (registry?.kind !== "azure-artifacts" || !fileExists(npmrcPath) || !fileExists(pipelinePath)) {
     return void 0;
   }
-  const holdsCredentials = (0, import_node_fs26.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_fs26.readFileSync)(pipelinePath, "utf8").includes("npmAuthenticate@0");
+  const holdsCredentials = (0, import_node_fs27.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_fs27.readFileSync)(pipelinePath, "utf8").includes("npmAuthenticate@0");
   if (!holdsCredentials && !runsTask) {
     return {
       check: "npm auth: .npmrc and azure-pipelines.yml agree",
@@ -7633,9 +7703,9 @@ function npmjsCredentialShape(credentials, environment) {
 }
 function checkVersionActions(workspaceRoot) {
   const candidates = [
-    ...(0, import_node_fs26.globSync)("packages/*/pubspec.yaml", { cwd: workspaceRoot }),
-    ...(0, import_node_fs26.globSync)("packages/*/*.csproj", { cwd: workspaceRoot }),
-    ...(0, import_node_fs26.globSync)("python-packages/*/pyproject.toml", { cwd: workspaceRoot })
+    ...(0, import_node_fs27.globSync)("packages/*/pubspec.yaml", { cwd: workspaceRoot }),
+    ...(0, import_node_fs27.globSync)("packages/*/*.csproj", { cwd: workspaceRoot }),
+    ...(0, import_node_fs27.globSync)("python-packages/*/pyproject.toml", { cwd: workspaceRoot })
   ].map((manifest) => toPosix2(manifest));
   return candidates.flatMap((manifest) => {
     const projectRoot = manifest.slice(0, manifest.lastIndexOf("/"));
@@ -7684,8 +7754,8 @@ function declaredTargets(workspaceRoot, projectRoot) {
 function checkTargetFilesExist(workspaceRoot) {
   const projectRoots = new Set(
     [
-      ...(0, import_node_fs26.globSync)("{apps,libs,packages}/*/project.json", { cwd: workspaceRoot }),
-      ...(0, import_node_fs26.globSync)("{apps,libs,packages}/*/package.json", { cwd: workspaceRoot })
+      ...(0, import_node_fs27.globSync)("{apps,libs,packages}/*/project.json", { cwd: workspaceRoot }),
+      ...(0, import_node_fs27.globSync)("{apps,libs,packages}/*/package.json", { cwd: workspaceRoot })
     ].map((manifest) => toPosix2(manifest).split("/").slice(0, 2).join("/"))
   );
   return [...projectRoots].flatMap(
@@ -7743,11 +7813,11 @@ function checkGoWorkInSync(workspaceRoot) {
   if (!fileExists(goWorkPath)) {
     return void 0;
   }
-  const contents = (0, import_node_fs26.existsSync)(goWorkPath) ? (0, import_node_fs26.readFileSync)(goWorkPath, "utf8") : "";
+  const contents = (0, import_node_fs27.existsSync)(goWorkPath) ? (0, import_node_fs27.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_fs26.existsSync)((0, import_node_path32.join)(workspaceRoot, entry, "go.mod")));
+  const stale = uses.filter((entry) => !(0, import_node_fs27.existsSync)((0, import_node_path32.join)(workspaceRoot, entry, "go.mod")));
   return {
     check: "every go.work `use` entry points to a module that still exists",
     ok: stale.length === 0,
@@ -7765,7 +7835,7 @@ function checkNativeApps(workspaceRoot) {
   ];
   const findings = pipelines.filter(({ file }) => fileExists((0, import_node_path32.join)(workspaceRoot, file))).map(({ file, marker }) => ({
     check: `${file} builds the native apps on every OS`,
-    ok: (0, import_node_fs26.readFileSync)((0, import_node_path32.join)(workspaceRoot, file), "utf8").includes(marker),
+    ok: (0, import_node_fs27.readFileSync)((0, import_node_path32.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`"
   }));
@@ -7798,14 +7868,14 @@ function checkNoRootRuntimeDependencies(workspaceRoot) {
   };
 }
 function checkRollupSourceMaps(workspaceRoot) {
-  const configs = (0, import_node_fs26.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
+  const configs = (0, import_node_fs27.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
     cwd: workspaceRoot
   }).map((config) => toPosix2(config));
   return configs.flatMap((relativePath) => {
     const configPath = (0, import_node_path32.join)(workspaceRoot, relativePath);
     let config;
     try {
-      config = (0, import_node_fs26.readFileSync)(configPath, "utf8");
+      config = (0, import_node_fs27.readFileSync)(configPath, "utf8");
     } catch {
       return [];
     }
@@ -7820,7 +7890,7 @@ function checkRollupSourceMaps(workspaceRoot) {
   });
 }
 function checkDeclarationSpecifiers(workspaceRoot) {
-  const configs = (0, import_node_fs26.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
+  const configs = (0, import_node_fs27.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
     cwd: workspaceRoot
   }).map((config) => toPosix2(config));
   return configs.flatMap((relativePath) => {
@@ -7860,7 +7930,7 @@ function checkDeclarationSpecifiers(workspaceRoot) {
 function checkPipelinePhases(workspaceRoot) {
   const files = ["azure-pipelines.yml", ".github/workflows/ci.yml"];
   return files.filter((file) => fileExists((0, import_node_path32.join)(workspaceRoot, file))).flatMap((file) => {
-    const { verifyActive, switchedOff } = inspectPipeline((0, import_node_fs26.readFileSync)((0, import_node_path32.join)(workspaceRoot, file), "utf8"));
+    const { verifyActive, switchedOff } = inspectPipeline((0, import_node_fs27.readFileSync)((0, import_node_path32.join)(workspaceRoot, file), "utf8"));
     const verify = {
       check: `${file} runs the enforced verify phase`,
       ok: verifyActive,
@@ -8055,7 +8125,7 @@ function runProjects(workspaceRoot, options) {
 var import_node_path35 = require("path");
 
 // src/cli-version/check-for-update.use-case.ts
-var import_node_fs27 = require("fs");
+var import_node_fs28 = require("fs");
 var import_node_path34 = require("path");
 var import_cross_spawn3 = __toESM(require("cross-spawn"));
 var PACKAGE_NAME2 = "@mnci/cli";
@@ -8116,7 +8186,7 @@ function releaseTriple(version) {
 function readCliVersion(packageDirectory) {
   try {
     const manifestPath = (0, import_node_path34.join)(packageDirectory, "..", "package.json");
-    const manifest = JSON.parse((0, import_node_fs27.readFileSync)(manifestPath, "utf8"));
+    const manifest = JSON.parse((0, import_node_fs28.readFileSync)(manifestPath, "utf8"));
     return manifest.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -8147,7 +8217,7 @@ function runInfo(workspaceRoot, cliVersion, options) {
 }
 
 // src/workspace-creation/adopt-directory.use-case.ts
-var import_node_fs28 = require("fs");
+var import_node_fs29 = require("fs");
 var import_node_path36 = require("path");
 var NEVER_COPIED = /* @__PURE__ */ new Set([".git", "node_modules"]);
 var AGENT_AND_CI_ENTRIES = [
@@ -8179,13 +8249,13 @@ var PREFLIGHT_BLOCKERS = [
   "packages"
 ];
 function assertAdoptableDirectory(target) {
-  if (!(0, import_node_fs28.existsSync)(target)) {
+  if (!(0, import_node_fs29.existsSync)(target)) {
     throw new Error(`--into '${target}' does not exist. Create or clone it first.`);
   }
-  if (!(0, import_node_fs28.statSync)(target).isDirectory()) {
+  if (!(0, import_node_fs29.statSync)(target).isDirectory()) {
     throw new Error(`--into '${target}' is not a directory.`);
   }
-  const blockers = PREFLIGHT_BLOCKERS.filter((entry) => (0, import_node_fs28.existsSync)((0, import_node_path36.join)(target, entry)));
+  const blockers = PREFLIGHT_BLOCKERS.filter((entry) => (0, import_node_fs29.existsSync)((0, import_node_path36.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.`
@@ -8193,15 +8263,15 @@ function assertAdoptableDirectory(target) {
   }
 }
 function mergeGitignore(generatedFile, targetFile) {
-  const existing = (0, import_node_fs28.readFileSync)(targetFile, "utf8");
+  const existing = (0, import_node_fs29.readFileSync)(targetFile, "utf8");
   const present = new Set(existing.split("\n").map((line) => line.trim()));
-  const additions = (0, import_node_fs28.readFileSync)(generatedFile, "utf8").split("\n").map((line) => line.trimEnd()).filter((line) => {
+  const additions = (0, import_node_fs29.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_fs28.writeFileSync)(
+  (0, import_node_fs29.writeFileSync)(
     targetFile,
     `${existing}${separator}
 # Added by mnci (Nx workspace)
@@ -8211,9 +8281,9 @@ ${additions.join("\n")}
   return true;
 }
 function adoptGeneratedWorkspace(generatedRoot, target) {
-  const entries = (0, import_node_fs28.readdirSync)(generatedRoot).filter((entry) => !NEVER_COPIED.has(entry));
+  const entries = (0, import_node_fs29.readdirSync)(generatedRoot).filter((entry) => !NEVER_COPIED.has(entry));
   const collisions = entries.filter(
-    (entry) => (0, import_node_fs28.existsSync)((0, import_node_path36.join)(target, entry)) && !EXISTING_WINS.has(entry) && entry !== ".gitignore"
+    (entry) => (0, import_node_fs29.existsSync)((0, import_node_path36.join)(target, entry)) && !EXISTING_WINS.has(entry) && entry !== ".gitignore"
   );
   if (collisions.length > 0) {
     throw new Error(
@@ -8224,24 +8294,24 @@ function adoptGeneratedWorkspace(generatedRoot, target) {
   for (const entry of entries) {
     const from = (0, import_node_path36.join)(generatedRoot, entry);
     const to = (0, import_node_path36.join)(target, entry);
-    if (entry === ".gitignore" && (0, import_node_fs28.existsSync)(to)) {
+    if (entry === ".gitignore" && (0, import_node_fs29.existsSync)(to)) {
       result.mergedGitignore = mergeGitignore(from, to);
       result.kept.push(entry);
       continue;
     }
-    if ((0, import_node_fs28.existsSync)(to)) {
+    if ((0, import_node_fs29.existsSync)(to)) {
       result.kept.push(entry);
       continue;
     }
-    (0, import_node_fs28.cpSync)(from, to, { recursive: true });
+    (0, import_node_fs29.cpSync)(from, to, { recursive: true });
     result.copied.push(entry);
   }
-  (0, import_node_fs28.rmSync)(generatedRoot, { recursive: true, force: true });
+  (0, import_node_fs29.rmSync)(generatedRoot, { recursive: true, force: true });
   return result;
 }
 
 // src/workspace-creation/create-workspace.use-case.ts
-var import_node_fs29 = require("fs");
+var import_node_fs30 = require("fs");
 var import_node_os2 = require("os");
 var import_node_path37 = require("path");
 function nxCloudProviderValue(ci) {
@@ -8301,7 +8371,7 @@ 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_fs29.mkdtempSync)((0, import_node_path37.join)((0, import_node_os2.tmpdir)(), "mnci-new-"));
+  const stagingParent = adoptTarget === void 0 ? process.cwd() : (0, import_node_fs30.mkdtempSync)((0, import_node_path37.join)((0, import_node_os2.tmpdir)(), "mnci-new-"));
   let workspaceRoot = (0, import_node_path37.join)(stagingParent, workspaceName);
   try {
     logger.step(`Creating Nx workspace '${workspaceName}' (preset: ts)`);
@@ -8325,7 +8395,7 @@ async function runNew(name, options) {
       workspaceRoot = adoptTarget;
     }
   } finally {
-    if (adoptTarget !== void 0) (0, import_node_fs29.rmSync)(stagingParent, { recursive: true, force: true });
+    if (adoptTarget !== void 0) (0, import_node_fs30.rmSync)(stagingParent, { recursive: true, force: true });
   }
   logger.step(
     "Applying MoNecromanCI overlay (VS Code workspace, release config, .npmrc, commitlint, pipeline, stack)"
@@ -8335,8 +8405,8 @@ async function runNew(name, options) {
     { workspaceName, scope, registry, agent, variableGroup, ci, stack, ...npmAuth && { npmAuth } },
     logger.detail
   );
-  (0, import_node_fs29.rmSync)((0, import_node_path37.join)(workspaceRoot, "node_modules"), { recursive: true, force: true });
-  (0, import_node_fs29.rmSync)((0, import_node_path37.join)(workspaceRoot, "package-lock.json"), { force: true });
+  (0, import_node_fs30.rmSync)((0, import_node_path37.join)(workspaceRoot, "node_modules"), { recursive: true, force: true });
+  (0, import_node_fs30.rmSync)((0, import_node_path37.join)(workspaceRoot, "package-lock.json"), { force: true });
   logger.step("Installing the toolchain (commitlint + husky + linting/formatting)");
   const installStatus = runShell(
     "npm",
@@ -8378,7 +8448,7 @@ var import_node_path39 = require("path");
 var import_prompts4 = require("@inquirer/prompts");
 
 // src/workspace-upgrade/upgrade-workspace.use-case.ts
-var import_node_fs30 = require("fs");
+var import_node_fs31 = require("fs");
 var import_node_path38 = require("path");
 function resolveRegistry2(options, persisted) {
   if (options.registry === "azure-artifacts" || options.organization && options.artifactsFeed) {
@@ -8408,7 +8478,7 @@ function resolveWorkspaceName(workspaceRoot, persisted) {
     return persisted.workspaceName;
   }
   try {
-    const existing = (0, import_node_fs30.readdirSync)(workspaceRoot).find(
+    const existing = (0, import_node_fs31.readdirSync)(workspaceRoot).find(
       (file) => file.endsWith(".code-workspace") && file !== "undefined.code-workspace"
     );
     if (existing) {
@@ -8420,7 +8490,7 @@ function resolveWorkspaceName(workspaceRoot, persisted) {
 }
 function detectNpmAuth(workspaceRoot) {
   try {
-    return (0, import_node_fs30.readFileSync)((0, import_node_path38.join)(workspaceRoot, "azure-pipelines.yml"), "utf8").includes("npmAuthenticate@0") ? "build-identity" : void 0;
+    return (0, import_node_fs31.readFileSync)((0, import_node_path38.join)(workspaceRoot, "azure-pipelines.yml"), "utf8").includes("npmAuthenticate@0") ? "build-identity" : void 0;
   } catch {
     return void 0;
   }