@mnci/cli 4.38.0 → 4.40.0

package/dist/cli.js

@@ -492,6 +492,189 @@ function fileExists(path) {
   return (0, import_node_fs4.existsSync)(path);
 }
 
+// src/pipeline-customization/legacy-pipeline-steps.algorithm.ts
+var MNCI_STEP_NAMES = /* @__PURE__ */ new Set([
+  "Add Go tool bin to PATH",
+  "Add the Flutter SDK to PATH",
+  "Attach HEAD and fetch refs",
+  "Attach HEAD to the source branch",
+  "Attach the per-platform zips to the GitHub Release (releasable Go apps)",
+  "Attach this OS's zip to the GitHub Release (releasable native apps)",
+  "Audit dependencies (fails on an actionable npm advisory)",
+  "Authenticate npm against the feed (build identity, no PAT)",
+  "Authenticate npm registry",
+  "Build all deployables",
+  "Cache npm packages",
+  "Check formatting (run 'npm run format' locally to fix)",
+  "Detect .NET projects",
+  "Download Go module dependencies",
+  "Ensure the function-apps folder exists",
+  "Fetch branches and release tags",
+  "Install Azure Functions Core Tools",
+  "Install dependencies",
+  "Install golangci-lint",
+  "Install native prerequisites (Linux)",
+  "Install Python dependencies (ruff, pytest, build, twine)",
+  "Install Python dependencies (ruff, pytest, build, twine, pip-audit)",
+  "Install Python project dependencies (editable, workspace-wide)",
+  "Lint",
+  "Lint, test and build affected projects",
+  "Lint, test and build affected projects (PR)",
+  "Lint, test and build everything",
+  "Lint, test, build and package the native apps",
+  "Lint, typecheck, test and build everything",
+  "npm audit (fails on an actionable advisory)",
+  "npm audit (non-blocking)",
+  "Pack all apps (one zip per app -> dist/drop)",
+  "Package function apps",
+  "Pin npm to the major mnci verifies against",
+  "pip-audit (non-blocking)",
+  "Preflight \u2014 name the PyPI projects this release would create",
+  "Preflight \u2014 npm must accept the token before anything is tagged",
+  "Publish function app packages",
+  "Publish packages and tag main",
+  "Publish Python packages (uv)",
+  "Publish the drop (one zip per app)",
+  "Push release tags (nx release's own push never runs without a remote Release configured)",
+  "Release (version from commits, tag-only, publish)",
+  "Resolve Dart dependencies (one pub get for the whole workspace)",
+  "Set the git identity used for release tags",
+  "Set up the Go toolchain",
+  "Set up the language toolchains (Python, Go, Flutter)",
+  "Sign in to Microsoft Entra ID (VS Code Marketplace)",
+  "Tag the run per app (type-name)",
+  "Test and build everything",
+  "Verify the workspace is synced (run 'npx nx sync' locally and commit if this fails)",
+  "Verify this is a full checkout (nx release needs the real tag history)"
+]);
+var MNCI_STEP_NAME_PATTERNS = [
+  /^Install the (\.NET SDK|Flutter SDK)/,
+  /^Release — version, tag/,
+  /^Verify \(/,
+  /^Publish this OS's native zips/
+];
+var MNCI_USES = ["actions/checkout@", "actions/setup-node@", "actions/setup-dotnet@", "actions/upload-artifact@", "azure/login@"];
+var MNCI_TASKS = ["UseNode@", "Cache@", "PublishBuildArtifacts@", "UseDotNet@", "npmAuthenticate@"];
+var MNCI_COMMANDS = ["npm ci", "npm install -g npm@", "git fetch --all", 'git config user.name "github-actions', "git checkout -B", "npx mnci ci", "npx nx sync"];
+function findFirstStepList(lines) {
+  const keyAt = lines.findIndex((line) => line.trim() === "steps:");
+  if (keyAt === -1) {
+    return void 0;
+  }
+  const firstItem = lines.findIndex((line, index) => index > keyAt && /^\s*- /.test(line));
+  if (firstItem === -1) {
+    return void 0;
+  }
+  const indent = lines[firstItem].length - lines[firstItem].trimStart().length;
+  const itemStart = " ".repeat(indent) + "- ";
+  const steps = [];
+  let pending = [];
+  let current;
+  for (let index = firstItem; index < lines.length; index++) {
+    const line = lines[index];
+    const lineIndent = line.length - line.trimStart().length;
+    const isBlank = line.trim() === "";
+    const isComment = line.trimStart().startsWith("#");
+    if (line.startsWith(itemStart)) {
+      current = { lead: pending, body: [line] };
+      steps.push(current);
+      pending = [];
+    } else if (isBlank || isComment && lineIndent <= indent) {
+      pending.push(line);
+    } else if (current && lineIndent > indent) {
+      current.body.push(...pending, line);
+      pending = [];
+    } else {
+      break;
+    }
+  }
+  return { steps, indent };
+}
+function topLevelFields(step) {
+  const fields = /* @__PURE__ */ new Map();
+  const keyIndent = step.body[0].length - step.body[0].trimStart().length + 2;
+  for (const [index, line] of step.body.entries()) {
+    const text = index === 0 ? line.trimStart().replace(/^- /, "") : line;
+    const lineIndent = index === 0 ? keyIndent : line.length - line.trimStart().length;
+    const trimmed = text.trimStart();
+    const colon = trimmed.indexOf(":");
+    const key = colon === -1 ? "" : trimmed.slice(0, colon);
+    if (lineIndent === keyIndent && /^[\w-]+$/.test(key) && !fields.has(key)) {
+      fields.set(key, trimmed.slice(colon + 1).trim().replaceAll(/^["']|["']$/g, ""));
+    }
+  }
+  return fields;
+}
+function isGeneratedStep(step) {
+  const fields = topLevelFields(step);
+  const name = fields.get("name") ?? fields.get("displayName");
+  if (name !== void 0 && (MNCI_STEP_NAMES.has(name) || MNCI_STEP_NAME_PATTERNS.some((pattern) => pattern.test(name)))) {
+    return true;
+  }
+  const uses = fields.get("uses");
+  if (uses !== void 0 && MNCI_USES.some((prefix) => uses.startsWith(prefix))) {
+    return true;
+  }
+  const task = fields.get("task");
+  if (task !== void 0 && MNCI_TASKS.some((prefix) => task.startsWith(prefix))) {
+    return true;
+  }
+  if (fields.has("checkout")) {
+    return true;
+  }
+  const command = fields.get("run") ?? fields.get("script");
+  return command !== void 0 && MNCI_COMMANDS.some((prefix) => command.startsWith(prefix));
+}
+function describeStep(step) {
+  const fields = topLevelFields(step);
+  return fields.get("name") ?? fields.get("displayName") ?? (fields.get("run") ?? fields.get("script") ?? step.body[0].trim()).slice(0, 60);
+}
+function landmark(step) {
+  const name = topLevelFields(step).get("name") ?? topLevelFields(step).get("displayName") ?? "";
+  if (/^(?:Verify \(|Lint|Test and build|Typecheck)/.test(name)) {
+    return "verify";
+  }
+  if (name.startsWith("Pack all apps")) {
+    return "pack";
+  }
+  if (/^(?:Release|Publish packages and tag)/.test(name)) {
+    return "release";
+  }
+  return void 0;
+}
+function readLegacyPipeline(lines) {
+  const reading = { slots: /* @__PURE__ */ new Map(), kept: [], hasPack: false, hasRelease: false };
+  const list = findFirstStepList(lines);
+  if (!list) {
+    return reading;
+  }
+  const marks = list.steps.map((step) => landmark(step));
+  const gate = marks.indexOf("verify");
+  const release = marks.indexOf("release");
+  reading.hasPack = marks.includes("pack");
+  reading.hasRelease = release !== -1;
+  for (const [index, step] of list.steps.entries()) {
+    if (isGeneratedStep(step)) {
+      continue;
+    }
+    let slot = "after-install";
+    if (release !== -1 && index > release) {
+      slot = "after-release";
+    } else if (gate !== -1 && index > gate) {
+      slot = "before-release";
+    }
+    const lines_ = [...step.lead, ...step.body].map((line) => line.startsWith(" ".repeat(list.indent)) ? line.slice(list.indent) : line.trimStart());
+    const existing = reading.slots.get(slot) ?? [];
+    reading.slots.set(slot, [...existing, ...existing.length > 0 ? [""] : [], ...trimBlank(lines_)]);
+    reading.kept.push(describeStep(step));
+  }
+  return reading;
+}
+function trimBlank(lines) {
+  const first = lines.findIndex((line) => line.trim() !== "");
+  return first === -1 ? [] : lines.slice(first);
+}
+
 // src/pipeline-customization/pipeline-markers.algorithm.ts
 var CHOOSABLE_PHASES = ["pack", "release"];
 var SLOT_BEGIN = /^(\s*)# mnci:slot (\S+)/;
@@ -597,6 +780,31 @@ function inspectPipeline(text) {
   };
 }
 
+// src/pipeline-customization/migrate-legacy-pipeline.use-case.ts
+function migrateLegacyPipeline(legacy, generated) {
+  const reading = readLegacyPipeline(legacy.split("\n"));
+  const off = [];
+  if (reading.kept.length > 0 || reading.hasPack || reading.hasRelease) {
+    if (!reading.hasPack) {
+      off.push("pack");
+    }
+    if (!reading.hasRelease) {
+      off.push("release");
+    }
+  }
+  const text = commentOutPhases(injectSlots(generated, reading.slots), off);
+  const notes = [
+    "This pipeline was written before mnci kept user slots, so it was regenerated. Edits to the steps mnci generated, and anything outside the step list (triggers, variables, extra jobs), are in git history."
+  ];
+  if (reading.kept.length > 0) {
+    notes.push(`Kept ${reading.kept.length} step${reading.kept.length === 1 ? "" : "s"} of your own in the new slots: ${reading.kept.join("; ")}. Check their order.`);
+  }
+  for (const phase of off) {
+    notes.push(`The old pipeline had no ${phase} step, so the ${phase} phase is switched off.`);
+  }
+  return { text, notes };
+}
+
 // src/pipeline-customization/merge-pipeline.use-case.ts
 function mergePipeline(existing, generated) {
   if (existing === void 0) {
@@ -604,10 +812,7 @@ function mergePipeline(existing, generated) {
   }
   const normalized = existing.replaceAll("\r\n", "\n");
   if (!/^\s*# mnci:(?:slot|phase) /m.test(normalized)) {
-    return {
-      text: generated,
-      notes: ['This pipeline was written before mnci kept user slots, so it was regenerated whole. Edits outside the generated steps are in git history: re-apply them inside the new "# mnci:slot" blocks.']
-    };
+    return migrateLegacyPipeline(normalized, generated);
   }
   const off = switchedOffPhases(normalized);
   const text = commentOutPhases(injectSlots(generated, extractSlots(normalized)), off);
@@ -2376,13 +2581,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 +2663,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 +2684,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 +2700,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 +2713,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 +2788,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 +2846,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 +2865,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 +2893,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 +2901,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 +2909,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 +2946,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 +2986,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 +3113,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 +3152,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 +3194,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 +3257,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 +3309,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 +3334,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 +3342,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 +3360,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 +3369,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 +3458,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 +3482,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 +3589,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 +3603,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 +3747,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 +3923,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 +3993,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 +4059,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 +4213,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 +4222,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 +4230,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 +4310,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 +4320,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 +4364,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 +4407,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 +4426,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 +4520,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 +4561,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 +5050,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 +5074,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 +5090,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 +5293,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 +5309,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 +5328,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 +5337,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 +5350,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 +5395,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 +5614,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 +5626,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 +5749,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 +5783,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 +5857,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 +6044,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 +6132,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 +6172,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 +6185,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 +6195,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 +6247,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 +6288,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 +6368,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 +6383,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 +6428,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 +6492,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 +6536,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 +6585,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 +6614,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 +6737,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 +6856,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 +7712,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 +7741,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 +7812,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 +7833,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 +7862,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 +7908,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 +7959,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 +8018,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 +8040,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 +8073,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 +8095,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 +8135,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 +8330,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 +8391,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 +8422,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 +8454,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 +8468,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 +8486,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 +8499,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 +8576,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 +8600,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 +8610,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 +8653,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 +8683,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 +8695,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;
   }