copilotkit 4.13.0 → 4.14.0

package/release/release-tool.js

@@ -55,16 +55,16 @@ var require_starter_source_policy = __commonJS({
 
 // apps/cli/src/release/cli-release.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import * as fs5 from "node:fs";
-import * as path5 from "node:path";
+import * as fs6 from "node:fs";
+import * as path6 from "node:path";
 
 // apps/cli/src/starter-source-catalog.ts
 var import_starter_source_policy = __toESM(require_starter_source_policy(), 1);
-function copilotKitStarter(path6) {
+function copilotKitStarter(path7) {
   return {
     owner: "CopilotKit",
     repo: "CopilotKit",
-    path: path6,
+    path: path7,
     mode: "sparse",
     ownership: "first-party"
   };
@@ -903,10 +903,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path6) {
-  if (!path6)
+function getElementAtPath(obj, path7) {
+  if (!path7)
     return obj;
-  return path6.reduce((acc, key) => acc?.[key], obj);
+  return path7.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1289,11 +1289,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path6, issues) {
+function prefixIssues(path7, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path6);
+    iss.path.unshift(path7);
     return iss;
   });
 }
@@ -1476,7 +1476,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path6 = []) => {
+  const processError = (error49, path7 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -1486,7 +1486,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path6, ...issue2.path];
+        const fullpath = [...path7, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1518,8 +1518,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path6 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path6) {
+  const path7 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path7) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -13495,13 +13495,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path6 = ref.slice(1).split("/").filter(Boolean);
-  if (path6.length === 0) {
+  const path7 = ref.slice(1).split("/").filter(Boolean);
+  if (path7.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path6[0] === defsKey) {
-    const key = path6[1];
+  if (path7[0] === defsKey) {
+    const key = path7[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -14427,11 +14427,11 @@ async function resolveCopilotKitSource(options) {
     }
   }
   const uniquePaths = options.validateStarterPaths === false ? [] : [...new Set(options.starterPaths)];
-  for (const path6 of uniquePaths) {
+  for (const path7 of uniquePaths) {
     const content = await requestGitHub(
-      `${apiRoot}/contents/${encodeURIComponent(path6)}?ref=${canonicalCommit}`,
+      `${apiRoot}/contents/${encodeURIComponent(path7)}?ref=${canonicalCommit}`,
       "contents",
-      { path: path6, canonicalCommit },
+      { path: path7, canonicalCommit },
       fetchImpl,
       options.githubToken,
       options.requestTimeoutMs
@@ -14442,14 +14442,14 @@ async function resolveCopilotKitSource(options) {
     if (content !== null && typeof content === "object" && !Array.isArray(content) && "type" in content && content.type === "file") {
       throw new ReleasePreflightError(
         "STARTER_PATH_NOT_DIRECTORY",
-        `The CopilotKit starter path ${path6} is not a directory`,
-        { path: path6, canonicalCommit }
+        `The CopilotKit starter path ${path7} is not a directory`,
+        { path: path7, canonicalCommit }
       );
     }
     throw new ReleasePreflightError(
       "GITHUB_RESPONSE_INVALID",
-      `GitHub returned invalid contents metadata for ${path6}`,
-      { path: path6, canonicalCommit }
+      `GitHub returned invalid contents metadata for ${path7}`,
+      { path: path7, canonicalCommit }
     );
   }
   return {
@@ -14692,13 +14692,126 @@ function planReleaseReconciliation(options) {
 
 // apps/cli/src/release/smoke-starters.ts
 import { execFile } from "node:child_process";
-import * as fs4 from "node:fs";
+import * as fs5 from "node:fs";
 import * as os2 from "node:os";
-import * as path4 from "node:path";
+import * as path5 from "node:path";
+
+// libs/feature-flags/src/registry.ts
+function defineFlags(defs) {
+  return Object.fromEntries(
+    Object.entries(defs).map(([key, body]) => [key, { ...body, key }])
+  );
+}
+var FLAG_DEFINITIONS = defineFlags({
+  // Ops can auto-deploy before App API, including in staging. Keep issuance
+  // off in every environment until all verifiers accept this signed claim.
+  "cli.organization-slug": {
+    purpose: "Include the Clerk organization slug in CLI product credentials after App API rollout.",
+    owner: "platform",
+    createdAt: "2026-09-17",
+    status: "rollout",
+    surfaces: ["ops-api"],
+    defaultByEnv: { dev: false, ci: false, prod: false },
+    envVar: "OPS_CLI_ORGANIZATION_SLUG_ENABLED"
+  },
+  // Self-hosted is a seam, not an offered choice yet (PE-94): the target moves
+  // only the app API URL, and no onboarding path offers it. Keep released
+  // binaries on managed until a self-hosted deployment can serve the product.
+  "cli.self-hosted-deployment": {
+    purpose: "Lets the CLI target a self-hosted Intelligence deployment through --deployment or COPILOTKIT_DEPLOYMENT.",
+    owner: "platform",
+    createdAt: "2026-09-22",
+    status: "rollout",
+    surfaces: ["cli"],
+    defaultByEnv: { dev: true, ci: true, prod: false }
+  },
+  "threads.bounded-replay": {
+    purpose: "Stage connect history on disk and require SDK acknowledgements for bounded delivery.",
+    owner: "realtime",
+    createdAt: "2026-09-16",
+    status: "rollout",
+    surfaces: ["realtime-gateway", "copilotkit-core"],
+    defaultByEnv: { dev: true, ci: true, prod: false },
+    envVar: "REALTIME_GATEWAY_BOUNDED_REPLAY_ENABLED"
+  },
+  // `active` (not `rollout`): a long-lived operational kill-switch, default-on
+  // in every env; `envVar` adopts the pre-existing INSPECT_ROUTES_ENABLED name.
+  "inspect.routes": {
+    purpose: "Gates the /api/_inspect/* introspection routes used by the web inspector; operational kill-switch.",
+    owner: "platform",
+    createdAt: "2026-06-23",
+    status: "active",
+    surfaces: ["app-api"],
+    defaultByEnv: { dev: true, ci: true, prod: true },
+    envVar: "INSPECT_ROUTES_ENABLED"
+  },
+  // Rollout flag for the in-progress Channels feature (OSS-373). Lets the
+  // SDK, UI, and infra land incrementally and deploy dark; production stays off
+  // until the rollout completes and the prod default is flipped in a later
+  // build. Server boundaries enforce it via the shared `resolveChannelsRollout`
+  // helper; `envVar` pins the pre-existing FF_MANAGED_BOTS toggle name so the
+  // operational override is byte-identical across the rename.
+  channels: {
+    purpose: "Gates the Channels feature (activation, listener, delivery, egress) so unfinished customer behavior stays dark until rollout completes.",
+    owner: "channels",
+    createdAt: "2026-06-25",
+    status: "rollout",
+    surfaces: ["app-api", "realtime-gateway", "app-frontend"],
+    defaultByEnv: { dev: true, ci: true, prod: false },
+    envVar: "FF_MANAGED_BOTS"
+  },
+  "managed-channels": {
+    purpose: "Canonical Managed Channels rollout gate, evaluated alongside the legacy FF_MANAGED_BOTS override while deployments migrate.",
+    owner: "channels",
+    createdAt: "2026-07-09",
+    status: "rollout",
+    surfaces: ["app-api", "realtime-gateway", "app-frontend"],
+    defaultByEnv: { dev: true, ci: true, prod: true }
+  },
+  "learning.platform-v1": {
+    purpose: "Gates the Learning V1 control API, runtime workers, product UI, and CLI download while the platform rolls out.",
+    owner: "learning",
+    createdAt: "2026-08-06",
+    status: "rollout",
+    surfaces: ["app-api", "app-frontend", "cli"],
+    defaultByEnv: { dev: false, ci: false, prod: false },
+    envVar: "LEARNING_ENABLED"
+  },
+  "analytics.pipeline": {
+    purpose: "Gates project-scoped analytics reads and realtime projection while the durable pipeline rolls out.",
+    owner: "analytics",
+    createdAt: "2026-08-16",
+    status: "rollout",
+    surfaces: ["app-api", "realtime-gateway"],
+    defaultByEnv: { dev: false, ci: false, prod: false },
+    envVar: "ANALYTICS_ENABLED"
+  },
+  // PE-242: an agent cannot tell whether the developer's browser shares its
+  // machine, so the loopback redirect fails over SSH, in VMs, and in
+  // containers. Ops mounts the device routes and the CLI switches
+  // `login --json` to them; with the flag off both keep the loopback flow.
+  // On in prod from CLI 4.14.0; Ops prod already served the routes.
+  "cli.device-login": {
+    purpose: "Signs in `copilotkit login --json` and `login --device` with an RFC 8628 device authorization grant instead of the loopback redirect.",
+    owner: "platform",
+    createdAt: "2026-09-23",
+    status: "rollout",
+    surfaces: ["ops-api", "cli"],
+    defaultByEnv: { dev: true, ci: true, prod: true }
+  },
+  "ops.stripe-billing-v1": {
+    purpose: "Gates the direct Stripe Checkout, Portal, projection, and provider-aware billing API during rollout.",
+    owner: "ops",
+    createdAt: "2026-09-08",
+    status: "rollout",
+    surfaces: ["ops-api"],
+    defaultByEnv: { dev: true, ci: true, prod: false }
+  }
+});
 
 // apps/cli/src/config.ts
 function getTemplateRef() {
-  return true ? "1e13b4945b44c6afa2e398a0c9935415d4aa7577" : "main";
+  return true ? "2c42a41a7e749c4473705769d1ae985d89718465" : "main";
 }
 
 // apps/cli/src/services/agentcore-config.ts
@@ -15266,10 +15379,60 @@ var FRAMEWORK_TEMPLATES = {
 };
 
 // apps/cli/src/services/project-scaffold.ts
-import * as fs3 from "node:fs";
-import * as path3 from "node:path";
+import * as fs4 from "node:fs";
+import * as path4 from "node:path";
 import * as os from "node:os";
 import { execFileSync } from "node:child_process";
+
+// apps/cli/src/services/project-config.ts
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
+var projectConfigSchema = external_exports.object({
+  projectId: external_exports.string().min(1),
+  projectSlug: external_exports.string().min(1),
+  /**
+   * Clerk organization the selection was made under.
+   *
+   * Absent on a self-hosted deployment, which has no Clerk organization at
+   * all. Demanding it made `.copilotkit/project.json` unparseable there, and
+   * the symptom surfaced a long way from the cause: `verify` reported the
+   * file "exists but could not be read" and failed `project_selected` on a
+   * correctly wired project, because resolution never reached the contents
+   * (PE-95).
+   *
+   * Optional, not loose. An empty string is still rejected: absent means
+   * self-hosted, blank means something wrote a bug.
+   */
+  clerkOrgId: external_exports.string().min(1).optional(),
+  telemetryBindingId: external_exports.string().trim().min(1).optional(),
+  /**
+   * Absolute URL of this project's CopilotKit runtime, when the project pins
+   * one.
+   *
+   * Stated, never guessed. `copilotkit verify` works out the port from the
+   * app's own dev configuration, and this is where a project whose runtime is
+   * somewhere that cannot be worked out — a different mount path, a
+   * container, a port that only ever appears on a command line — says so once
+   * instead of passing `--runtime-url` on every invocation (OSS-1090).
+   *
+   * A person writes it, and so does `project select --runtime-url`. An
+   * onboarding run settles a free port and then has nowhere to put it, so
+   * `verify` falls back to its assumed default and reports on whatever holds
+   * that port — in one run, an unrelated checkout (PE-58). The flag is still
+   * a statement rather than a guess: the caller has to name the URL.
+   */
+  runtimeUrl: external_exports.string().trim().min(1).optional()
+}).strict();
+function canonicalizeDir(dir) {
+  const resolved = path3.resolve(dir);
+  try {
+    return fs3.realpathSync(resolved);
+  } catch {
+    return resolved;
+  }
+}
+
+// apps/cli/src/services/project-scaffold.ts
 var PROJECT_DIRECTORY_NAMES = /* @__PURE__ */ new Set([
   "agent",
   "api",
@@ -15306,23 +15469,118 @@ function entryHoldsProject(entry) {
     return true;
   return PROJECT_DIRECTORY_NAMES.has(entry) || PROJECT_MANIFEST_NAMES.has(entry);
 }
-function isProjectDirOccupied(projectDir) {
-  return fs3.existsSync(projectDir) && fs3.readdirSync(projectDir).some(entryHoldsProject);
+var SYSTEM_FOLDERS = [
+  "/Applications",
+  "/Library",
+  "/System",
+  "/Users",
+  "/Volumes",
+  "/bin",
+  "/etc",
+  "/home",
+  "/opt",
+  "/private",
+  "/private/tmp",
+  "/private/var",
+  "/sbin",
+  "/tmp",
+  "/usr",
+  "/var"
+];
+var PROJECTS_BELOW_DEPTH = 2;
+function sharedFolderKind(dir, homeDir) {
+  const home = canonicalizeDir(homeDir);
+  if (dir === home)
+    return "home";
+  const system = new Set(
+    [
+      ...SYSTEM_FOLDERS,
+      path4.parse(dir).root,
+      path4.dirname(home),
+      os.tmpdir(),
+      process.env["SystemRoot"] ?? ""
+    ].filter((folder) => folder !== "").map(canonicalizeDir)
+  );
+  return system.has(dir) ? "system" : void 0;
+}
+function readEntries(dir) {
+  try {
+    return fs4.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
 }
-function assertProjectDirAvailable(projectDir) {
-  if (isProjectDirOccupied(projectDir)) {
+function findProjectsBelow(dir) {
+  const found = [];
+  const visit = (relative, depth) => {
+    for (const entry of readEntries(path4.join(dir, relative))) {
+      if (!entry.isDirectory())
+        continue;
+      if (entry.name.startsWith(".") || entry.name === "node_modules")
+        continue;
+      const child = path4.join(relative, entry.name);
+      const names = readEntries(path4.join(dir, child)).map((e) => e.name);
+      if (names.some((n) => n === ".git" || PROJECT_MANIFEST_NAMES.has(n))) {
+        found.push(child);
+      } else if (depth < PROJECTS_BELOW_DEPTH) {
+        visit(child, depth + 1);
+      }
+    }
+  };
+  visit("", 1);
+  return found.sort();
+}
+function readProjectDirContents(projectDir, homeDir = os.homedir()) {
+  if (!fs4.existsSync(projectDir))
+    return { kind: "available" };
+  const dir = canonicalizeDir(projectDir);
+  const folder = sharedFolderKind(dir, homeDir);
+  if (folder !== void 0)
+    return { kind: "shared-folder", folder };
+  const entries = readEntries(dir).map((entry) => entry.name);
+  if (entries.some(entryHoldsProject))
+    return { kind: "project" };
+  const projects = findProjectsBelow(dir);
+  if (projects.length === 0)
+    return { kind: "available" };
+  return entries.includes(".git") ? { kind: "project" } : { kind: "projects-below", projects };
+}
+function assertProjectDirAvailable(projectDir, homeDir = os.homedir()) {
+  const message = occupiedMessage(
+    projectDir,
+    readProjectDirContents(projectDir, homeDir)
+  );
+  if (message !== void 0) {
     throw tagError(
-      new Error(`${projectDir} already holds a project`),
+      new Error(message),
       TELEMETRY_ERROR_CODES.PREREQUISITE_MISSING
     );
   }
 }
+var LISTED_PROJECTS = 5;
+function occupiedMessage(projectDir, contents) {
+  const elsewhere = "Create an empty folder for the new app, or open your project folder, and run init there.";
+  switch (contents.kind) {
+    case "available":
+      return void 0;
+    case "project":
+      return `${projectDir} already holds a project`;
+    case "shared-folder":
+      return contents.folder === "home" ? `${projectDir} is your home folder. ${elsewhere}` : `${projectDir} is a system folder. ${elsewhere}`;
+    case "projects-below": {
+      const named = contents.projects.slice(0, LISTED_PROJECTS);
+      const more = contents.projects.length - named.length;
+      const list = named.join(", ") + (more > 0 ? `, and ${more} more` : "");
+      return `${projectDir} holds other projects: ${list}. ${elsewhere}`;
+    }
+  }
+}
 async function scaffoldProject(options) {
   const { projectDir, template } = options;
   assertProjectDirAvailable(projectDir);
   const localTemplateDir = process.env["COPILOTKIT_TEMPLATE_DIR"];
   if (localTemplateDir !== void 0 && localTemplateDir !== "") {
-    if (!fs3.existsSync(localTemplateDir)) {
+    if (!fs4.existsSync(localTemplateDir)) {
       throw tagError(
         new Error(
           `COPILOTKIT_TEMPLATE_DIR points at a path that does not exist: ${localTemplateDir}`
@@ -15330,7 +15588,7 @@ async function scaffoldProject(options) {
         TELEMETRY_ERROR_CODES.TEMPLATE_FETCH_FAILED
       );
     }
-    fs3.mkdirSync(projectDir, { recursive: true });
+    fs4.mkdirSync(projectDir, { recursive: true });
     await copyDirectory(localTemplateDir, projectDir, true);
     return;
   }
@@ -15345,7 +15603,7 @@ async function scaffoldProject(options) {
 }
 function pathEntryExists(entryPath) {
   try {
-    fs3.lstatSync(entryPath);
+    fs4.lstatSync(entryPath);
     return true;
   } catch (error48) {
     if (error48 instanceof Error && "code" in error48 && error48.code === "ENOENT") {
@@ -15356,7 +15614,7 @@ function pathEntryExists(entryPath) {
 }
 async function cloneTemplate(source, destinationPath) {
   const { owner, repo, revision, subdirectoryPath, mode } = source;
-  const tempDir = fs3.mkdtempSync(path3.join(os.tmpdir(), "copilotkit-clone-"));
+  const tempDir = fs4.mkdtempSync(path4.join(os.tmpdir(), "copilotkit-clone-"));
   const isWholeRepo = mode === "whole-repository";
   const destinationExisted = pathEntryExists(destinationPath);
   try {
@@ -15376,8 +15634,8 @@ async function cloneTemplate(source, destinationPath) {
         { cwd: tempDir, stdio: "pipe" },
         TELEMETRY_ERROR_CODES.GIT_FAILED
       );
-      fs3.writeFileSync(
-        path3.join(tempDir, ".git/info/sparse-checkout"),
+      fs4.writeFileSync(
+        path4.join(tempDir, ".git/info/sparse-checkout"),
         subdirectoryPath
       );
     }
@@ -15391,8 +15649,8 @@ async function cloneTemplate(source, destinationPath) {
       { cwd: tempDir, stdio: "pipe" },
       TELEMETRY_ERROR_CODES.GIT_FAILED
     );
-    const sourcePath = isWholeRepo ? tempDir : path3.join(tempDir, subdirectoryPath);
-    if (!isWholeRepo && !fs3.existsSync(sourcePath)) {
+    const sourcePath = isWholeRepo ? tempDir : path4.join(tempDir, subdirectoryPath);
+    if (!isWholeRepo && !fs4.existsSync(sourcePath)) {
       throw tagError(
         new Error(
           `Template directory '${subdirectoryPath}' not found in the repository.`
@@ -15400,11 +15658,11 @@ async function cloneTemplate(source, destinationPath) {
         TELEMETRY_ERROR_CODES.TEMPLATE_FETCH_FAILED
       );
     }
-    fs3.mkdirSync(destinationPath, { recursive: true });
+    fs4.mkdirSync(destinationPath, { recursive: true });
     await copyDirectory(sourcePath, destinationPath, isWholeRepo);
   } catch (cause) {
     if (!destinationExisted) {
-      fs3.rmSync(destinationPath, { recursive: true, force: true });
+      fs4.rmSync(destinationPath, { recursive: true, force: true });
     }
     const error48 = cause instanceof Error ? cause : new Error("Starter template checkout failed");
     const code = error48.code;
@@ -15414,26 +15672,26 @@ async function cloneTemplate(source, destinationPath) {
     throw tagError(error48, TELEMETRY_ERROR_CODES.TEMPLATE_FETCH_FAILED);
   } finally {
     try {
-      fs3.rmSync(tempDir, { recursive: true, force: true });
+      fs4.rmSync(tempDir, { recursive: true, force: true });
     } catch {
     }
   }
 }
 async function copyDirectory(source, destination, excludeGit = false) {
-  if (!fs3.existsSync(destination)) {
-    fs3.mkdirSync(destination, { recursive: true });
+  if (!fs4.existsSync(destination)) {
+    fs4.mkdirSync(destination, { recursive: true });
   }
-  const entries = fs3.readdirSync(source, { withFileTypes: true });
+  const entries = fs4.readdirSync(source, { withFileTypes: true });
   for (const entry of entries) {
     if (excludeGit && entry.name === ".git") {
       continue;
     }
-    const srcPath = path3.join(source, entry.name);
-    const destPath = path3.join(destination, entry.name);
+    const srcPath = path4.join(source, entry.name);
+    const destPath = path4.join(destination, entry.name);
     if (entry.isDirectory()) {
       await copyDirectory(srcPath, destPath, excludeGit);
     } else {
-      fs3.copyFileSync(srcPath, destPath);
+      fs4.copyFileSync(srcPath, destPath);
     }
   }
 }
@@ -15491,10 +15749,10 @@ var StarterSmokeError = class extends Error {
   }
 };
 async function scaffoldStarterForSmoke(input, scaffold = scaffoldProject) {
-  const temporaryRoot = fs4.mkdtempSync(
-    path4.join(os2.tmpdir(), `copilotkit-smoke-${input.framework}-`)
+  const temporaryRoot = fs5.mkdtempSync(
+    path5.join(os2.tmpdir(), `copilotkit-smoke-${input.framework}-`)
   );
-  const projectDir = path4.join(temporaryRoot, "project");
+  const projectDir = path5.join(temporaryRoot, "project");
   try {
     const definition = FRAMEWORK_TEMPLATES[input.framework];
     const configuredTemplate = definition.template;
@@ -15535,8 +15793,8 @@ async function scaffoldStarterForSmoke(input, scaffold = scaffoldProject) {
       const credential = command?.match(
         /dotnet user-secrets set ([A-Za-z0-9_]+)/
       )?.[1];
-      const programPath = path4.join(projectDir, "agent", "Program.cs");
-      const program = fs4.existsSync(programPath) ? fs4.readFileSync(programPath, "utf8") : "";
+      const programPath = path5.join(projectDir, "agent", "Program.cs");
+      const program = fs5.existsSync(programPath) ? fs5.readFileSync(programPath, "utf8") : "";
       if (!credential || !program.includes(credential)) {
         throw new StarterSmokeError(
           "STARTER_CREDENTIAL_MISMATCH",
@@ -15549,14 +15807,14 @@ async function scaffoldStarterForSmoke(input, scaffold = scaffoldProject) {
         );
       }
     }
-    const entries = fs4.readdirSync(projectDir);
+    const entries = fs5.readdirSync(projectDir);
     return entries.join("\n");
   } finally {
-    fs4.rmSync(temporaryRoot, { recursive: true, force: true });
+    fs5.rmSync(temporaryRoot, { recursive: true, force: true });
   }
 }
 async function executeStarterSmokeChild(command) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     execFile(
       command.executable,
       [...command.args],
@@ -15570,7 +15828,7 @@ async function executeStarterSmokeChild(command) {
           reject(error48);
           return;
         }
-        resolve4(stdout);
+        resolve5(stdout);
       }
     );
   });
@@ -15587,7 +15845,7 @@ async function runStarterSmokeChild(input, execute = executeStarterSmokeChild, e
     return await execute({
       executable: process.execPath,
       args: [
-        path4.resolve(entrypoint),
+        path5.resolve(entrypoint),
         "smoke-one",
         "--framework",
         input.framework,
@@ -15897,7 +16155,7 @@ function parseArguments(args) {
   return { command: releaseCommand, flags };
 }
 function readJsonObject(inputPath) {
-  const text = inputPath === "-" ? fs5.readFileSync(0, "utf8") : fs5.readFileSync(inputPath, "utf8");
+  const text = inputPath === "-" ? fs6.readFileSync(0, "utf8") : fs6.readFileSync(inputPath, "utf8");
   const value = JSON.parse(text);
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     throw new ReleaseCliInputError(`Expected a JSON object in ${inputPath}`);
@@ -15923,8 +16181,8 @@ function emitResult(result, scalarOutputs, flags, stdout) {
 `;
   const outputPath = flags.get("--output");
   if (outputPath !== void 0) {
-    fs5.mkdirSync(path5.dirname(path5.resolve(outputPath)), { recursive: true });
-    fs5.writeFileSync(outputPath, json2);
+    fs6.mkdirSync(path6.dirname(path6.resolve(outputPath)), { recursive: true });
+    fs6.writeFileSync(outputPath, json2);
   }
   const githubOutputPath = flags.get("--github-output");
   if (githubOutputPath !== void 0) {
@@ -15937,7 +16195,7 @@ function emitResult(result, scalarOutputs, flags, stdout) {
       }
       return `${name}=${serialized}`;
     });
-    fs5.appendFileSync(githubOutputPath, `${outputLines.join("\n")}
+    fs6.appendFileSync(githubOutputPath, `${outputLines.join("\n")}
 `);
   }
   stdout(json2);
@@ -15973,7 +16231,7 @@ async function runReleaseCli(args, dependencies = {}) {
     }
     const validateStarterPaths = validateStarterPathsValue === "true";
     const pathsFile = optionalString(flags, "--paths-file");
-    const pathsDocument = pathsFile ? JSON.parse(fs5.readFileSync(pathsFile, "utf8")) : getFirstPartyStarterPaths();
+    const pathsDocument = pathsFile ? JSON.parse(fs6.readFileSync(pathsFile, "utf8")) : getFirstPartyStarterPaths();
     const starterPaths = pathsDocument !== null && typeof pathsDocument === "object" && !Array.isArray(pathsDocument) && "starterPaths" in pathsDocument ? pathsDocument.starterPaths : pathsDocument ?? getFirstPartyStarterPaths();
     if (!Array.isArray(starterPaths) || starterPaths.length === 0 || starterPaths.length > 100 || !starterPaths.every(
       (value) => typeof value === "string" && /^[A-Za-z0-9._/-]+$/.test(value) && !value.startsWith("/") && !value.split("/").includes("..")
@@ -16086,7 +16344,7 @@ async function runReleaseCli(args, dependencies = {}) {
     const buildInfoPath = requiredString(flags, "--build-info");
     let result2;
     try {
-      result2 = parseBuildInfo(fs5.readFileSync(buildInfoPath, "utf8"));
+      result2 = parseBuildInfo(fs6.readFileSync(buildInfoPath, "utf8"));
     } catch (error48) {
       throw new ReleaseCliInputError(
         `Invalid CLI build information: ${error48 instanceof Error ? error48.message : String(error48)}`
@@ -16128,7 +16386,7 @@ async function runReleaseCli(args, dependencies = {}) {
   }
   if (command === "verify-published") {
     const archivePath = requiredString(flags, "--archive");
-    const archive = fs5.readFileSync(archivePath);
+    const archive = fs6.readFileSync(archivePath);
     const result2 = await verifyPublishedPackage({
       archive,
       registryIntegrity: requiredString(flags, "--registry-integrity"),
@@ -16170,8 +16428,8 @@ async function runReleaseCli(args, dependencies = {}) {
     const buildInfoPath = requiredString(flags, "--build-info");
     const archivePath = requiredString(flags, "--archive");
     const result2 = createValidationManifest({
-      buildInfo: parseBuildInfo(fs5.readFileSync(buildInfoPath, "utf8")),
-      archiveIntegrity: calculatePackageIntegrity(fs5.readFileSync(archivePath))
+      buildInfo: parseBuildInfo(fs6.readFileSync(buildInfoPath, "utf8")),
+      archiveIntegrity: calculatePackageIntegrity(fs6.readFileSync(archivePath))
     });
     emitResult(
       result2,
@@ -16190,7 +16448,7 @@ async function runReleaseCli(args, dependencies = {}) {
   }
   if (command === "manifest") {
     const buildInfoPath = requiredString(flags, "--build-info");
-    const buildInfo = parseBuildInfo(fs5.readFileSync(buildInfoPath, "utf8"));
+    const buildInfo = parseBuildInfo(fs6.readFileSync(buildInfoPath, "utf8"));
     const completionRunId = optionalString(flags, "--completion-run-id");
     const completion = completionRunId !== void 0 ? {
       workflowRunId: completionRunId,
@@ -16228,7 +16486,7 @@ async function runReleaseCli(args, dependencies = {}) {
   if (command === "reconcile") {
     const expectedManifestPath = requiredString(flags, "--expected-manifest");
     const expectedManifest = parseReleaseManifest(
-      fs5.readFileSync(expectedManifestPath, "utf8")
+      fs6.readFileSync(expectedManifestPath, "utf8")
     );
     const tagTarget = optionalString(flags, "--tag-target");
     const releaseTag = optionalString(flags, "--release-tag");