@fern-api/fern-api-dev 4.80.4-1-gc11eebc7322 → 4.80.4-4-g3da138c98f4

package/cli.cjs

@@ -68378,8 +68378,8 @@ var require_graceful_fs = __commonJS({
         }
       }
       var fs$writeFile = fs28.writeFile;
-      fs28.writeFile = writeFile90;
-      function writeFile90(path99, data2, options2, cb) {
+      fs28.writeFile = writeFile91;
+      function writeFile91(path99, data2, options2, cb) {
         if (typeof options2 === "function")
           cb = options2, options2 = null;
         return go$writeFile(path99, data2, options2, cb);
@@ -68396,8 +68396,8 @@ var require_graceful_fs = __commonJS({
       }
       var fs$appendFile = fs28.appendFile;
       if (fs$appendFile)
-        fs28.appendFile = appendFile2;
-      function appendFile2(path99, data2, options2, cb) {
+        fs28.appendFile = appendFile3;
+      function appendFile3(path99, data2, options2, cb) {
         if (typeof options2 === "function")
           cb = options2, options2 = null;
         return go$appendFile(path99, data2, options2, cb);
@@ -290012,8 +290012,8 @@ var require_graceful_fs2 = __commonJS({
         }
       }
       var fs$writeFile = fs28.writeFile;
-      fs28.writeFile = writeFile90;
-      function writeFile90(path99, data2, options2, cb) {
+      fs28.writeFile = writeFile91;
+      function writeFile91(path99, data2, options2, cb) {
         if (typeof options2 === "function")
           cb = options2, options2 = null;
         return go$writeFile(path99, data2, options2, cb);
@@ -290030,8 +290030,8 @@ var require_graceful_fs2 = __commonJS({
       }
       var fs$appendFile = fs28.appendFile;
       if (fs$appendFile)
-        fs28.appendFile = appendFile2;
-      function appendFile2(path99, data2, options2, cb) {
+        fs28.appendFile = appendFile3;
+      function appendFile3(path99, data2, options2, cb) {
         if (typeof options2 === "function")
           cb = options2, options2 = null;
         return go$appendFile(path99, data2, options2, cb);
@@ -337996,7 +337996,7 @@ var require_dist14 = __commonJS({
       }
       return result;
     }
-    var import_promises184 = require("fs/promises");
+    var import_promises185 = require("fs/promises");
     var import_node_os15 = require("os");
     var import_node_path210 = require("path");
     var import_minimatch8 = require_commonjs3();
@@ -338209,9 +338209,9 @@ var require_dist14 = __commonJS({
               if (laterFiles.has(fileResult.file) || laterFiles.has(originalPath)) {
                 const filePath = (0, import_node_path210.join)(this.outputDir, fileResult.file);
                 try {
-                  const content5 = await (0, import_promises184.readFile)(filePath, "utf-8");
+                  const content5 = await (0, import_promises185.readFile)(filePath, "utf-8");
                   const stripped = stripConflictMarkers(content5);
-                  await (0, import_promises184.writeFile)(filePath, stripped);
+                  await (0, import_promises185.writeFile)(filePath, stripped);
                 } catch {
                 }
               }
@@ -338223,7 +338223,7 @@ var require_dist14 = __commonJS({
       /** Populate accumulator after git apply succeeds. */
       async populateAccumulatorForPatch(patch5, baseGen, currentTreeHash) {
         if (!baseGen) return;
-        const tempDir2 = await (0, import_promises184.mkdtemp)((0, import_node_path210.join)((0, import_node_os15.tmpdir)(), "replay-acc-"));
+        const tempDir2 = await (0, import_promises185.mkdtemp)((0, import_node_path210.join)((0, import_node_os15.tmpdir)(), "replay-acc-"));
         const { GitClient: GitClient2 } = await Promise.resolve().then(() => (init_GitClient(), GitClient_exports));
         const tempGit = new GitClient2(tempDir2);
         await tempGit.exec(["init"]);
@@ -338235,7 +338235,7 @@ var require_dist14 = __commonJS({
             const resolvedPath = await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash);
             const base4 = await this.git.showFile(baseGen.tree_hash, filePath);
             const theirs = await this.applyPatchToContent(base4, patch5.patch_content, filePath, tempGit, tempDir2);
-            const effectiveTheirs = theirs ?? await (0, import_promises184.readFile)((0, import_node_path210.join)(this.outputDir, resolvedPath), "utf-8").catch(() => null);
+            const effectiveTheirs = theirs ?? await (0, import_promises185.readFile)((0, import_node_path210.join)(this.outputDir, resolvedPath), "utf-8").catch(() => null);
             if (effectiveTheirs != null) {
               this.fileTheirsAccumulator.set(resolvedPath, {
                 content: effectiveTheirs,
@@ -338244,7 +338244,7 @@ var require_dist14 = __commonJS({
             }
           }
         } finally {
-          await (0, import_promises184.rm)(tempDir2, { recursive: true }).catch(() => {
+          await (0, import_promises185.rm)(tempDir2, { recursive: true }).catch(() => {
           });
         }
       }
@@ -338273,7 +338273,7 @@ var require_dist14 = __commonJS({
           const snapshots = /* @__PURE__ */ new Map();
           for (const filePath of patch5.files) {
             const fullPath = (0, import_node_path210.join)(this.outputDir, filePath);
-            snapshots.set(filePath, await (0, import_promises184.readFile)(fullPath, "utf-8").catch(() => null));
+            snapshots.set(filePath, await (0, import_promises185.readFile)(fullPath, "utf-8").catch(() => null));
           }
           try {
             await this.git.execWithInput(["apply", "--3way"], patch5.patch_content);
@@ -338288,9 +338288,9 @@ var require_dist14 = __commonJS({
             for (const [filePath, content5] of snapshots) {
               const fullPath = (0, import_node_path210.join)(this.outputDir, filePath);
               if (content5 != null) {
-                await (0, import_promises184.writeFile)(fullPath, content5);
+                await (0, import_promises185.writeFile)(fullPath, content5);
               } else {
-                await (0, import_promises184.unlink)(fullPath).catch(() => {
+                await (0, import_promises185.unlink)(fullPath).catch(() => {
                 });
               }
             }
@@ -338301,7 +338301,7 @@ var require_dist14 = __commonJS({
       async applyWithThreeWayMerge(patch5) {
         const fileResults = [];
         const resolvedFiles = {};
-        const tempDir2 = await (0, import_promises184.mkdtemp)((0, import_node_path210.join)((0, import_node_os15.tmpdir)(), "replay-"));
+        const tempDir2 = await (0, import_promises185.mkdtemp)((0, import_node_path210.join)((0, import_node_os15.tmpdir)(), "replay-"));
         const { GitClient: GitClient2 } = await Promise.resolve().then(() => (init_GitClient(), GitClient_exports));
         const tempGit = new GitClient2(tempDir2);
         await tempGit.exec(["init"]);
@@ -338324,7 +338324,7 @@ var require_dist14 = __commonJS({
             fileResults.push(result);
           }
         } finally {
-          await (0, import_promises184.rm)(tempDir2, { recursive: true }).catch(() => {
+          await (0, import_promises185.rm)(tempDir2, { recursive: true }).catch(() => {
           });
         }
         const conflictFiles = fileResults.filter((r5) => r5.status === "conflict");
@@ -338365,7 +338365,7 @@ var require_dist14 = __commonJS({
             }
           }
           const oursPath = (0, import_node_path210.join)(this.outputDir, resolvedPath);
-          const ours = await (0, import_promises184.readFile)(oursPath, "utf-8").catch(() => null);
+          const ours = await (0, import_promises185.readFile)(oursPath, "utf-8").catch(() => null);
           let ghostReconstructed = false;
           let theirs = null;
           if (!base4 && ours && !renameSourcePath) {
@@ -338462,15 +338462,15 @@ var require_dist14 = __commonJS({
               baseGeneration: patch5.base_generation
             });
             const outDir2 = (0, import_node_path210.dirname)(oursPath);
-            await (0, import_promises184.mkdir)(outDir2, { recursive: true });
-            await (0, import_promises184.writeFile)(oursPath, effective_theirs);
+            await (0, import_promises185.mkdir)(outDir2, { recursive: true });
+            await (0, import_promises185.writeFile)(oursPath, effective_theirs);
             return { file: resolvedPath, status: "merged", reason: "new-file" };
           }
           if (base4 == null && ours != null && effective_theirs != null && !useAccumulatorAsMergeBase) {
             const merged2 = threeWayMerge("", ours, effective_theirs);
             const outDir2 = (0, import_node_path210.dirname)(oursPath);
-            await (0, import_promises184.mkdir)(outDir2, { recursive: true });
-            await (0, import_promises184.writeFile)(oursPath, merged2.content);
+            await (0, import_promises185.mkdir)(outDir2, { recursive: true });
+            await (0, import_promises185.writeFile)(oursPath, merged2.content);
             if (merged2.hasConflicts) {
               return {
                 file: resolvedPath,
@@ -338510,8 +338510,8 @@ var require_dist14 = __commonJS({
           }
           const merged = threeWayMerge(mergeBase, ours, effective_theirs);
           const outDir = (0, import_node_path210.dirname)(oursPath);
-          await (0, import_promises184.mkdir)(outDir, { recursive: true });
-          await (0, import_promises184.writeFile)(oursPath, merged.content);
+          await (0, import_promises185.mkdir)(outDir, { recursive: true });
+          await (0, import_promises185.writeFile)(oursPath, merged.content);
           if (effective_theirs != null && !merged.hasConflicts) {
             this.fileTheirsAccumulator.set(resolvedPath, {
               content: effective_theirs,
@@ -338586,8 +338586,8 @@ var require_dist14 = __commonJS({
         try {
           if (sourceFilePath) {
             const tempSourcePath = (0, import_node_path210.join)(tempDir2, sourceFilePath);
-            await (0, import_promises184.mkdir)((0, import_node_path210.dirname)(tempSourcePath), { recursive: true });
-            await (0, import_promises184.writeFile)(tempSourcePath, base4);
+            await (0, import_promises185.mkdir)((0, import_node_path210.dirname)(tempSourcePath), { recursive: true });
+            await (0, import_promises185.writeFile)(tempSourcePath, base4);
             await tempGit.exec(["add", sourceFilePath]);
             await tempGit.exec([
               "commit",
@@ -338597,15 +338597,15 @@ var require_dist14 = __commonJS({
             ]);
             await tempGit.execWithInput(["apply", "--allow-empty"], fileDiff);
             const tempTargetPath = (0, import_node_path210.join)(tempDir2, filePath);
-            return await (0, import_promises184.readFile)(tempTargetPath, "utf-8");
+            return await (0, import_promises185.readFile)(tempTargetPath, "utf-8");
           }
           const tempFilePath = (0, import_node_path210.join)(tempDir2, filePath);
-          await (0, import_promises184.mkdir)((0, import_node_path210.dirname)(tempFilePath), { recursive: true });
-          await (0, import_promises184.writeFile)(tempFilePath, base4);
+          await (0, import_promises185.mkdir)((0, import_node_path210.dirname)(tempFilePath), { recursive: true });
+          await (0, import_promises185.writeFile)(tempFilePath, base4);
           await tempGit.exec(["add", filePath]);
           await tempGit.exec(["commit", "-m", `base for ${filePath}`, "--allow-empty"]);
           await tempGit.execWithInput(["apply", "--allow-empty"], fileDiff);
-          return await (0, import_promises184.readFile)(tempFilePath, "utf-8");
+          return await (0, import_promises185.readFile)(tempFilePath, "utf-8");
         } catch {
           return null;
         }
@@ -338622,8 +338622,8 @@ var require_dist14 = __commonJS({
         if (!fileDiff) return false;
         try {
           const tempFilePath = (0, import_node_path210.join)(tempDir2, filePath);
-          await (0, import_promises184.mkdir)((0, import_node_path210.dirname)(tempFilePath), { recursive: true });
-          await (0, import_promises184.writeFile)(tempFilePath, content5);
+          await (0, import_promises185.mkdir)((0, import_node_path210.dirname)(tempFilePath), { recursive: true });
+          await (0, import_promises185.writeFile)(tempFilePath, content5);
           await tempGit.exec(["add", filePath]);
           await tempGit.exec(["commit", "-m", `check already-applied ${filePath}`, "--allow-empty"]);
           await tempGit.execWithInput(["apply", "--reverse", "--check", "--allow-empty"], fileDiff);
@@ -352442,8 +352442,8 @@ var require_jsonfile = __commonJS({
       const str3 = stringify5(obj, options2);
       await universalify.fromCallback(fs27.writeFile)(file4, str3, options2);
     }
-    var writeFile90 = universalify.fromPromise(_writeFile);
-    function writeFileSync8(file4, obj, options2 = {}) {
+    var writeFile91 = universalify.fromPromise(_writeFile);
+    function writeFileSync9(file4, obj, options2 = {}) {
       const fs27 = options2.fs || _fs;
       const str3 = stringify5(obj, options2);
       return fs27.writeFileSync(file4, str3, options2);
@@ -352451,8 +352451,8 @@ var require_jsonfile = __commonJS({
     module4.exports = {
       readFile: readFile104,
       readFileSync: readFileSync19,
-      writeFile: writeFile90,
-      writeFileSync: writeFileSync8
+      writeFile: writeFile91,
+      writeFileSync: writeFileSync9
     };
   }
 });
@@ -567266,25 +567266,28 @@ var TtyAwareLogger = class {
   }
   paint() {
     const spinnerFrame = this.spinner.frame();
-    const taskLines = [];
+    const frames = [];
     for (const task of this.tasks) {
-      const paintForTask = task.printInteractiveTasks({ spinner: spinnerFrame });
-      if (paintForTask.length > 0) {
-        taskLines.push(paintForTask);
+      const body = task.printInteractiveTasks({ spinner: spinnerFrame });
+      if (body.length > 0) {
+        frames.push({ title: task.title, body });
       }
     }
-    if (taskLines.length === 0) {
+    if (frames.length === 0) {
       return "";
     }
     const spinnerStatus = process.env.FERN_SPINNER_STATUS;
-    if (spinnerStatus && taskLines.length > 0) {
-      taskLines[0] = `${taskLines[0]} - ${spinnerStatus}`;
+    if (spinnerStatus) {
+      const first3 = frames[0];
+      if (first3 != null) {
+        first3.body = `${first3.body} - ${spinnerStatus}`;
+      }
     }
-    const paint = [
-      "\u250C\u2500",
-      ...taskLines.map((taskLine) => addPrefixToString({ content: taskLine, prefix: "\u2502 ", includePrefixOnAllLines: true })),
+    const paint = frames.map(({ title: title3, body }) => [
+      title3 != null ? `\u250C\u2500 ${title3} \u2500` : "\u250C\u2500",
+      addPrefixToString({ content: body, prefix: "\u2502 ", includePrefixOnAllLines: true }),
       "\u2514\u2500"
-    ].join("\n") + "\n";
+    ].join("\n")).join("\n") + "\n";
     this.lastPaint = paint;
     return paint;
   }
@@ -614331,7 +614334,7 @@ var AccessTokenPosthogManager = class {
         properties: {
           ...event,
           ...event.properties,
-          version: "4.80.4-1-gc11eebc7322",
+          version: "4.80.4-4-g3da138c98f4",
           usingAccessToken: true
         }
       });
@@ -614385,7 +614388,7 @@ var UserPosthogManager = class {
       distinctId: this.userId ?? await this.getPersistedDistinctId(),
       event: "CLI",
       properties: {
-        version: "4.80.4-1-gc11eebc7322",
+        version: "4.80.4-4-g3da138c98f4",
         ...event,
         ...event.properties,
         usingAccessToken: false,
@@ -788501,13 +788504,13 @@ async function removeInvalidAiExamples({ sourceFilePath, context: context3 }) {
         }
       }
     }
-    const { writeFile: writeFile90 } = await import("fs/promises");
+    const { writeFile: writeFile91 } = await import("fs/promises");
     const yamlContent = jsYaml.dump(parsed, {
       indent: 2,
       lineWidth: -1,
       noRefs: true
     });
-    await writeFile90(overrideFilePath, yamlContent, "utf-8");
+    await writeFile91(overrideFilePath, yamlContent, "utf-8");
     context3.logger.info(`Removed ${validationResult.invalidCount} invalid AI examples from ai_examples_override.yml`);
     return {
       removedCount: validationResult.invalidCount,
@@ -831666,7 +831669,7 @@ var LOCAL_STORAGE_FOLDER4 = ".fern-dev";
 var LOGS_FOLDER_NAME = "logs";
 var MAX_LOGS_DIR_SIZE_BYTES = 100 * 1024 * 1024;
 function getCliSource() {
-  const version7 = "4.80.4-1-gc11eebc7322";
+  const version7 = "4.80.4-4-g3da138c98f4";
   return `cli@${version7}`;
 }
 var DebugLogger = class {
@@ -834541,6 +834544,9 @@ async function validateAPIWorkspaceAndLogIssues({ workspace, context: context3,
   }
 }
 
+// ../generation/remote-generation/remote-workspace-runner/lib/runRemoteGenerationForAPIWorkspace.js
+init_lib4();
+
 // ../workspace/loader/lib/handleFailedWorkspaceParserResult.js
 init_lib4();
 init_zod();
@@ -842030,14 +842036,51 @@ async function uploadDynamicIRForSdkGeneration({ fdr, organization, version: ver
 }
 
 // ../generation/remote-generation/remote-workspace-runner/lib/runRemoteGenerationForAPIWorkspace.js
-async function runRemoteGenerationForAPIWorkspace({ projectConfig, organization, workspace, context: context3, generatorGroup, version: version7, shouldLogS3Url, token, whitelabel, absolutePathToPreview, isPreview, fiddlePreview, pushPreviewBranch, mode, fernignorePath, skipFernignore, dynamicIrOnly, validateWorkspace, retryRateLimited, requireEnvVars, automationMode, autoMerge }) {
+async function runRemoteGenerationForAPIWorkspace({ projectConfig, organization, workspace, context: context3, generatorGroup, version: version7, shouldLogS3Url, token, whitelabel, absolutePathToPreview, isPreview, fiddlePreview, pushPreviewBranch, mode, fernignorePath, skipFernignore, dynamicIrOnly, validateWorkspace, retryRateLimited, requireEnvVars, automationMode, autoMerge, automation }) {
   if (generatorGroup.generators.length === 0) {
     context3.logger.warn("No generators specified.");
     return null;
   }
-  const interactiveTasks = [];
   const snippetsProducedBy = [];
-  interactiveTasks.push(...generatorGroup.generators.map((generatorInvocation) => context3.runInteractiveTask({ name: generatorInvocation.name }, async (interactiveTaskContext) => {
+  const results = await Promise.all(generatorGroup.generators.map((generatorInvocation) => context3.runInteractiveTask({ name: generatorInvocation.name }, (interactiveTaskContext) => generateOne({
+    generatorInvocation,
+    interactiveTaskContext,
+    // Closed-over state + params passed through to the per-generator worker.
+    projectConfig,
+    organization,
+    workspace,
+    context: context3,
+    generatorGroup,
+    version: version7,
+    shouldLogS3Url,
+    token,
+    whitelabel,
+    absolutePathToPreview,
+    isPreview,
+    fiddlePreview,
+    pushPreviewBranch,
+    mode,
+    fernignorePath,
+    skipFernignore,
+    dynamicIrOnly,
+    validateWorkspace,
+    retryRateLimited,
+    requireEnvVars,
+    automationMode,
+    autoMerge,
+    automation,
+    onSnippetsProduced: (invocation) => snippetsProducedBy.push(invocation)
+  }))));
+  if (automation == null && results.some((didSucceed) => !didSucceed)) {
+    context3.failAndThrow();
+  }
+  return {
+    snippetsProducedBy
+  };
+}
+async function generateOne({ generatorInvocation, interactiveTaskContext, projectConfig, organization, workspace, context: context3, generatorGroup, version: version7, shouldLogS3Url, token, whitelabel, absolutePathToPreview, isPreview, fiddlePreview, pushPreviewBranch, mode, fernignorePath, skipFernignore, dynamicIrOnly, validateWorkspace, retryRateLimited, requireEnvVars, automationMode, autoMerge, automation, onSnippetsProduced }) {
+  const startedAt = Date.now();
+  try {
     const settings = getBaseOpenAPIWorkspaceSettingsFromGeneratorInvocation(generatorInvocation);
     const fernWorkspace = await workspace.toFernWorkspace({ context: context3 }, settings, generatorInvocation.apiOverride?.specs);
     if (validateWorkspace) {
@@ -842097,8 +842140,8 @@ async function runRemoteGenerationForAPIWorkspace({ projectConfig, organization,
       automationMode,
       autoMerge
     });
-    if (remoteTaskHandlerResponse != null && remoteTaskHandlerResponse.createdSnippets) {
-      snippetsProducedBy.push(generatorInvocation);
+    if (remoteTaskHandlerResponse?.createdSnippets) {
+      onSnippetsProduced(generatorInvocation);
       if (generatorInvocation.absolutePathToLocalSnippets != null && remoteTaskHandlerResponse.snippetsS3PreSignedReadUrl != null) {
         await downloadSnippetsForTask({
           snippetsS3PreSignedReadUrl: remoteTaskHandlerResponse.snippetsS3PreSignedReadUrl,
@@ -842107,14 +842150,27 @@ async function runRemoteGenerationForAPIWorkspace({ projectConfig, organization,
         });
       }
     }
-  })));
-  const results = await Promise.all(interactiveTasks);
-  if (results.some((didSucceed) => !didSucceed)) {
-    context3.failAndThrow();
+    automation?.recorder.recordSuccess({
+      apiName: workspace.workspaceName,
+      groupName: generatorGroup.groupName,
+      generatorName: generatorInvocation.name,
+      version: remoteTaskHandlerResponse?.actualVersion ?? null,
+      durationMs: Date.now() - startedAt
+    });
+  } catch (error50) {
+    if (automation == null) {
+      throw error50;
+    }
+    const message = extractErrorMessage(error50);
+    automation.recorder.recordFailure({
+      apiName: workspace.workspaceName,
+      groupName: generatorGroup.groupName,
+      generatorName: generatorInvocation.name,
+      errorMessage: message,
+      durationMs: Date.now() - startedAt
+    });
+    interactiveTaskContext.failWithoutThrowing(message);
   }
-  return {
-    snippetsProducedBy
-  };
 }
 
 // ../generation/remote-generation/remote-workspace-runner/lib/runRemoteGenerationForDocsWorkspace.js
@@ -843180,7 +843236,7 @@ var LegacyDocsPublisher = class {
         previewId,
         disableTemplates: void 0,
         skipUpload,
-        cliVersion: "4.80.4-1-gc11eebc7322"
+        cliVersion: "4.80.4-4-g3da138c98f4"
       });
       if (taskContext.getResult() === TaskResult.Failure) {
         return { success: false };
@@ -917757,6 +917813,7 @@ var TaskContextImpl = class {
   result = TaskResult.Success;
   logImmediately;
   logPrefix;
+  title;
   subtasks = [];
   shouldBufferLogs;
   bufferedLogs = [];
@@ -917767,6 +917824,7 @@ var TaskContextImpl = class {
   constructor({
     logImmediately,
     logPrefix,
+    title: title3,
     takeOverTerminal,
     onResult,
     shouldBufferLogs,
@@ -917775,6 +917833,7 @@ var TaskContextImpl = class {
   }) {
     this.logImmediately = logImmediately;
     this.logPrefix = logPrefix ?? "";
+    this.title = title3;
     this.takeOverTerminal = takeOverTerminal;
     this.onResult = onResult;
     this.shouldBufferLogs = shouldBufferLogs;
@@ -917915,25 +917974,34 @@ var InteractiveTaskContextImpl = class extends TaskContextImpl {
     }
     lines.push(...this.subtasks.map((subtask) => subtask.print({ spinner })));
     return addPrefixToString({
-      prefix: `${this.getIcon({ spinner }).padEnd(spinner.length)} `,
+      prefix: this.getIcon({ spinner }),
       content: lines.join("\n")
     });
   }
   printInteractiveTasks({ spinner }) {
     return this.print({ spinner });
   }
+  /**
+   * Tasks with subtasks (e.g. a generator group whose children are individual generators)
+   * render with a disclosure-triangle glyph instead of the leaf check/x/spinner, so the
+   * tree shape is legible at a glance. Leaves keep the existing per-status glyphs.
+   *
+   * Every branch returns a string ending in a trailing space so the caller doesn't need
+   * to pad — `spinner` from ora already includes one, and static glyphs add one explicitly.
+   */
   getIcon({ spinner }) {
+    const hasChildren2 = this.subtasks.length > 0;
     switch (this.status) {
       case "notStarted":
-        return source_default.dim("\u25E6");
+        return hasChildren2 ? source_default.dim("\u25B8 ") : source_default.dim("\u25E6 ");
       case "running":
-        return spinner;
+        return hasChildren2 ? source_default.cyan("\u25BE ") : spinner;
       case "finished":
         switch (this.getResult()) {
           case TaskResult.Success:
-            return source_default.green("\u2713");
+            return hasChildren2 ? source_default.green("\u25BE ") : source_default.green("\u2713 ");
           case TaskResult.Failure:
-            return source_default.red("x");
+            return hasChildren2 ? source_default.red("\u25BE ") : source_default.red("x ");
         }
     }
   }
@@ -918269,7 +918337,7 @@ var CliContext = class _CliContext {
     if (false) {
       this.logger.error("CLI_VERSION is not defined");
     }
-    return "4.80.4-1-gc11eebc7322";
+    return "4.80.4-4-g3da138c98f4";
   }
   getCliName() {
     if (false) {
@@ -918416,16 +918484,16 @@ var CliContext = class _CliContext {
   logger = createLogger((level, ...args) => this.log(level, ...args));
   stderr = createLogger((level, ...args) => this.logStderr(level, ...args));
   constructTaskInitForWorkspace(workspace) {
-    const prefixWithoutPadding = wrapWorkspaceNameForPrefix(
-      workspace.type === "docs" ? "docs" : workspace.workspaceName ?? "api"
-    );
+    const workspaceName = workspace.type === "docs" ? "docs" : workspace.workspaceName ?? "api";
+    const prefixWithoutPadding = wrapWorkspaceNameForPrefix(workspaceName);
     const minLengthForPrefix = 1 + (this.longestWorkspaceName != null ? wrapWorkspaceNameForPrefix(this.longestWorkspaceName) : prefixWithoutPadding).length;
     const prefix2 = prefixWithoutPadding.padEnd(minLengthForPrefix);
     const colorForWorkspace = WORKSPACE_NAME_COLORS[this.numTasks++ % WORKSPACE_NAME_COLORS.length];
     const prefixWithColor = source_default.hex(colorForWorkspace)(prefix2);
     return {
       ...this.constructTaskInit(),
-      logPrefix: prefixWithColor
+      logPrefix: prefixWithColor,
+      title: source_default.hex(colorForWorkspace).bold(workspaceName)
     };
   }
   constructTaskInit() {
@@ -919855,6 +919923,1007 @@ async function addGeneratorToWorkspaces({
   );
 }
 
+// src/commands/generate/filterGenerators.ts
+function parseGeneratorArg(generatorArg) {
+  if (generatorArg == null) {
+    return { generatorName: void 0, generatorIndex: void 0 };
+  }
+  const parsed = generatorArg.length > 0 ? Number(generatorArg) : Number.NaN;
+  if (!Number.isNaN(parsed) && Number.isInteger(parsed) && parsed >= 0) {
+    return { generatorName: void 0, generatorIndex: parsed };
+  }
+  return { generatorName: generatorArg, generatorIndex: void 0 };
+}
+function filterGenerators({
+  generators,
+  generatorIndex,
+  generatorName,
+  groupName
+}) {
+  if (generatorIndex != null) {
+    const generator = generators[generatorIndex];
+    if (generator == null) {
+      return {
+        ok: false,
+        error: `Generator index ${generatorIndex} is out of bounds in group '${groupName}' (${generators.length} generators available)`
+      };
+    }
+    return { ok: true, generators: [generator] };
+  }
+  if (generatorName != null) {
+    const filtered = generators.filter((gen) => gen.name === generatorName);
+    if (filtered.length === 0) {
+      const available = generators.map((gen) => gen.name);
+      return {
+        ok: false,
+        error: `Generator '${generatorName}' not found in group '${groupName}'. Available generators: ${available.join(", ")}`
+      };
+    }
+    return { ok: true, generators: filtered };
+  }
+  return { ok: true, generators };
+}
+
+// src/commands/generate/generateAPIWorkspaces.ts
+init_lib6();
+
+// src/constants.ts
+var API_CLI_OPTION = "api";
+var GROUP_CLI_OPTION = "group";
+var PREVIEW_DIRECTORY = ".preview";
+var APPROVED_DIRECTORIES_FILENAME = "approved-output-directories";
+var LOCAL_STORAGE_FOLDER6 = ".fern-dev";
+
+// src/commands/generate/checkOutputDirectory.ts
+init_lib6();
+var import_promises136 = require("fs/promises");
+
+// src/persistence/output-directories/getOutputDirectories.ts
+init_lib6();
+var import_promises134 = require("fs/promises");
+
+// src/persistence/output-directories/getPathToOutputDirectoriesFile.ts
+init_lib6();
+var import_os16 = require("os");
+function getPathToOutputDirectoriesFile() {
+  return join8(
+    AbsoluteFilePath2.of((0, import_os16.homedir)()),
+    RelativeFilePath2.of(LOCAL_STORAGE_FOLDER6),
+    RelativeFilePath2.of(APPROVED_DIRECTORIES_FILENAME)
+  );
+}
+
+// src/persistence/output-directories/getOutputDirectories.ts
+async function getOutputDirectories() {
+  const pathToOutputDirectoriesFile = getPathToOutputDirectoriesFile();
+  const doesOutputDirectoriesFileExist = await doesPathExist(pathToOutputDirectoriesFile);
+  if (!doesOutputDirectoriesFileExist) {
+    return [];
+  }
+  const outputDirectoriesFileContents = await (0, import_promises134.readFile)(pathToOutputDirectoriesFile, { encoding: "utf-8" });
+  const outputDirectories = JSON.parse(outputDirectoriesFileContents);
+  return outputDirectories;
+}
+
+// src/persistence/output-directories/storeOutputDirectories.ts
+var import_promises135 = require("fs/promises");
+var import_path85 = __toESM(require("path"), 1);
+async function storeOutputDirectories(outputDirectories) {
+  await (0, import_promises135.mkdir)(import_path85.default.dirname(getPathToOutputDirectoriesFile()), { recursive: true });
+  await (0, import_promises135.writeFile)(getPathToOutputDirectoriesFile(), JSON.stringify(outputDirectories, null, 2));
+}
+
+// src/commands/generate/checkOutputDirectory.ts
+async function checkOutputDirectory(outputPath, cliContext, force) {
+  if (!outputPath || isCI() || force) {
+    return {
+      shouldProceed: true
+    };
+  }
+  const savedDirectories = await getOutputDirectories();
+  if (savedDirectories?.includes(outputPath)) {
+    return {
+      shouldProceed: true
+    };
+  }
+  const doesExist = await doesPathExist(outputPath);
+  if (!doesExist) {
+    return {
+      shouldProceed: true
+    };
+  }
+  const files = await (0, import_promises136.readdir)(outputPath);
+  if (files.length === 0) {
+    return {
+      shouldProceed: true
+    };
+  }
+  const shouldOverwrite = await cliContext.confirmPrompt(
+    `Directory ${outputPath} contains existing files that may be overwritten. Continue?`,
+    false
+  );
+  if (!shouldOverwrite) {
+    return {
+      shouldProceed: false
+    };
+  }
+  await storeOutputDirectories([...savedDirectories ?? [], outputPath]);
+  return {
+    shouldProceed: true
+  };
+}
+
+// src/commands/generate/generateAPIWorkspace.ts
+init_lib6();
+
+// src/commands/generate/resolveGroupAlias.ts
+function resolveGroupAlias({
+  name: name2,
+  groupAliases,
+  availableGroupNames
+}) {
+  const aliasTargets = groupAliases[name2];
+  if (aliasTargets != null) {
+    for (const target of aliasTargets) {
+      if (!availableGroupNames.includes(target)) {
+        return {
+          type: "alias-references-missing-group",
+          alias: name2,
+          missingGroupName: target,
+          availableGroupNames
+        };
+      }
+    }
+    return { type: "resolved", groupNames: aliasTargets };
+  }
+  if (availableGroupNames.includes(name2)) {
+    return { type: "resolved", groupNames: [name2] };
+  }
+  return {
+    type: "unknown",
+    name: name2,
+    availableGroupNames,
+    availableAliasNames: Object.keys(groupAliases)
+  };
+}
+
+// src/commands/generate/resolveGroupNamesForGeneration.ts
+function resolveGroupNamesForGeneration({
+  groupName,
+  generatorsConfiguration,
+  isAutomation
+}) {
+  if (isAutomation && groupName == null) {
+    return {
+      type: "fan-out",
+      groupNames: generatorsConfiguration.groups.map((g8) => g8.groupName)
+    };
+  }
+  const effective = groupName ?? generatorsConfiguration.defaultGroup;
+  if (effective == null) {
+    return {
+      type: "missing-group",
+      availableGroupNames: generatorsConfiguration.groups.map((g8) => g8.groupName)
+    };
+  }
+  return {
+    type: "targeted",
+    groupName: effective,
+    fromDefaultGroup: groupName == null
+  };
+}
+
+// src/commands/generate/describeSkipReason.ts
+function describeSkipReason(generator, rootAutorelease) {
+  if (!generator.automation.generate) {
+    return "automations.generate is false";
+  }
+  if (generator.absolutePathToLocalOutput != null) {
+    return "output is configured for local-file-system (cannot run remotely)";
+  }
+  if (generator.raw?.autorelease === false) {
+    return "autorelease is false";
+  }
+  if (generator.raw?.autorelease == null && rootAutorelease === false) {
+    return "autorelease is false at the root of generators.yml";
+  }
+  return null;
+}
+
+// src/commands/generate/shouldSkipGenerator.ts
+function shouldSkipGenerator({
+  generator,
+  rootAutorelease
+}) {
+  return describeSkipReason(generator, rootAutorelease) != null;
+}
+
+// src/commands/generate/selectGeneratorsForAutomation.ts
+function buildAutomationTargeting({
+  generatorIndex,
+  generatorName
+}) {
+  if (generatorIndex != null) {
+    return { type: "index", index: generatorIndex };
+  }
+  if (generatorName != null) {
+    return { type: "name", name: generatorName };
+  }
+  return { type: "none" };
+}
+function selectGeneratorsForAutomation({
+  generators,
+  rootAutorelease,
+  targeting
+}) {
+  if (targeting.type === "index") {
+    for (const g8 of generators) {
+      const reason = describeSkipReason(g8, rootAutorelease);
+      if (reason != null) {
+        return { type: "reject-opted-out", generatorName: g8.name, index: targeting.index, reason };
+      }
+    }
+    return { type: "run", generators };
+  }
+  const eligible = generators.filter((g8) => !shouldSkipGenerator({ generator: g8, rootAutorelease }));
+  if (eligible.length === 0) {
+    return { type: "empty-after-skip" };
+  }
+  return { type: "run", generators: eligible };
+}
+
+// src/commands/generate/shouldSkipMissingGenerator.ts
+function shouldSkipMissingGenerator({
+  automation,
+  generatorName,
+  generatorIndex
+}) {
+  return automation != null && generatorName != null && generatorIndex == null;
+}
+
+// src/commands/generate/generateAPIWorkspace.ts
+async function generateWorkspace({
+  organization,
+  workspace,
+  projectConfig,
+  context: context3,
+  groupName,
+  generatorName,
+  generatorIndex,
+  version: version7,
+  shouldLogS3Url,
+  token,
+  useLocalDocker,
+  keepDocker,
+  absolutePathToPreview,
+  mode,
+  runner,
+  inspect: inspect6,
+  lfsOverride,
+  fernignorePath,
+  skipFernignore,
+  dynamicIrOnly,
+  noReplay,
+  retryRateLimited,
+  requireEnvVars,
+  automationMode,
+  autoMerge,
+  automation
+}) {
+  if (workspace.generatorsConfiguration == null) {
+    context3.logger.warn("This workspaces has no generators.yml");
+    return;
+  }
+  if (workspace.generatorsConfiguration.groups.length === 0) {
+    context3.logger.warn(`This workspace has no groups specified in ${GENERATORS_CONFIGURATION_FILENAME}`);
+    return;
+  }
+  const resolvedGroupNames = resolveGroupsOrFail({
+    groupName,
+    generatorsConfiguration: workspace.generatorsConfiguration,
+    isAutomation: automation != null,
+    context: context3
+  });
+  const { ai: ai10, replay } = workspace.generatorsConfiguration;
+  if (!useLocalDocker && !token) {
+    return context3.failAndThrow("Please run fern login", void 0, { code: CliError.Code.AuthError });
+  }
+  const runnableGroups = resolvedGroupNames.flatMap((resolvedGroupName) => {
+    const runnable = resolveRunnableGroup({
+      resolvedGroupName,
+      workspace,
+      generatorIndex,
+      generatorName,
+      automation,
+      lfsOverride,
+      context: context3,
+      useLocalDocker,
+      token
+    });
+    return runnable != null ? [{ resolvedGroupName, group: runnable }] : [];
+  });
+  await Promise.all(
+    runnableGroups.map(
+      ({ resolvedGroupName, group }) => context3.runInteractiveTask({ name: resolvedGroupName }, async (groupContext) => {
+        if (useLocalDocker) {
+          await runLocalGenerationForWorkspace({
+            token,
+            projectConfig,
+            workspace,
+            generatorGroup: group,
+            version: version7,
+            keepDocker,
+            context: groupContext,
+            runner,
+            absolutePathToPreview,
+            inspect: inspect6,
+            ai: ai10,
+            replay,
+            noReplay,
+            validateWorkspace: true,
+            requireEnvVars,
+            skipFernignore,
+            automationMode,
+            autoMerge
+          });
+        } else if (token != null) {
+          await runRemoteGenerationForAPIWorkspace({
+            projectConfig,
+            organization,
+            workspace,
+            context: groupContext,
+            generatorGroup: group,
+            version: version7,
+            shouldLogS3Url,
+            token,
+            whitelabel: workspace.generatorsConfiguration?.whitelabel,
+            absolutePathToPreview,
+            mode,
+            fernignorePath,
+            skipFernignore,
+            dynamicIrOnly,
+            validateWorkspace: true,
+            retryRateLimited,
+            requireEnvVars,
+            automationMode,
+            autoMerge,
+            automation
+          });
+        }
+      })
+    )
+  );
+}
+function resolveRunnableGroup({
+  resolvedGroupName,
+  workspace,
+  generatorIndex,
+  generatorName,
+  automation,
+  lfsOverride,
+  context: context3,
+  useLocalDocker,
+  token
+}) {
+  let group = workspace.generatorsConfiguration?.groups.find(
+    (otherGroup) => otherGroup.groupName === resolvedGroupName
+  );
+  if (group == null) {
+    return context3.failAndThrow(`Group '${resolvedGroupName}' does not exist.`, void 0, {
+      code: CliError.Code.ConfigError
+    });
+  }
+  const filterResult = filterGenerators({
+    generators: group.generators,
+    generatorIndex,
+    generatorName,
+    groupName: resolvedGroupName
+  });
+  if (!filterResult.ok) {
+    if (shouldSkipMissingGenerator({ automation, generatorName, generatorIndex })) {
+      return null;
+    }
+    return context3.failAndThrow(filterResult.error, void 0, { code: CliError.Code.ConfigError });
+  }
+  let filteredGenerators = filterResult.generators;
+  if (automation != null) {
+    const selection = selectGeneratorsForAutomation({
+      generators: filteredGenerators,
+      rootAutorelease: workspace.generatorsConfiguration?.rawConfiguration.autorelease,
+      targeting: buildAutomationTargeting({ generatorIndex, generatorName })
+    });
+    if (selection.type === "reject-opted-out") {
+      return context3.failAndThrow(
+        `Generator '${selection.generatorName}' at index ${selection.index} in group '${resolvedGroupName}' is excluded from automation: ${selection.reason}. Target by name instead to have opt-outs filtered silently, drop the --generator flag to fan out across eligible generators, or re-enable automation for this generator in generators.yml.`,
+        void 0,
+        { code: CliError.Code.ConfigError }
+      );
+    }
+    if (selection.type === "empty-after-skip") {
+      return null;
+    }
+    filteredGenerators = selection.generators;
+  }
+  group = { ...group, generators: filteredGenerators };
+  if (lfsOverride != null) {
+    group = applyLfsOverride(group, lfsOverride, context3);
+  }
+  if (!useLocalDocker && token != null) {
+    const customImageGenerators = group.generators.filter((g8) => g8.containerImage != null);
+    if (customImageGenerators.length > 0) {
+      const names2 = customImageGenerators.map((g8) => g8.name).join(", ");
+      return context3.failAndThrow(
+        `Custom image configurations are only supported with local generation (--local). The following generators use custom images: ${names2}`
+      );
+    }
+  }
+  return group;
+}
+function resolveGroupsOrFail({
+  groupName,
+  generatorsConfiguration,
+  isAutomation,
+  context: context3
+}) {
+  const resolution = resolveGroupNamesForGeneration({ groupName, generatorsConfiguration, isAutomation });
+  if (resolution.type === "fan-out") {
+    return resolution.groupNames;
+  }
+  if (resolution.type === "missing-group") {
+    const longestGroupName = Math.max(...resolution.availableGroupNames.map((name2) => name2.length));
+    const currentArgs = process.argv.slice(2).join(" ");
+    const suggestions = resolution.availableGroupNames.map((name2) => {
+      const suggestedCommand = `fern ${currentArgs} --${GROUP_CLI_OPTION} ${name2}`;
+      return ` \u203A ${source_default.bold(name2.padEnd(longestGroupName))}  ${source_default.dim(suggestedCommand)}`;
+    }).join("\n");
+    context3.failAndThrow(
+      `No group specified. Use the --${GROUP_CLI_OPTION} option, or set "${DEFAULT_GROUP_GENERATORS_CONFIG_KEY}" in ${GENERATORS_CONFIGURATION_FILENAME}:
+${suggestions}`,
+      void 0,
+      { code: CliError.Code.NetworkError }
+    );
+    return [];
+  }
+  if (resolution.fromDefaultGroup) {
+    context3.logger.info(
+      source_default.dim(`Using default group '${resolution.groupName}' from ${GENERATORS_CONFIGURATION_FILENAME}`)
+    );
+  }
+  const aliasResult = resolveGroupAlias({
+    name: resolution.groupName,
+    groupAliases: generatorsConfiguration.groupAliases,
+    availableGroupNames: generatorsConfiguration.groups.map((g8) => g8.groupName)
+  });
+  if (aliasResult.type === "alias-references-missing-group") {
+    context3.failAndThrow(
+      `Group alias '${aliasResult.alias}' references non-existent group '${aliasResult.missingGroupName}'. Available groups: ${aliasResult.availableGroupNames.join(", ")}`,
+      void 0,
+      { code: CliError.Code.NetworkError }
+    );
+    return [];
+  }
+  if (aliasResult.type === "unknown") {
+    const aliasesSuffix = aliasResult.availableAliasNames.length > 0 ? `. Available aliases: ${aliasResult.availableAliasNames.join(", ")}` : "";
+    context3.failAndThrow(
+      `'${aliasResult.name}' is not a valid group or alias. Available groups: ${aliasResult.availableGroupNames.join(", ")}${aliasesSuffix}`,
+      void 0,
+      { code: CliError.Code.NetworkError }
+    );
+    return [];
+  }
+  return aliasResult.groupNames;
+}
+function applyLfsOverride(group, lfsOverridePath, context3) {
+  const baseAbsolutePath = AbsoluteFilePath2.of(resolve6(cwd(), lfsOverridePath));
+  const languageCount = {};
+  const modifiedGenerators = [];
+  for (const generator of group.generators) {
+    const language = generator.language ?? getLanguageFromGeneratorName3(generator.name);
+    let outputPath;
+    if (group.generators.length === 1) {
+      outputPath = baseAbsolutePath;
+    } else {
+      const languageDir = language || "unknown";
+      if (languageCount[languageDir] == null) {
+        languageCount[languageDir] = 0;
+      }
+      languageCount[languageDir]++;
+      const dirName = languageCount[languageDir] === 1 ? languageDir : `${languageDir}-${languageCount[languageDir]}`;
+      outputPath = join8(baseAbsolutePath, RelativeFilePath2.of(dirName));
+    }
+    const modifiedGenerator = {
+      ...generator,
+      outputMode: api_exports4.remoteGen.OutputMode.downloadFiles({}),
+      absolutePathToLocalOutput: outputPath
+    };
+    modifiedGenerators.push(modifiedGenerator);
+    context3.logger.info(
+      `Overriding output for generator '${generator.name}' to local-file-system at: ${outputPath}`
+    );
+  }
+  return {
+    ...group,
+    generators: modifiedGenerators
+  };
+}
+function getLanguageFromGeneratorName3(generatorName) {
+  if (generatorName.includes("typescript") || generatorName.includes("ts")) {
+    return "typescript";
+  }
+  if (generatorName.includes("python") || generatorName.includes("py")) {
+    return "python";
+  }
+  if (generatorName.includes("java")) {
+    return "java";
+  }
+  if (generatorName.includes("go")) {
+    return "go";
+  }
+  if (generatorName.includes("ruby")) {
+    return "ruby";
+  }
+  if (generatorName.includes("csharp") || generatorName.includes("c#")) {
+    return "csharp";
+  }
+  if (generatorName.includes("swift")) {
+    return "swift";
+  }
+  if (generatorName.includes("php")) {
+    return "php";
+  }
+  if (generatorName.includes("rust")) {
+    return "rust";
+  }
+  return generatorName.replace(/[^a-zA-Z0-9]/g, "-").toLowerCase();
+}
+
+// src/commands/generate/resolvePosthogCommandLabel.ts
+function resolvePosthogCommandLabel(automation) {
+  return automation != null ? "fern automations generate" : "fern generate";
+}
+
+// src/commands/generate/shouldPreflightGenerator.ts
+function shouldPreflightGenerator({
+  generator,
+  rootAutorelease,
+  automation
+}) {
+  if (automation == null) {
+    return true;
+  }
+  return !shouldSkipGenerator({ generator, rootAutorelease });
+}
+
+// src/commands/generate/generateAPIWorkspaces.ts
+var GenerationMode = {
+  PullRequest: "pull-request"
+};
+async function generateAPIWorkspaces({
+  project,
+  cliContext,
+  version: version7,
+  groupName,
+  generatorName,
+  generatorIndex,
+  shouldLogS3Url,
+  keepDocker,
+  useLocalDocker,
+  preview,
+  mode,
+  force,
+  runner,
+  inspect: inspect6,
+  lfsOverride,
+  fernignorePath,
+  skipFernignore,
+  dynamicIrOnly,
+  outputDir,
+  noReplay,
+  retryRateLimited,
+  requireEnvVars,
+  automationMode,
+  autoMerge,
+  automation
+}) {
+  let token = void 0;
+  if (!useLocalDocker) {
+    const currentToken = await cliContext.runTask(async (context3) => {
+      return askToLogin(context3);
+    });
+    if (currentToken.type === "user") {
+      await cliContext.runTask(async (context3) => {
+        await createOrganizationIfDoesNotExist({
+          organization: project.config.organization,
+          token: currentToken,
+          context: context3
+        });
+      });
+    }
+    token = currentToken;
+  }
+  await confirmOutputDirectoriesForEligibleGenerators({
+    project,
+    groupName,
+    generatorName,
+    generatorIndex,
+    automation,
+    cliContext,
+    force
+  });
+  cliContext.instrumentPostHogEvent({
+    orgId: project.config.organization,
+    command: resolvePosthogCommandLabel(automation),
+    properties: {
+      workspaces: buildPosthogWorkspaces({ project, groupName, generatorName })
+    }
+  });
+  await Promise.all(
+    project.apiWorkspaces.map(async (workspace) => {
+      await cliContext.runTaskForWorkspace(workspace, async (context3) => {
+        const absolutePathToPreview = preview ? outputDir != null ? AbsoluteFilePath2.of(resolve6(cwd(), outputDir)) : join8(workspace.absoluteFilePath, RelativeFilePath2.of(PREVIEW_DIRECTORY)) : void 0;
+        if (absolutePathToPreview != null) {
+          context3.logger.info(`Writing preview to ${absolutePathToPreview}`);
+        }
+        await generateWorkspace({
+          organization: project.config.organization,
+          workspace,
+          projectConfig: project.config,
+          context: context3,
+          version: version7,
+          groupName,
+          generatorName,
+          generatorIndex,
+          shouldLogS3Url,
+          token,
+          useLocalDocker,
+          keepDocker,
+          absolutePathToPreview,
+          mode,
+          runner,
+          inspect: inspect6,
+          lfsOverride,
+          fernignorePath,
+          skipFernignore,
+          dynamicIrOnly,
+          noReplay,
+          retryRateLimited,
+          requireEnvVars,
+          automationMode,
+          autoMerge,
+          automation
+        });
+      });
+    })
+  );
+}
+async function confirmOutputDirectoriesForEligibleGenerators({
+  project,
+  groupName,
+  generatorName,
+  generatorIndex,
+  automation,
+  cliContext,
+  force
+}) {
+  for (const workspace of project.apiWorkspaces) {
+    const resolvedGroupNames = expandGroupFilter(groupName, workspace.generatorsConfiguration);
+    const rootAutorelease = workspace.generatorsConfiguration?.rawConfiguration.autorelease;
+    const groupsInScope = workspace.generatorsConfiguration?.groups.filter(
+      (group) => resolvedGroupNames == null || resolvedGroupNames.includes(group.groupName)
+    ) ?? [];
+    for (const group of groupsInScope) {
+      const filterResult = filterGenerators({
+        generators: group.generators,
+        generatorIndex,
+        generatorName,
+        groupName: group.groupName
+      });
+      if (!filterResult.ok) {
+        continue;
+      }
+      for (const generator of filterResult.generators) {
+        if (!shouldPreflightGenerator({ generator, rootAutorelease, automation })) {
+          continue;
+        }
+        const { shouldProceed } = await checkOutputDirectory(
+          generator.absolutePathToLocalOutput,
+          cliContext,
+          force
+        );
+        if (!shouldProceed) {
+          cliContext.failAndThrow("Generation cancelled", void 0, { code: CliError.Code.ConfigError });
+        }
+      }
+    }
+  }
+}
+function buildPosthogWorkspaces({
+  project,
+  groupName,
+  generatorName
+}) {
+  return project.apiWorkspaces.map((workspace) => {
+    const resolvedGroupNames = expandGroupFilter(groupName, workspace.generatorsConfiguration);
+    return {
+      name: workspace.workspaceName,
+      group: groupName,
+      generators: workspace.generatorsConfiguration?.groups.filter((group) => resolvedGroupNames == null || resolvedGroupNames.includes(group.groupName)).map(
+        (group) => group.generators.filter((generator) => generatorName == null || generator.name === generatorName).map((generator) => ({
+          name: generator.name,
+          version: generator.version,
+          outputMode: generator.outputMode.type,
+          config: generator.config
+        }))
+      )
+    };
+  });
+}
+function expandGroupFilter(groupName, generatorsConfiguration) {
+  if (groupName == null) {
+    return null;
+  }
+  if (generatorsConfiguration == null) {
+    return [groupName];
+  }
+  const aliasGroups = generatorsConfiguration.groupAliases[groupName];
+  if (aliasGroups != null) {
+    return aliasGroups;
+  }
+  return [groupName];
+}
+
+// src/commands/automations/generate/GeneratorRunResult.ts
+function countResults(results) {
+  let succeeded = 0;
+  let failed = 0;
+  let skipped = 0;
+  for (const r5 of results) {
+    switch (r5.status) {
+      case "success":
+        succeeded++;
+        break;
+      case "failed":
+        failed++;
+        break;
+      case "skipped_no_diff":
+        skipped++;
+        break;
+    }
+  }
+  return { succeeded, failed, skipped };
+}
+var GeneratorRunCollector = class {
+  #results = [];
+  recordSuccess(args) {
+    this.#results.push({
+      apiName: args.apiName,
+      groupName: args.groupName,
+      generatorName: args.generatorName,
+      status: "success",
+      version: args.version,
+      pullRequestUrl: null,
+      errorMessage: null,
+      durationMs: args.durationMs
+    });
+  }
+  recordFailure(args) {
+    this.#results.push({
+      apiName: args.apiName,
+      groupName: args.groupName,
+      generatorName: args.generatorName,
+      status: "failed",
+      version: null,
+      pullRequestUrl: null,
+      errorMessage: args.errorMessage,
+      durationMs: args.durationMs
+    });
+  }
+  results() {
+    return this.#results;
+  }
+  hasFailures() {
+    return this.#results.some((r5) => r5.status === "failed");
+  }
+  counts() {
+    return countResults(this.#results);
+  }
+};
+
+// src/commands/automations/generate/reportGenerateResults.ts
+var import_fs35 = require("fs");
+var import_promises137 = require("fs/promises");
+var JSON_SCHEMA_VERSION = 1;
+function renderStdoutSummary(results) {
+  return formatCounts(countResults(results));
+}
+function renderMarkdownSummary(results) {
+  const lines = [];
+  lines.push("## Fern Automations \xB7 Generate");
+  lines.push("");
+  lines.push("| API | Group | Generator | Status | Version | PR |");
+  lines.push("|-----|-------|-----------|--------|---------|----|");
+  for (const result of results) {
+    lines.push(
+      `| ${mdCell(result.apiName)} | ${mdCell(result.groupName)} | ${mdCell(result.generatorName)} | ${statusCell(result)} | ${mdCell(result.version)} | ${prCell(result.pullRequestUrl)} |`
+    );
+  }
+  lines.push("");
+  lines.push(`**Summary:** ${formatCounts(countResults(results))}`);
+  lines.push("");
+  return lines.join("\n");
+}
+function renderJsonSummary(results) {
+  return {
+    version: JSON_SCHEMA_VERSION,
+    generators: results.map((r5) => ({
+      api: r5.apiName ?? null,
+      group: r5.groupName,
+      generatorName: r5.generatorName,
+      status: r5.status,
+      pullRequestUrl: r5.pullRequestUrl,
+      version: r5.version,
+      error: r5.errorMessage,
+      durationMs: r5.durationMs
+    })),
+    summary: countResults(results)
+  };
+}
+function formatCounts(counts) {
+  return `${counts.succeeded} succeeded \xB7 ${counts.skipped} skipped \xB7 ${counts.failed} failed`;
+}
+async function writeResults({
+  results,
+  jsonOutputPath
+}) {
+  const stepSummaryPath = getGithubStepSummaryPath();
+  if (stepSummaryPath != null) {
+    try {
+      await (0, import_promises137.appendFile)(stepSummaryPath, renderMarkdownSummary(results), "utf8");
+    } catch {
+    }
+  }
+  if (jsonOutputPath != null) {
+    await (0, import_promises137.writeFile)(jsonOutputPath, JSON.stringify(renderJsonSummary(results), null, 2), "utf8");
+  }
+}
+function writeResultsSync({
+  results,
+  jsonOutputPath
+}) {
+  const stepSummaryPath = getGithubStepSummaryPath();
+  if (stepSummaryPath != null) {
+    try {
+      (0, import_fs35.appendFileSync)(stepSummaryPath, renderMarkdownSummary(results), "utf8");
+    } catch {
+    }
+  }
+  if (jsonOutputPath != null) {
+    try {
+      (0, import_fs35.writeFileSync)(jsonOutputPath, JSON.stringify(renderJsonSummary(results), null, 2), "utf8");
+    } catch {
+    }
+  }
+}
+function getGithubStepSummaryPath() {
+  const path99 = process.env.GITHUB_STEP_SUMMARY;
+  return path99 != null && path99.length > 0 ? path99 : void 0;
+}
+function mdCell(value2) {
+  if (value2 == null || value2.length === 0) {
+    return "\u2014";
+  }
+  return value2.replace(/\|/g, "\\|");
+}
+function statusCell(result) {
+  switch (result.status) {
+    case "success":
+      return "\u2705 success";
+    case "failed":
+      return "\u274C failed";
+    case "skipped_no_diff":
+      return "\u23ED\uFE0F skipped (no diff)";
+  }
+}
+function prCell(url3) {
+  if (url3 == null) {
+    return "\u2014";
+  }
+  const match3 = url3.match(/\/pull\/(\d+)/);
+  if (match3 != null) {
+    return `[#${match3[1]}](${url3})`;
+  }
+  return `[link](${url3})`;
+}
+
+// src/commands/automations/generate/executeAutomationsGenerate.ts
+async function executeAutomationsGenerate({
+  cliContext,
+  options: options2
+}) {
+  const { generatorName, generatorIndex } = parseGeneratorArg(options2.generator);
+  const collector = new GeneratorRunCollector();
+  const { jsonOutputPath } = options2;
+  let outputsFlushed = false;
+  let taskAborted = false;
+  const flushOnSignal = () => {
+    if (outputsFlushed) {
+      return;
+    }
+    outputsFlushed = true;
+    writeResultsSync({ results: collector.results(), jsonOutputPath });
+  };
+  process.once("SIGINT", flushOnSignal);
+  process.once("SIGTERM", flushOnSignal);
+  try {
+    await cliContext.runTask(async () => {
+      await generateAPIWorkspaces({
+        project: await loadProjectAndRegisterWorkspacesWithContext(cliContext, {
+          commandLineApiWorkspace: options2.api,
+          defaultToAllApiWorkspaces: true
+        }),
+        cliContext,
+        version: options2.version,
+        groupName: options2.group,
+        generatorName,
+        generatorIndex,
+        shouldLogS3Url: false,
+        keepDocker: false,
+        useLocalDocker: false,
+        preview: false,
+        mode: void 0,
+        force: true,
+        runner: void 0,
+        inspect: false,
+        lfsOverride: void 0,
+        fernignorePath: void 0,
+        skipFernignore: false,
+        dynamicIrOnly: false,
+        outputDir: void 0,
+        noReplay: false,
+        retryRateLimited: false,
+        requireEnvVars: false,
+        automationMode: true,
+        autoMerge: options2.autoMerge,
+        automation: { recorder: collector }
+      });
+    });
+  } catch (error50) {
+    if (!(error50 instanceof TaskAbortSignal)) {
+      throw error50;
+    }
+    taskAborted = true;
+  } finally {
+    process.off("SIGINT", flushOnSignal);
+    process.off("SIGTERM", flushOnSignal);
+    if (!outputsFlushed) {
+      outputsFlushed = true;
+      await reportFinalOutputs({ collector, jsonOutputPath, taskAborted });
+    }
+    if (collector.hasFailures()) {
+      process.exitCode = 1;
+    }
+  }
+}
+async function reportFinalOutputs({
+  collector,
+  jsonOutputPath,
+  taskAborted
+}) {
+  const results = collector.results();
+  if (results.length === 0) {
+    if (taskAborted) {
+      return;
+    }
+    process.stdout.write(
+      "No eligible generators ran in the selected APIs and groups \u2014 every candidate either opts out via automations.generate / autorelease, uses local-file-system output, or did not match an explicit --group / --api filter.\n"
+    );
+    return;
+  }
+  await writeResults({ results, jsonOutputPath });
+  process.stdout.write(`${renderStdoutSummary(results)}
+`);
+}
+
 // src/commands/sdk-preview/overrideOutputForPreview.ts
 var PREVIEW_REGISTRY_URL = process.env.FERN_PREVIEW_REGISTRY_URL ?? "https://npm.buildwithfern.com";
 var SUPPORTED_TYPESCRIPT_GENERATORS = /* @__PURE__ */ new Set([
@@ -920401,7 +921470,7 @@ async function previewDocsWorkspace({
 
 // src/commands/docs-diff/docsDiff.ts
 init_lib6();
-var import_promises134 = require("fs/promises");
+var import_promises138 = require("fs/promises");
 var import_pngjs = __toESM(require_png2(), 1);
 async function getSlugForFiles({
   previewUrl,
@@ -920624,8 +921693,8 @@ async function generateComparisons({
   afterPath,
   comparisonBasePath
 }) {
-  const beforePng = import_pngjs.PNG.sync.read(await (0, import_promises134.readFile)(beforePath));
-  const afterPng = import_pngjs.PNG.sync.read(await (0, import_promises134.readFile)(afterPath));
+  const beforePng = import_pngjs.PNG.sync.read(await (0, import_promises138.readFile)(beforePath));
+  const afterPng = import_pngjs.PNG.sync.read(await (0, import_promises138.readFile)(afterPath));
   const beforeOriginalHeight = beforePng.height;
   const afterOriginalHeight = afterPng.height;
   const width = Math.max(beforePng.width, afterPng.width);
@@ -920663,7 +921732,7 @@ async function generateComparisons({
     const sideBySide = createSideBySideComparison(croppedBefore, croppedAfter, 20, true);
     const outPath = `${base4}-region-${i9 + 1}.png`;
     const pngBuffer = import_pngjs.PNG.sync.write(sideBySide);
-    await (0, import_promises134.writeFile)(outPath, new Uint8Array(pngBuffer));
+    await (0, import_promises138.writeFile)(outPath, new Uint8Array(pngBuffer));
     results.push({ changePercent, boundingBox, comparisonPath: outPath });
   }
   return results;
@@ -920742,7 +921811,7 @@ async function docsDiff({
     outputDir.startsWith("/") ? outputDir : join8(cwd(), RelativeFilePath2.of(outputDir))
   );
   if (!await doesPathExist(outputPath)) {
-    await (0, import_promises134.mkdir)(outputPath, { recursive: true });
+    await (0, import_promises138.mkdir)(outputPath, { recursive: true });
   }
   const results = [];
   await cliContext.runTask(async (context3) => {
@@ -924054,8 +925123,8 @@ function renderNamespacesIndexPage(nsPath, childEntries, nsTitle) {
 }
 
 // ../library-docs-generator/lib/src/writers/MdxFileWriter.js
-var import_fs35 = require("fs");
-var import_path85 = require("path");
+var import_fs36 = require("fs");
+var import_path86 = require("path");
 var MdxFileWriter = class {
   outputDir;
   writtenFiles = [];
@@ -924071,9 +925140,9 @@ var MdxFileWriter = class {
    * @returns Absolute path of the written file
    */
   writePage(pageKey, content5) {
-    const filePath = (0, import_path85.join)(this.outputDir, pageKey);
-    (0, import_fs35.mkdirSync)((0, import_path85.dirname)(filePath), { recursive: true });
-    (0, import_fs35.writeFileSync)(filePath, content5);
+    const filePath = (0, import_path86.join)(this.outputDir, pageKey);
+    (0, import_fs36.mkdirSync)((0, import_path86.dirname)(filePath), { recursive: true });
+    (0, import_fs36.writeFileSync)(filePath, content5);
     this.writtenFiles.push(filePath);
     return filePath;
   }
@@ -925080,8 +926149,8 @@ function renderModulePage(module4, ctx, parentPath = "") {
 }
 
 // ../library-docs-generator/lib/src/writers/NavigationBuilder.js
-var import_fs36 = require("fs");
-var import_path86 = require("path");
+var import_fs37 = require("fs");
+var import_path87 = require("path");
 function buildNavigation(rootModule, baseSlug) {
   return generateModuleNav(rootModule, "", baseSlug);
 }
@@ -925115,9 +926184,9 @@ var NAVIGATION_FILENAME = "_navigation.yml";
 function writeNavigation(outputDir, navigation2) {
   const header = "# AUTO-GENERATED by `fern docs md generate` \u2014 DO NOT EDIT\n";
   const yaml3 = jsYaml.dump(navigation2, { lineWidth: 120, noRefs: true });
-  const filePath = (0, import_path86.join)(outputDir, NAVIGATION_FILENAME);
-  (0, import_fs36.mkdirSync)((0, import_path86.dirname)(filePath), { recursive: true });
-  (0, import_fs36.writeFileSync)(filePath, header + yaml3);
+  const filePath = (0, import_path87.join)(outputDir, NAVIGATION_FILENAME);
+  (0, import_fs37.mkdirSync)((0, import_path87.dirname)(filePath), { recursive: true });
+  (0, import_fs37.writeFileSync)(filePath, header + yaml3);
   return filePath;
 }
 
@@ -925155,7 +926224,7 @@ function renderModuleTree(module4, ctx, writer2, parentPath) {
 }
 
 // src/commands/docs-md-generate/generateLibraryDocs.ts
-var import_promises135 = require("fs/promises");
+var import_promises139 = require("fs/promises");
 function createLibraryDocsClient2({ token }) {
   const defaultOrigin = "https://registry-dev2.buildwithfern.com";
   const baseUrl = process.env.FERN_FDR_ORIGIN ?? process.env.OVERRIDE_FDR_ORIGIN ?? defaultOrigin;
@@ -925281,7 +926350,7 @@ async function generateSingleLibrary({
     if (config5.lang === "cpp" && config5.config?.doxyfile != null) {
       const doxyfilePath = resolve6(docsWorkspace.absoluteFilePath, config5.config.doxyfile);
       try {
-        doxyfileContent = await (0, import_promises135.readFile)(doxyfilePath, "utf-8");
+        doxyfileContent = await (0, import_promises139.readFile)(doxyfilePath, "utf-8");
       } catch {
         return interactiveTaskContext.failAndThrow(
           `Library '${name2}': Could not read Doxyfile at '${config5.config.doxyfile}' (resolved to ${doxyfilePath})`,
@@ -925627,7 +926696,7 @@ Found ${previewDeployments.length} preview deployment(s):
 }
 
 // src/commands/downgrade/downgrade.ts
-var import_promises136 = require("fs/promises");
+var import_promises140 = require("fs/promises");
 
 // ../../../node_modules/.pnpm/immer@10.2.0/node_modules/immer/dist/immer.mjs
 var NOTHING = /* @__PURE__ */ Symbol.for("immer-nothing");
@@ -926378,13 +927447,13 @@ async function downgrade({
   const newProjectConfig = produce(projectConfig.rawConfig, (draft) => {
     draft.version = targetVersion;
   });
-  await (0, import_promises136.writeFile)(projectConfig._absolutePath, ensureFinalNewline(JSON.stringify(newProjectConfig, void 0, 2)));
+  await (0, import_promises140.writeFile)(projectConfig._absolutePath, ensureFinalNewline(JSON.stringify(newProjectConfig, void 0, 2)));
   cliContext.logger.info(`Updated ${PROJECT_CONFIG_FILENAME} to version ${targetVersion}`);
 }
 
 // src/commands/export/generateOpenAPIForWorkspaces.ts
 init_lib6();
-var import_promises137 = require("fs/promises");
+var import_promises141 = require("fs/promises");
 
 // src/commands/export/converters/servicesConverter.ts
 init_lib4();
@@ -927767,8 +928836,8 @@ async function generateOpenAPIForWorkspaces({
           ir: ir10,
           mode: "openapi"
         });
-        await (0, import_promises137.mkdir)(dirname6(outputPath), { recursive: true });
-        await (0, import_promises137.writeFile)(
+        await (0, import_promises141.mkdir)(dirname6(outputPath), { recursive: true });
+        await (0, import_promises141.writeFile)(
           outputPath,
           outputPath.endsWith(".json") ? JSON.stringify(openapi, void 0, indent4) : jsYaml.dump(openapi, { indent: indent4 })
         );
@@ -927799,517 +928868,6 @@ async function formatWorkspaces({
   );
 }
 
-// src/commands/generate/filterGenerators.ts
-function parseGeneratorArg(generatorArg) {
-  if (generatorArg == null) {
-    return { generatorName: void 0, generatorIndex: void 0 };
-  }
-  const parsed = generatorArg.length > 0 ? Number(generatorArg) : Number.NaN;
-  if (!Number.isNaN(parsed) && Number.isInteger(parsed) && parsed >= 0) {
-    return { generatorName: void 0, generatorIndex: parsed };
-  }
-  return { generatorName: generatorArg, generatorIndex: void 0 };
-}
-function filterGenerators({
-  generators,
-  generatorIndex,
-  generatorName,
-  groupName
-}) {
-  if (generatorIndex != null) {
-    const generator = generators[generatorIndex];
-    if (generator == null) {
-      return {
-        ok: false,
-        error: `Generator index ${generatorIndex} is out of bounds in group '${groupName}' (${generators.length} generators available)`
-      };
-    }
-    return { ok: true, generators: [generator] };
-  }
-  if (generatorName != null) {
-    const filtered = generators.filter((gen) => gen.name === generatorName);
-    if (filtered.length === 0) {
-      const available = generators.map((gen) => gen.name);
-      return {
-        ok: false,
-        error: `Generator '${generatorName}' not found in group '${groupName}'. Available generators: ${available.join(", ")}`
-      };
-    }
-    return { ok: true, generators: filtered };
-  }
-  return { ok: true, generators };
-}
-
-// src/commands/generate/generateAPIWorkspaces.ts
-init_lib6();
-
-// src/constants.ts
-var API_CLI_OPTION = "api";
-var GROUP_CLI_OPTION = "group";
-var PREVIEW_DIRECTORY = ".preview";
-var APPROVED_DIRECTORIES_FILENAME = "approved-output-directories";
-var LOCAL_STORAGE_FOLDER6 = ".fern-dev";
-
-// src/commands/generate/checkOutputDirectory.ts
-init_lib6();
-var import_promises140 = require("fs/promises");
-
-// src/persistence/output-directories/getOutputDirectories.ts
-init_lib6();
-var import_promises138 = require("fs/promises");
-
-// src/persistence/output-directories/getPathToOutputDirectoriesFile.ts
-init_lib6();
-var import_os16 = require("os");
-function getPathToOutputDirectoriesFile() {
-  return join8(
-    AbsoluteFilePath2.of((0, import_os16.homedir)()),
-    RelativeFilePath2.of(LOCAL_STORAGE_FOLDER6),
-    RelativeFilePath2.of(APPROVED_DIRECTORIES_FILENAME)
-  );
-}
-
-// src/persistence/output-directories/getOutputDirectories.ts
-async function getOutputDirectories() {
-  const pathToOutputDirectoriesFile = getPathToOutputDirectoriesFile();
-  const doesOutputDirectoriesFileExist = await doesPathExist(pathToOutputDirectoriesFile);
-  if (!doesOutputDirectoriesFileExist) {
-    return [];
-  }
-  const outputDirectoriesFileContents = await (0, import_promises138.readFile)(pathToOutputDirectoriesFile, { encoding: "utf-8" });
-  const outputDirectories = JSON.parse(outputDirectoriesFileContents);
-  return outputDirectories;
-}
-
-// src/persistence/output-directories/storeOutputDirectories.ts
-var import_promises139 = require("fs/promises");
-var import_path87 = __toESM(require("path"), 1);
-async function storeOutputDirectories(outputDirectories) {
-  await (0, import_promises139.mkdir)(import_path87.default.dirname(getPathToOutputDirectoriesFile()), { recursive: true });
-  await (0, import_promises139.writeFile)(getPathToOutputDirectoriesFile(), JSON.stringify(outputDirectories, null, 2));
-}
-
-// src/commands/generate/checkOutputDirectory.ts
-async function checkOutputDirectory(outputPath, cliContext, force) {
-  if (!outputPath || isCI() || force) {
-    return {
-      shouldProceed: true
-    };
-  }
-  const savedDirectories = await getOutputDirectories();
-  if (savedDirectories?.includes(outputPath)) {
-    return {
-      shouldProceed: true
-    };
-  }
-  const doesExist = await doesPathExist(outputPath);
-  if (!doesExist) {
-    return {
-      shouldProceed: true
-    };
-  }
-  const files = await (0, import_promises140.readdir)(outputPath);
-  if (files.length === 0) {
-    return {
-      shouldProceed: true
-    };
-  }
-  const shouldOverwrite = await cliContext.confirmPrompt(
-    `Directory ${outputPath} contains existing files that may be overwritten. Continue?`,
-    false
-  );
-  if (!shouldOverwrite) {
-    return {
-      shouldProceed: false
-    };
-  }
-  await storeOutputDirectories([...savedDirectories ?? [], outputPath]);
-  return {
-    shouldProceed: true
-  };
-}
-
-// src/commands/generate/generateAPIWorkspace.ts
-init_lib6();
-async function generateWorkspace({
-  organization,
-  workspace,
-  projectConfig,
-  context: context3,
-  groupName,
-  generatorName,
-  generatorIndex,
-  version: version7,
-  shouldLogS3Url,
-  token,
-  useLocalDocker,
-  keepDocker,
-  absolutePathToPreview,
-  mode,
-  runner,
-  inspect: inspect6,
-  lfsOverride,
-  fernignorePath,
-  skipFernignore,
-  dynamicIrOnly,
-  noReplay,
-  retryRateLimited,
-  requireEnvVars,
-  automationMode,
-  autoMerge
-}) {
-  if (workspace.generatorsConfiguration == null) {
-    context3.logger.warn("This workspaces has no generators.yml");
-    return;
-  }
-  if (workspace.generatorsConfiguration.groups.length === 0) {
-    context3.logger.warn(`This workspace has no groups specified in ${GENERATORS_CONFIGURATION_FILENAME}`);
-    return;
-  }
-  const groupNameOrDefault = groupName ?? workspace.generatorsConfiguration.defaultGroup;
-  if (groupName == null && groupNameOrDefault != null) {
-    context3.logger.info(
-      source_default.dim(`Using default group '${groupNameOrDefault}' from ${GENERATORS_CONFIGURATION_FILENAME}`)
-    );
-  }
-  if (groupNameOrDefault == null) {
-    const groupNames = workspace.generatorsConfiguration.groups.map((g8) => g8.groupName);
-    const longestGroupName = Math.max(...groupNames.map((name2) => name2.length));
-    const currentArgs = process.argv.slice(2).join(" ");
-    const message = `No group specified. Use the --${GROUP_CLI_OPTION} option, or set "${DEFAULT_GROUP_GENERATORS_CONFIG_KEY}" in ${GENERATORS_CONFIGURATION_FILENAME}:
-` + groupNames.map((name2) => {
-      const suggestedCommand = `fern ${currentArgs} --${GROUP_CLI_OPTION} ${name2}`;
-      return ` \u203A ${source_default.bold(name2.padEnd(longestGroupName))}  ${source_default.dim(suggestedCommand)}`;
-    }).join("\n");
-    return context3.failAndThrow(message, void 0, { code: CliError.Code.NetworkError });
-  }
-  const resolvedGroupNames = resolveGroupAlias(
-    groupNameOrDefault,
-    workspace.generatorsConfiguration.groupAliases,
-    workspace.generatorsConfiguration.groups.map((g8) => g8.groupName),
-    context3
-  );
-  const { ai: ai10, replay } = workspace.generatorsConfiguration;
-  if (!useLocalDocker && !token) {
-    return context3.failAndThrow("Please run fern login", void 0, { code: CliError.Code.AuthError });
-  }
-  await Promise.all(
-    resolvedGroupNames.map(async (resolvedGroupName) => {
-      let group = workspace.generatorsConfiguration?.groups.find(
-        (otherGroup) => otherGroup.groupName === resolvedGroupName
-      );
-      if (group == null) {
-        return context3.failAndThrow(`Group '${resolvedGroupName}' does not exist.`, void 0, {
-          code: CliError.Code.ConfigError
-        });
-      }
-      const filterResult = filterGenerators({
-        generators: group.generators,
-        generatorIndex,
-        generatorName,
-        groupName: resolvedGroupName
-      });
-      if (!filterResult.ok) {
-        return context3.failAndThrow(filterResult.error, void 0, { code: CliError.Code.ConfigError });
-      }
-      group = { ...group, generators: filterResult.generators };
-      if (lfsOverride != null) {
-        group = applyLfsOverride(group, lfsOverride, context3);
-      }
-      if (resolvedGroupNames.length > 1) {
-        context3.logger.info(`Running generation for group '${resolvedGroupName}'...`);
-      }
-      if (useLocalDocker) {
-        await runLocalGenerationForWorkspace({
-          token,
-          projectConfig,
-          workspace,
-          generatorGroup: group,
-          version: version7,
-          keepDocker,
-          context: context3,
-          runner,
-          absolutePathToPreview,
-          inspect: inspect6,
-          ai: ai10,
-          replay,
-          noReplay,
-          validateWorkspace: true,
-          requireEnvVars,
-          skipFernignore,
-          automationMode,
-          autoMerge
-        });
-      } else if (token != null) {
-        const customImageGenerators = group.generators.filter((g8) => g8.containerImage != null);
-        if (customImageGenerators.length > 0) {
-          const names2 = customImageGenerators.map((g8) => g8.name).join(", ");
-          return context3.failAndThrow(
-            `Custom image configurations are only supported with local generation (--local). The following generators use custom images: ${names2}`
-          );
-        }
-        await runRemoteGenerationForAPIWorkspace({
-          projectConfig,
-          organization,
-          workspace,
-          context: context3,
-          generatorGroup: group,
-          version: version7,
-          shouldLogS3Url,
-          token,
-          whitelabel: workspace.generatorsConfiguration?.whitelabel,
-          absolutePathToPreview,
-          mode,
-          fernignorePath,
-          skipFernignore,
-          dynamicIrOnly,
-          validateWorkspace: true,
-          retryRateLimited,
-          requireEnvVars,
-          automationMode,
-          autoMerge
-        });
-      }
-    })
-  );
-}
-function resolveGroupAlias(groupNameOrAlias, groupAliases, availableGroups, context3) {
-  const aliasGroups = groupAliases[groupNameOrAlias];
-  if (aliasGroups != null) {
-    for (const groupName of aliasGroups) {
-      if (!availableGroups.includes(groupName)) {
-        context3.failAndThrow(
-          `Group alias '${groupNameOrAlias}' references non-existent group '${groupName}'. Available groups: ${availableGroups.join(", ")}`,
-          void 0,
-          { code: CliError.Code.NetworkError }
-        );
-      }
-    }
-    return aliasGroups;
-  }
-  if (availableGroups.includes(groupNameOrAlias)) {
-    return [groupNameOrAlias];
-  }
-  const availableAliases = Object.keys(groupAliases);
-  const suggestions = [...availableGroups, ...availableAliases];
-  context3.failAndThrow(
-    `'${groupNameOrAlias}' is not a valid group or alias. Available groups: ${availableGroups.join(", ")}` + (availableAliases.length > 0 ? `. Available aliases: ${availableAliases.join(", ")}` : ""),
-    void 0,
-    { code: CliError.Code.NetworkError }
-  );
-  return [];
-}
-function applyLfsOverride(group, lfsOverridePath, context3) {
-  const baseAbsolutePath = AbsoluteFilePath2.of(resolve6(cwd(), lfsOverridePath));
-  const languageCount = {};
-  const modifiedGenerators = [];
-  for (const generator of group.generators) {
-    const language = generator.language ?? getLanguageFromGeneratorName3(generator.name);
-    let outputPath;
-    if (group.generators.length === 1) {
-      outputPath = baseAbsolutePath;
-    } else {
-      const languageDir = language || "unknown";
-      if (languageCount[languageDir] == null) {
-        languageCount[languageDir] = 0;
-      }
-      languageCount[languageDir]++;
-      const dirName = languageCount[languageDir] === 1 ? languageDir : `${languageDir}-${languageCount[languageDir]}`;
-      outputPath = join8(baseAbsolutePath, RelativeFilePath2.of(dirName));
-    }
-    const modifiedGenerator = {
-      ...generator,
-      outputMode: api_exports4.remoteGen.OutputMode.downloadFiles({}),
-      absolutePathToLocalOutput: outputPath
-    };
-    modifiedGenerators.push(modifiedGenerator);
-    context3.logger.info(
-      `Overriding output for generator '${generator.name}' to local-file-system at: ${outputPath}`
-    );
-  }
-  return {
-    ...group,
-    generators: modifiedGenerators
-  };
-}
-function getLanguageFromGeneratorName3(generatorName) {
-  if (generatorName.includes("typescript") || generatorName.includes("ts")) {
-    return "typescript";
-  }
-  if (generatorName.includes("python") || generatorName.includes("py")) {
-    return "python";
-  }
-  if (generatorName.includes("java")) {
-    return "java";
-  }
-  if (generatorName.includes("go")) {
-    return "go";
-  }
-  if (generatorName.includes("ruby")) {
-    return "ruby";
-  }
-  if (generatorName.includes("csharp") || generatorName.includes("c#")) {
-    return "csharp";
-  }
-  if (generatorName.includes("swift")) {
-    return "swift";
-  }
-  if (generatorName.includes("php")) {
-    return "php";
-  }
-  if (generatorName.includes("rust")) {
-    return "rust";
-  }
-  return generatorName.replace(/[^a-zA-Z0-9]/g, "-").toLowerCase();
-}
-
-// src/commands/generate/generateAPIWorkspaces.ts
-var GenerationMode = {
-  PullRequest: "pull-request"
-};
-async function generateAPIWorkspaces({
-  project,
-  cliContext,
-  version: version7,
-  groupName,
-  generatorName,
-  generatorIndex,
-  shouldLogS3Url,
-  keepDocker,
-  useLocalDocker,
-  preview,
-  mode,
-  force,
-  runner,
-  inspect: inspect6,
-  lfsOverride,
-  fernignorePath,
-  skipFernignore,
-  dynamicIrOnly,
-  outputDir,
-  noReplay,
-  retryRateLimited,
-  requireEnvVars,
-  automationMode,
-  autoMerge
-}) {
-  let token = void 0;
-  if (!useLocalDocker) {
-    const currentToken = await cliContext.runTask(async (context3) => {
-      return askToLogin(context3);
-    });
-    if (currentToken.type === "user") {
-      await cliContext.runTask(async (context3) => {
-        await createOrganizationIfDoesNotExist({
-          organization: project.config.organization,
-          token: currentToken,
-          context: context3
-        });
-      });
-    }
-    token = currentToken;
-  }
-  for (const workspace of project.apiWorkspaces) {
-    const resolvedGroupNames = resolveGroupNamesForWorkspace(groupName, workspace.generatorsConfiguration);
-    for (const group of workspace.generatorsConfiguration?.groups.filter(
-      (group2) => resolvedGroupNames == null || resolvedGroupNames.includes(group2.groupName)
-    ) ?? []) {
-      const filterResult = filterGenerators({
-        generators: group.generators,
-        generatorIndex,
-        generatorName,
-        groupName: group.groupName
-      });
-      if (!filterResult.ok) {
-        continue;
-      }
-      for (const generator of filterResult.generators) {
-        const { shouldProceed } = await checkOutputDirectory(
-          generator.absolutePathToLocalOutput,
-          cliContext,
-          force
-        );
-        if (!shouldProceed) {
-          cliContext.failAndThrow("Generation cancelled", void 0, { code: CliError.Code.ConfigError });
-        }
-      }
-    }
-  }
-  cliContext.instrumentPostHogEvent({
-    orgId: project.config.organization,
-    command: "fern generate",
-    properties: {
-      workspaces: project.apiWorkspaces.map((workspace) => {
-        const resolvedGroupNames = resolveGroupNamesForWorkspace(groupName, workspace.generatorsConfiguration);
-        return {
-          name: workspace.workspaceName,
-          group: groupName,
-          generators: workspace.generatorsConfiguration?.groups.filter((group) => resolvedGroupNames == null || resolvedGroupNames.includes(group.groupName)).map((group) => {
-            return group.generators.filter((generator) => generatorName == null || generator.name === generatorName).map((generator) => {
-              return {
-                name: generator.name,
-                version: generator.version,
-                outputMode: generator.outputMode.type,
-                config: generator.config
-              };
-            });
-          })
-        };
-      })
-    }
-  });
-  await Promise.all(
-    project.apiWorkspaces.map(async (workspace) => {
-      await cliContext.runTaskForWorkspace(workspace, async (context3) => {
-        const absolutePathToPreview = preview ? outputDir != null ? AbsoluteFilePath2.of(resolve6(cwd(), outputDir)) : join8(workspace.absoluteFilePath, RelativeFilePath2.of(PREVIEW_DIRECTORY)) : void 0;
-        if (absolutePathToPreview != null) {
-          context3.logger.info(`Writing preview to ${absolutePathToPreview}`);
-        }
-        await generateWorkspace({
-          organization: project.config.organization,
-          workspace,
-          projectConfig: project.config,
-          context: context3,
-          version: version7,
-          groupName,
-          generatorName,
-          generatorIndex,
-          shouldLogS3Url,
-          token,
-          useLocalDocker,
-          keepDocker,
-          absolutePathToPreview,
-          mode,
-          runner,
-          inspect: inspect6,
-          lfsOverride,
-          fernignorePath,
-          skipFernignore,
-          dynamicIrOnly,
-          noReplay,
-          retryRateLimited,
-          requireEnvVars,
-          automationMode,
-          autoMerge
-        });
-      });
-    })
-  );
-}
-function resolveGroupNamesForWorkspace(groupName, generatorsConfiguration) {
-  if (groupName == null) {
-    return null;
-  }
-  if (generatorsConfiguration == null) {
-    return [groupName];
-  }
-  const aliasGroups = generatorsConfiguration.groupAliases[groupName];
-  if (aliasGroups != null) {
-    return aliasGroups;
-  }
-  return [groupName];
-}
-
 // src/commands/generate/generateDocsWorkspace.ts
 init_js();
 
@@ -928830,7 +929388,7 @@ async function generateOpenAPIIrForWorkspaces({
 
 // src/commands/generate-overrides/compareOpenAPISpecs.ts
 init_lib6();
-var import_promises141 = require("fs/promises");
+var import_promises142 = require("fs/promises");
 async function compareOpenAPISpecs({
   originalPath,
   modifiedPath,
@@ -928871,12 +929429,12 @@ async function compareOpenAPISpecs({
       }
       outputPath = join8(dirname6(originalPath), RelativeFilePath2.of(overridesFilename));
     }
-    await (0, import_promises141.writeFile)(outputPath, jsYaml.dump(overrides, { lineWidth: -1, noRefs: true }));
+    await (0, import_promises142.writeFile)(outputPath, jsYaml.dump(overrides, { lineWidth: -1, noRefs: true }));
     context3.logger.info(`Overrides written to ${outputPath}`);
   });
 }
 async function loadSpec2(filepath, context3) {
-  const contents = await (0, import_promises141.readFile)(filepath, "utf8");
+  const contents = await (0, import_promises142.readFile)(filepath, "utf8");
   try {
     return JSON.parse(contents);
   } catch {
@@ -928980,7 +929538,7 @@ function deepEqual(a4, b7) {
 
 // src/commands/generate-overrides/writeOverridesForWorkspaces.ts
 init_lib6();
-var import_promises142 = require("fs/promises");
+var import_promises143 = require("fs/promises");
 async function writeOverridesForWorkspaces({
   project,
   includeModels,
@@ -929005,7 +929563,7 @@ async function writeOverridesForWorkspaces({
 async function readExistingOverrides(overridesFilepath, context3) {
   let parsedOverrides = null;
   try {
-    const contents = (await (0, import_promises142.readFile)(overridesFilepath, "utf8")).toString();
+    const contents = (await (0, import_promises143.readFile)(overridesFilepath, "utf8")).toString();
     try {
       parsedOverrides = JSON.parse(contents);
     } catch (err) {
@@ -929070,7 +929628,7 @@ async function writeDefinitionForOpenAPIWorkspace({
       for (const overridesPath of overridesPaths) {
         const existingOverrides = await readExistingOverrides(overridesPath, context3);
         const content5 = generateOverridesContent({ ir: ir10, existingOverrides, includeModels, context: context3 });
-        await (0, import_promises142.writeFile)(overridesPath, jsYaml.dump(content5));
+        await (0, import_promises143.writeFile)(overridesPath, jsYaml.dump(content5));
       }
     } else {
       const content5 = generateOverridesContent({ ir: ir10, existingOverrides: {}, includeModels, context: context3 });
@@ -929084,7 +929642,7 @@ async function writeDefinitionForOpenAPIWorkspace({
           overridesFilename = `${nameWithoutExt}-overrides${extension4}`;
         }
       }
-      await (0, import_promises142.writeFile)(
+      await (0, import_promises143.writeFile)(
         join8(dirname6(spec.absoluteFilepath), RelativeFilePath2.of(overridesFilename)),
         jsYaml.dump(content5)
       );
@@ -929500,7 +930058,7 @@ function convertIRtoJsonSchema(args) {
 }
 
 // src/commands/jsonschema/generateJsonschemaForWorkspace.ts
-var import_promises143 = require("fs/promises");
+var import_promises144 = require("fs/promises");
 async function generateJsonschemaForWorkspaces({
   typeLocator,
   project,
@@ -929548,9 +930106,9 @@ async function generateJsonschemaForWorkspaces({
           context: context3
         });
         if (!await doesPathExist(dirname6(jsonschemaFilepath))) {
-          await (0, import_promises143.mkdir)(dirname6(jsonschemaFilepath), { recursive: true });
+          await (0, import_promises144.mkdir)(dirname6(jsonschemaFilepath), { recursive: true });
         }
-        await (0, import_promises143.writeFile)(jsonschemaFilepath, JSON.stringify(jsonSchema, null, 2));
+        await (0, import_promises144.writeFile)(jsonschemaFilepath, JSON.stringify(jsonSchema, null, 2));
         context3.logger.info(source_default.green(`Wrote JSON Schema to ${jsonschemaFilepath}`));
       });
     })
@@ -929559,7 +930117,7 @@ async function generateJsonschemaForWorkspaces({
 
 // src/commands/merge/mergeOpenAPIWithOverrides.ts
 init_lib6();
-var import_promises144 = require("fs/promises");
+var import_promises145 = require("fs/promises");
 var HTTP_METHODS2 = /* @__PURE__ */ new Set(["get", "put", "post", "delete", "options", "head", "patch", "trace"]);
 async function mergeOpenAPIWithOverrides({
   openapiPath,
@@ -929584,12 +930142,12 @@ async function mergeOpenAPIWithOverrides({
     const merged = mergeExamplesIntoSpec(openapi, overrides, context3);
     const isJson = outputPath.endsWith(".json");
     const output2 = isJson ? JSON.stringify(merged, null, 2) : jsYaml.dump(merged, { lineWidth: -1, noRefs: true });
-    await (0, import_promises144.writeFile)(outputPath, output2);
+    await (0, import_promises145.writeFile)(outputPath, output2);
     context3.logger.info(`Merged output written to ${outputPath}`);
   });
 }
 async function loadYamlOrJson(filepath, context3) {
-  const contents = await (0, import_promises144.readFile)(filepath, "utf8");
+  const contents = await (0, import_promises145.readFile)(filepath, "utf8");
   try {
     return JSON.parse(contents);
   } catch {
@@ -930223,7 +930781,7 @@ async function mockServer({
 }
 
 // src/commands/register/registerWorkspacesV1.ts
-var import_promises145 = require("fs/promises");
+var import_promises146 = require("fs/promises");
 var import_path93 = __toESM(require("path"), 1);
 var import_tmp_promise16 = __toESM(require_tmp_promise(), 1);
 async function registerWorkspacesV1({
@@ -930276,7 +930834,7 @@ async function registerWorkspacesV1({
         context3.logger.debug(`Compressing definition at ${tmpDir.path}`);
         await Zn8({ file: tarPath, cwd: resolvedWorkspace.absoluteFilePath }, ["."]);
         context3.logger.info("Uploading definition...");
-        await axios_default.put(registerApiResponse.body.definitionS3UploadUrl, await (0, import_promises145.readFile)(tarPath));
+        await axios_default.put(registerApiResponse.body.definitionS3UploadUrl, await (0, import_promises146.readFile)(tarPath));
         context3.logger.info(
           `Registered @${project.config.organization}/${resolvedWorkspace.definition.rootApiFile.contents.name}:${registerApiResponse.body.version}`
         );
@@ -930518,7 +931076,7 @@ async function generateDiff({
 
 // src/commands/sdk-preview/sdkPreview.ts
 init_lib6();
-var import_promises146 = __toESM(require("fs/promises"), 1);
+var import_promises147 = __toESM(require("fs/promises"), 1);
 
 // src/commands/sdk-preview/computePreviewVersion.ts
 var BASE_VERSION = "0.0.1";
@@ -930638,7 +931196,7 @@ async function sdkPreview({
     const firstPath = pathOutputs[0];
     const absolutePathToOutput = firstPath != null ? AbsoluteFilePath2.of(resolve6(cwd(), firstPath)) : void 0;
     if (absolutePathToOutput != null) {
-      await import_promises146.default.mkdir(absolutePathToOutput, { recursive: true });
+      await import_promises147.default.mkdir(absolutePathToOutput, { recursive: true });
     }
     for (const workspace of project.apiWorkspaces) {
       if (workspace.generatorsConfiguration == null) {
@@ -930822,7 +931380,7 @@ async function sdkPreview({
 }
 
 // src/commands/self-update/selfUpdate.ts
-var import_promises147 = require("fs/promises");
+var import_promises148 = require("fs/promises");
 var import_path94 = require("path");
 async function getPackageManagerBinDir(logger4, pm) {
   let command3;
@@ -930868,7 +931426,7 @@ async function detectInstallationMethod(logger4) {
   logger4.debug(`Found fern at: ${fernPath}`);
   let resolvedPath;
   try {
-    resolvedPath = await (0, import_promises147.realpath)(fernPath);
+    resolvedPath = await (0, import_promises148.realpath)(fernPath);
     logger4.debug(`Resolved to: ${resolvedPath}`);
   } catch (error50) {
     logger4.debug(`Failed to resolve symlink: ${error50}`);
@@ -931171,21 +931729,21 @@ async function generateToken({
 // src/commands/upgrade/updateApiSpec.ts
 init_lib6();
 var fs26 = __toESM(require("fs"), 1);
-var import_promises148 = require("fs/promises");
+var import_promises149 = require("fs/promises");
 init_graphql();
 var import_stream16 = require("stream");
-var import_promises149 = require("stream/promises");
+var import_promises150 = require("stream/promises");
 async function fetchAndWriteFile(url3, path99, logger4, indent4) {
   const resp = await fetch(url3);
   if (resp.ok && resp.body) {
     logger4.debug("Origin successfully fetched, writing to file");
     const fileStream = fs26.createWriteStream(path99);
-    await (0, import_promises149.finished)(import_stream16.Readable.fromWeb(resp.body).pipe(fileStream));
-    const fileContents = await (0, import_promises148.readFile)(path99, "utf8");
+    await (0, import_promises150.finished)(import_stream16.Readable.fromWeb(resp.body).pipe(fileStream));
+    const fileContents = await (0, import_promises149.readFile)(path99, "utf8");
     try {
-      await (0, import_promises148.writeFile)(path99, JSON.stringify(JSON.parse(fileContents), void 0, indent4), "utf8");
+      await (0, import_promises149.writeFile)(path99, JSON.stringify(JSON.parse(fileContents), void 0, indent4), "utf8");
     } catch (e5) {
-      await (0, import_promises148.writeFile)(path99, jsYaml.dump(jsYaml.load(fileContents), { indent: indent4 }), "utf8");
+      await (0, import_promises149.writeFile)(path99, jsYaml.dump(jsYaml.load(fileContents), { indent: indent4 }), "utf8");
     }
     logger4.debug("File written successfully");
   }
@@ -931341,14 +931899,14 @@ async function tryDirectJSONFetch(url3, logger4) {
 async function fetchGraphQLSchemaWithAutoDetection(url3, path99, logger4) {
   const postResult = await tryGraphQLIntrospection(url3, logger4);
   if (postResult.success) {
-    await (0, import_promises148.writeFile)(path99, postResult.result, "utf8");
+    await (0, import_promises149.writeFile)(path99, postResult.result, "utf8");
     logger4.info("Successfully fetched GraphQL schema using POST introspection");
     return;
   }
   logger4.debug(`POST introspection failed: ${postResult.error}`);
   const getResult = await tryDirectJSONFetch(url3, logger4);
   if (getResult.success) {
-    await (0, import_promises148.writeFile)(path99, getResult.result, "utf8");
+    await (0, import_promises149.writeFile)(path99, getResult.result, "utf8");
     logger4.info("Successfully fetched GraphQL schema using direct JSON fetch");
     return;
   }
@@ -931457,7 +932015,7 @@ async function processDefinitions({
 init_lib4();
 
 // ../cli-migrations/lib/migrations/0.0.191/discriminant/migration.js
-var import_promises150 = require("fs/promises");
+var import_promises151 = require("fs/promises");
 
 // ../cli-migrations/lib/migrations/0.0.191/discriminant/getAllYamlFiles.js
 init_lib6();
@@ -931493,7 +932051,7 @@ var migration = {
       try {
         const fileContents = await getFileContents(yamlFilepath);
         const newContents = addDiscriminantToFile(fileContents);
-        await (0, import_promises150.writeFile)(yamlFilepath, newContents);
+        await (0, import_promises151.writeFile)(yamlFilepath, newContents);
       } catch (error50) {
         context3.failAndThrow("Failed to migrate " + yamlFilepath, error50);
       }
@@ -931501,7 +932059,7 @@ var migration = {
   }
 };
 async function getFileContents(filepath) {
-  const buffer = await (0, import_promises150.readFile)(filepath);
+  const buffer = await (0, import_promises151.readFile)(filepath);
   return buffer.toString();
 }
 var UNION_REGEX = /^(\s{2,})union:\s*$/gm;
@@ -931530,7 +932088,7 @@ var versionMigrations = {
 var __default = versionMigrations;
 
 // ../cli-migrations/lib/migrations/0.0.203/union-single-property-key/migration.js
-var import_promises151 = require("fs/promises");
+var import_promises152 = require("fs/promises");
 var import_yaml7 = __toESM(require_dist9(), 1);
 
 // ../cli-migrations/lib/migrations/0.0.203/union-single-property-key/getAllYamlFiles.js
@@ -931573,7 +932131,7 @@ var migration2 = {
   }
 };
 async function migrateFile(filepath, context3) {
-  const contents = await (0, import_promises151.readFile)(filepath);
+  const contents = await (0, import_promises152.readFile)(filepath);
   const parsedDocument = import_yaml7.default.parseDocument(contents.toString());
   const types4 = parsedDocument.get("types");
   if (types4 == null) {
@@ -931605,7 +932163,7 @@ async function migrateFile(filepath, context3) {
       }
     }
   }
-  await (0, import_promises151.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises152.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.0.203/index.js
@@ -931616,7 +932174,7 @@ var versionMigrations2 = {
 var __default2 = versionMigrations2;
 
 // ../cli-migrations/lib/migrations/0.0.207/add-mode-to-draft-generators/migration.js
-var import_promises152 = require("fs/promises");
+var import_promises153 = require("fs/promises");
 var import_yaml8 = __toESM(require_dist9(), 1);
 
 // ../cli-migrations/lib/migrations/0.0.207/add-mode-to-draft-generators/getAllGeneratorYamlFiles.js
@@ -931659,7 +932217,7 @@ var migration3 = {
   }
 };
 async function migrateGeneratorsYml(filepath, context3) {
-  const contents = await (0, import_promises152.readFile)(filepath);
+  const contents = await (0, import_promises153.readFile)(filepath);
   const parsedDocument = import_yaml8.default.parseDocument(contents.toString());
   const draftGenerators = parsedDocument.get("draft");
   if (draftGenerators == null) {
@@ -931686,7 +932244,7 @@ async function migrateGeneratorsYml(filepath, context3) {
       draftGenerator.set("output-path", name2.value.includes("openapi") ? "./generated-openapi" : name2.value.includes("postman") ? "./generated-postman" : localOutput);
     }
   });
-  await (0, import_promises152.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises153.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.0.207/index.js
@@ -931697,7 +932255,7 @@ var versionMigrations3 = {
 var __default3 = versionMigrations3;
 
 // ../cli-migrations/lib/migrations/0.0.210/remove-inline-error-declarations/migration.js
-var import_promises153 = require("fs/promises");
+var import_promises154 = require("fs/promises");
 var import_yaml9 = __toESM(require_dist9(), 1);
 
 // ../cli-migrations/lib/migrations/0.0.210/remove-inline-error-declarations/getAllYamlFiles.js
@@ -931740,7 +932298,7 @@ var migration4 = {
   }
 };
 async function migrateFile2(filepath, context3) {
-  const contents = await (0, import_promises153.readFile)(filepath);
+  const contents = await (0, import_promises154.readFile)(filepath);
   const parsedDocument = import_yaml9.default.parseDocument(contents.toString());
   const addType = (typeName, typeDeclaration2) => {
     const types4 = parsedDocument.get("types");
@@ -931784,7 +932342,7 @@ async function migrateFile2(filepath, context3) {
       }
     }
   }
-  await (0, import_promises153.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises154.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.0.210/index.js
@@ -931795,7 +932353,7 @@ var versionMigrations4 = {
 var __default4 = versionMigrations4;
 
 // ../cli-migrations/lib/migrations/0.0.212/add-publishing-to-release-generators/migration.js
-var import_promises154 = require("fs/promises");
+var import_promises155 = require("fs/promises");
 var import_yaml10 = __toESM(require_dist9(), 1);
 
 // ../cli-migrations/lib/migrations/0.0.212/add-publishing-to-release-generators/getAllGeneratorYamlFiles.js
@@ -931838,7 +932396,7 @@ var migration5 = {
   }
 };
 async function migrateGeneratorsYml2(filepath, context3) {
-  const contents = await (0, import_promises154.readFile)(filepath);
+  const contents = await (0, import_promises155.readFile)(filepath);
   const parsedDocument = import_yaml10.default.parseDocument(contents.toString());
   const releaseGenerators = parsedDocument.get("release");
   if (releaseGenerators == null) {
@@ -931876,7 +932434,7 @@ async function migrateGeneratorsYml2(filepath, context3) {
     }
     releaseGenerator.delete("outputs");
   });
-  await (0, import_promises154.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises155.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.0.212/index.js
@@ -931887,7 +932445,7 @@ var versionMigrations5 = {
 var __default5 = versionMigrations5;
 
 // ../cli-migrations/lib/migrations/0.0.220/rename-alias-key-to-type/migration.js
-var import_promises155 = require("fs/promises");
+var import_promises156 = require("fs/promises");
 
 // ../cli-migrations/lib/migrations/0.0.220/rename-alias-key-to-type/getAllYamlFiles.js
 init_lib6();
@@ -931920,9 +932478,9 @@ var migration6 = {
   run: async ({ context: context3 }) => {
     const yamlFiles = await getAllYamlFiles4(context3);
     for (const filepath of yamlFiles) {
-      const contents = await (0, import_promises155.readFile)(filepath);
+      const contents = await (0, import_promises156.readFile)(filepath);
       const newContents = contents.toString().replaceAll(" alias:", " type:");
-      await (0, import_promises155.writeFile)(filepath, newContents);
+      await (0, import_promises156.writeFile)(filepath, newContents);
     }
   }
 };
@@ -931935,7 +932493,7 @@ var versionMigrations6 = {
 var __default6 = versionMigrations6;
 
 // ../cli-migrations/lib/migrations/0.0.221/add-error-discriminant/migration.js
-var import_promises156 = require("fs/promises");
+var import_promises157 = require("fs/promises");
 
 // ../cli-migrations/lib/migrations/0.0.221/add-error-discriminant/getAllRootApiYamlFiles.js
 init_lib6();
@@ -931968,9 +932526,9 @@ var migration7 = {
   run: async ({ context: context3 }) => {
     const yamlFiles = await getAllRootApiYamlFiles(context3);
     for (const filepath of yamlFiles) {
-      const contents = await (0, import_promises156.readFile)(filepath);
+      const contents = await (0, import_promises157.readFile)(filepath);
       const newContents = contents.toString() + "\nerror-discriminant: error";
-      await (0, import_promises156.writeFile)(filepath, newContents);
+      await (0, import_promises157.writeFile)(filepath, newContents);
     }
   }
 };
@@ -931984,7 +932542,7 @@ var __default7 = versionMigrations7;
 
 // ../cli-migrations/lib/migrations/0.0.241/add-generator-groups/migration.js
 init_lib4();
-var import_promises157 = require("fs/promises");
+var import_promises158 = require("fs/promises");
 
 // ../cli-migrations/lib/migrations/0.0.241/add-generator-groups/getAllGeneratorYamlFiles.js
 init_lib6();
@@ -932116,7 +932674,7 @@ var migration8 = {
   }
 };
 async function migrateGeneratorsYml3(filepath) {
-  const contentsStr = await (0, import_promises157.readFile)(filepath);
+  const contentsStr = await (0, import_promises158.readFile)(filepath);
   const contents = jsYaml.load(contentsStr.toString());
   const oldGeneratorsConfiguration = GeneratorsConfigurationSchema2.parse(contents);
   let newGeneratorsConfiguration = {};
@@ -932134,7 +932692,7 @@ async function migrateGeneratorsYml3(filepath) {
       generators: oldGeneratorsConfiguration.release.map((releaseGeneratorInvocation) => convertReleaseGeneratorInvocation(releaseGeneratorInvocation))
     };
   }
-  await (0, import_promises157.writeFile)(filepath, jsYaml.dump(newGeneratorsConfiguration));
+  await (0, import_promises158.writeFile)(filepath, jsYaml.dump(newGeneratorsConfiguration));
 }
 function convertDraftGeneratorInvocation(draftGeneratorInvocation) {
   const newSchema = {
@@ -932209,7 +932767,7 @@ var versionMigrations8 = {
 var __default8 = versionMigrations8;
 
 // ../cli-migrations/lib/migrations/0.0.248/add-error-discrimination-config/migration.js
-var import_promises158 = require("fs/promises");
+var import_promises159 = require("fs/promises");
 var import_yaml11 = __toESM(require_dist9(), 1);
 
 // ../cli-migrations/lib/migrations/0.0.248/add-error-discrimination-config/getAllRootApiYamlFiles.js
@@ -932252,7 +932810,7 @@ var migration9 = {
   }
 };
 async function migrateRootApiFile(filepath) {
-  const contents = await (0, import_promises158.readFile)(filepath);
+  const contents = await (0, import_promises159.readFile)(filepath);
   const parsedDocument = import_yaml11.default.parseDocument(contents.toString());
   const errorDiscriminant = parsedDocument.get("error-discriminant", true);
   if (errorDiscriminant == null || !import_yaml11.default.isScalar(errorDiscriminant) || typeof errorDiscriminant.value !== "string") {
@@ -932263,7 +932821,7 @@ async function migrateRootApiFile(filepath) {
     "property-name": errorDiscriminant.value
   });
   parsedDocument.delete("error-discriminant");
-  await (0, import_promises158.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises159.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.0.248/index.js
@@ -932274,7 +932832,7 @@ var versionMigrations9 = {
 var __default9 = versionMigrations9;
 
 // ../cli-migrations/lib/migrations/0.1.3-rc3/add-inline-requests/migration.js
-var import_promises159 = require("fs/promises");
+var import_promises160 = require("fs/promises");
 var import_yaml12 = __toESM(require_dist9(), 1);
 
 // ../cli-migrations/lib/migrations/0.1.3-rc3/add-inline-requests/getAllYamlFiles.js
@@ -932317,7 +932875,7 @@ var migration10 = {
   }
 };
 async function migrateYamlFile(filepath, context3) {
-  const contents = await (0, import_promises159.readFile)(filepath);
+  const contents = await (0, import_promises160.readFile)(filepath);
   const parsedDocument = import_yaml12.default.parseDocument(contents.toString());
   const services = parsedDocument.get("services");
   if (services == null) {
@@ -932357,7 +932915,7 @@ async function migrateYamlFile(filepath, context3) {
         context3.failWithoutThrowing("Failed to convert endpoint", e5);
       }
     }
-    await (0, import_promises159.writeFile)(filepath, parsedDocument.toString());
+    await (0, import_promises160.writeFile)(filepath, parsedDocument.toString());
   }
 }
 function convertEndpoint4({ document: document4, endpoint: endpoint3 }) {
@@ -932436,7 +932994,7 @@ var versionMigrations10 = {
 var __default10 = versionMigrations10;
 
 // ../cli-migrations/lib/migrations/0.3.0-rc12/add-value-key-to-type-examples/migration.js
-var import_promises160 = require("fs/promises");
+var import_promises161 = require("fs/promises");
 var import_yaml13 = __toESM(require_dist9(), 1);
 
 // ../cli-migrations/lib/migrations/0.3.0-rc12/add-value-key-to-type-examples/getAllYamlFiles.js
@@ -932479,7 +933037,7 @@ var migration11 = {
   }
 };
 async function migrateYamlFile2(filepath, context3) {
-  const contents = await (0, import_promises160.readFile)(filepath);
+  const contents = await (0, import_promises161.readFile)(filepath);
   const parsedDocument = import_yaml13.default.parseDocument(contents.toString());
   const types4 = parsedDocument.get("types");
   if (types4 == null) {
@@ -932505,7 +933063,7 @@ async function migrateYamlFile2(filepath, context3) {
       examples.set(i9, { value: value2 });
     }
   }
-  await (0, import_promises160.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises161.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.3.0-rc12/index.js
@@ -932516,7 +933074,7 @@ var versionMigrations11 = {
 var __default11 = versionMigrations11;
 
 // ../cli-migrations/lib/migrations/0.3.23/change-services-key-to-service/migration.js
-var import_promises161 = require("fs/promises");
+var import_promises162 = require("fs/promises");
 var import_yaml14 = __toESM(require_dist9(), 1);
 
 // ../cli-migrations/lib/migrations/0.3.23/change-services-key-to-service/getAllYamlFiles.js
@@ -932559,7 +933117,7 @@ var migration12 = {
   }
 };
 async function migrateYamlFile3(filepath, context3) {
-  const contents = await (0, import_promises161.readFile)(filepath);
+  const contents = await (0, import_promises162.readFile)(filepath);
   const parsedDocument = import_yaml14.default.parseDocument(contents.toString());
   if (!import_yaml14.default.isMap(parsedDocument.contents)) {
     return context3.failAndThrow("File is not a map");
@@ -932589,7 +933147,7 @@ async function migrateYamlFile3(filepath, context3) {
       pair.value = firstService.value;
     }
   }
-  await (0, import_promises161.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises162.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.3.23/index.js
@@ -932600,7 +933158,7 @@ var versionMigrations12 = {
 var __default12 = versionMigrations12;
 
 // ../cli-migrations/lib/migrations/0.5.4/move-service-docs-to-top-level/migration.js
-var import_promises162 = require("fs/promises");
+var import_promises163 = require("fs/promises");
 var import_yaml15 = __toESM(require_dist9(), 1);
 
 // ../cli-migrations/lib/migrations/0.5.4/move-service-docs-to-top-level/getAllYamlFiles.js
@@ -932643,7 +933201,7 @@ var migration13 = {
   }
 };
 async function migrateYamlFile4(filepath, context3) {
-  const contents = await (0, import_promises162.readFile)(filepath);
+  const contents = await (0, import_promises163.readFile)(filepath);
   const parsedDocument = import_yaml15.default.parseDocument(contents.toString());
   if (!import_yaml15.default.isMap(parsedDocument.contents)) {
     return context3.failAndThrow("File is not a map");
@@ -932662,7 +933220,7 @@ async function migrateYamlFile4(filepath, context3) {
   }
   service.items.splice(indexOfServiceDocsPair, 1);
   parsedDocument.contents.items.unshift(docsPair);
-  await (0, import_promises162.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises163.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.5.4/index.js
@@ -932673,7 +933231,7 @@ var versionMigrations13 = {
 var __default13 = versionMigrations13;
 
 // ../cli-migrations/lib/migrations/0.9.10/add-suffix-to-docs-domain/migration.js
-var import_promises163 = require("fs/promises");
+var import_promises164 = require("fs/promises");
 
 // ../cli-migrations/lib/migrations/0.9.10/add-suffix-to-docs-domain/getAllGeneratorYamlFiles.js
 init_lib6();
@@ -932715,14 +933273,14 @@ var migration14 = {
   }
 };
 async function migrateYamlFile5(filepath) {
-  const contents = await (0, import_promises163.readFile)(filepath);
+  const contents = await (0, import_promises164.readFile)(filepath);
   const domainSuffix = process.env.DOMAIN_SUFFIX ?? "docs.buildwithfern.com";
   const regex5 = /(docs:\s*domain:\s*)"([^"]*)"/g;
   const updatedSnapshot = contents.toString().replace(regex5, (_match, _prefix, domain3) => {
     return `docs:
       domain: "${domain3}.${domainSuffix}"`;
   });
-  await (0, import_promises163.writeFile)(filepath, updatedSnapshot.toString());
+  await (0, import_promises164.writeFile)(filepath, updatedSnapshot.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.9.10/index.js
@@ -932742,10 +933300,10 @@ var LegacyDocsSerializers = __toESM(require_serialization4(), 1);
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/docs-config/loadRawDocsConfiguration.js
 init_lib6();
-var import_promises164 = require("fs/promises");
+var import_promises165 = require("fs/promises");
 async function loadRawDocsConfiguration2({ absolutePathToWorkspace }) {
   const filepath = getAbsolutePathToDocsYaml({ absolutePathToWorkspace });
-  const contentsStr = await (0, import_promises164.readFile)(filepath);
+  const contentsStr = await (0, import_promises165.readFile)(filepath);
   const contentsParsed = jsYaml.load(contentsStr.toString());
   const result = await LegacyDocsSerializers.DocsConfiguration.parse(contentsParsed);
   if (result.ok) {
@@ -932764,7 +933322,7 @@ function getAbsolutePathToDocsFolder({ absolutePathToWorkspace }) {
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/migrateDocsAndMultipleAPIs.js
 init_lib6();
-var import_promises166 = require("fs/promises");
+var import_promises167 = require("fs/promises");
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/docs-config/convertLegacyDocsConfig.js
 function convertLegacyDocsConfig({ docsConfiguration, docsURLs, apiName }) {
@@ -932972,10 +933530,10 @@ __export(legacy_exports, {
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/generators-configuration/loadRawGeneratorsConfiguration.js
 init_lib6();
-var import_promises165 = require("fs/promises");
+var import_promises166 = require("fs/promises");
 async function loadRawGeneratorsConfiguration2({ absolutePathToWorkspace }) {
   const filepath = getAbsolutePathToGeneratorsConfiguration({ absolutePathToWorkspace });
-  const contentsStr = await (0, import_promises165.readFile)(filepath);
+  const contentsStr = await (0, import_promises166.readFile)(filepath);
   const contentsParsed = jsYaml.load(contentsStr.toString());
   const result = await legacy_exports.GeneratorsConfigurationSchema.safeParseAsync(contentsParsed);
   if (result.success) {
@@ -933005,7 +933563,7 @@ function migrateDocsInstances(docsURLs) {
 var APIS_DIRECTORY2 = "apis";
 async function migrateDocsAndMultipleAPIs({ absolutePathToFernDirectory, workspaces, workspaceContainingDocs }) {
   const absolutePathToApisDirectory = join8(absolutePathToFernDirectory, RelativeFilePath2.of(APIS_DIRECTORY2));
-  await (0, import_promises166.mkdir)(absolutePathToApisDirectory);
+  await (0, import_promises167.mkdir)(absolutePathToApisDirectory);
   for (const workspace of workspaces) {
     const absolutePathToWorkspace = join8(absolutePathToFernDirectory, RelativeFilePath2.of(workspace));
     const docsURLs = await migrateAndWriteGeneratorsYml({ absolutePathToWorkspace });
@@ -933013,11 +933571,11 @@ async function migrateDocsAndMultipleAPIs({ absolutePathToFernDirectory, workspa
       await migrateAndWriteDocsYml({ absolutePathToWorkspace, docsURLs, apiName: workspaceContainingDocs });
       const absolutePathToDocsFolder = getAbsolutePathToDocsFolder({ absolutePathToWorkspace });
       await moveFolder({ src: absolutePathToDocsFolder, dest: absolutePathToFernDirectory });
-      await (0, import_promises166.rm)(absolutePathToDocsFolder, { recursive: true });
+      await (0, import_promises167.rm)(absolutePathToDocsFolder, { recursive: true });
     }
     const absolutePathToNestedWorkspace = join8(absolutePathToApisDirectory, RelativeFilePath2.of(workspace));
     await moveFolder({ src: absolutePathToWorkspace, dest: absolutePathToNestedWorkspace });
-    await (0, import_promises166.rm)(absolutePathToWorkspace, { recursive: true });
+    await (0, import_promises167.rm)(absolutePathToWorkspace, { recursive: true });
   }
 }
 async function migrateAndWriteGeneratorsYml({ absolutePathToWorkspace }) {
@@ -933030,7 +933588,7 @@ async function migrateAndWriteGeneratorsYml({ absolutePathToWorkspace }) {
     generatorsConfiguration,
     pathModificationStrategy: PathModificationStrategy.Nest
   });
-  await (0, import_promises166.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
+  await (0, import_promises167.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
   return convertedResponse.docsURLs;
 }
 async function migrateAndWriteDocsYml({ absolutePathToWorkspace, docsURLs, apiName }) {
@@ -933044,20 +933602,20 @@ async function migrateAndWriteDocsYml({ absolutePathToWorkspace, docsURLs, apiNa
     apiName
   });
   const absolutePathToDocsConfig = getAbsolutePathToDocsYaml({ absolutePathToWorkspace });
-  await (0, import_promises166.writeFile)(absolutePathToDocsConfig, jsYaml.dump(convertedDocsConfig));
+  await (0, import_promises167.writeFile)(absolutePathToDocsConfig, jsYaml.dump(convertedDocsConfig));
 }
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/migrateDocsAndSingleAPI.js
 init_lib6();
-var import_promises167 = require("fs/promises");
+var import_promises168 = require("fs/promises");
 async function migrateDocsAndSingleAPI({ absolutePathToFernDirectory, absolutePathToWorkspace }) {
   const docsURLs = await migrateAndWriteGeneratorsYml2({ absolutePathToWorkspace });
   await migrateAndWriteDocsYml2({ absolutePathToWorkspace, docsURLs });
   const absolutePathToDocsFolder = getAbsolutePathToDocsFolder({ absolutePathToWorkspace });
   await moveFolder({ src: absolutePathToDocsFolder, dest: absolutePathToFernDirectory });
   await moveFolder({ src: absolutePathToWorkspace, dest: absolutePathToFernDirectory });
-  await (0, import_promises167.rm)(absolutePathToDocsFolder, { recursive: true });
-  await (0, import_promises167.rm)(absolutePathToWorkspace, { recursive: true });
+  await (0, import_promises168.rm)(absolutePathToDocsFolder, { recursive: true });
+  await (0, import_promises168.rm)(absolutePathToWorkspace, { recursive: true });
 }
 async function migrateAndWriteDocsYml2({ absolutePathToWorkspace, docsURLs }) {
   const docsConfiguration = await loadRawDocsConfiguration2({ absolutePathToWorkspace });
@@ -933070,7 +933628,7 @@ async function migrateAndWriteDocsYml2({ absolutePathToWorkspace, docsURLs }) {
     apiName: void 0
   });
   const absolutePathToDocsConfig = getAbsolutePathToDocsYaml({ absolutePathToWorkspace });
-  await (0, import_promises167.writeFile)(absolutePathToDocsConfig, jsYaml.dump(convertedDocsConfig));
+  await (0, import_promises168.writeFile)(absolutePathToDocsConfig, jsYaml.dump(convertedDocsConfig));
 }
 async function migrateAndWriteGeneratorsYml2({ absolutePathToWorkspace }) {
   const generatorsConfiguration = await loadRawGeneratorsConfiguration2({ absolutePathToWorkspace });
@@ -933082,23 +933640,23 @@ async function migrateAndWriteGeneratorsYml2({ absolutePathToWorkspace }) {
     generatorsConfiguration,
     pathModificationStrategy: "MoveUp"
   });
-  await (0, import_promises167.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
+  await (0, import_promises168.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
   return convertedResponse.docsURLs;
 }
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/migrateOnlyMultipleAPIs.js
 init_lib6();
-var import_promises168 = require("fs/promises");
+var import_promises169 = require("fs/promises");
 var APIS_DIRECTORY3 = "apis";
 async function migrateOnlyMultipleAPIs({ absolutePathToFernDirectory, workspaces }) {
   const absolutePathToApisDirectory = join8(absolutePathToFernDirectory, RelativeFilePath2.of(APIS_DIRECTORY3));
-  await (0, import_promises168.mkdir)(absolutePathToApisDirectory);
+  await (0, import_promises169.mkdir)(absolutePathToApisDirectory);
   for (const workspace of workspaces) {
     const absolutePathToWorkspace = join8(absolutePathToFernDirectory, RelativeFilePath2.of(workspace));
     await migrateAndWriteGeneratorsYml3({ absolutePathToWorkspace });
     const absolutePathToNestedWorkspace = join8(absolutePathToApisDirectory, RelativeFilePath2.of(workspace));
     await moveFolder({ src: absolutePathToWorkspace, dest: absolutePathToNestedWorkspace });
-    await (0, import_promises168.rm)(absolutePathToWorkspace, { recursive: true });
+    await (0, import_promises169.rm)(absolutePathToWorkspace, { recursive: true });
   }
 }
 async function migrateAndWriteGeneratorsYml3({ absolutePathToWorkspace }) {
@@ -933111,16 +933669,16 @@ async function migrateAndWriteGeneratorsYml3({ absolutePathToWorkspace }) {
     generatorsConfiguration,
     pathModificationStrategy: PathModificationStrategy.Nest
   });
-  await (0, import_promises168.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
+  await (0, import_promises169.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
 }
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/migrateOnlySingleAPI.js
 init_lib6();
-var import_promises169 = require("fs/promises");
+var import_promises170 = require("fs/promises");
 async function migrateOnlySingleAPI({ absolutePathToFernDirectory, absolutePathToWorkspace }) {
   await migrateAndWriteGeneratorsYml4({ absolutePathToWorkspace });
   await moveFolder({ src: absolutePathToWorkspace, dest: absolutePathToFernDirectory });
-  await (0, import_promises169.rm)(absolutePathToWorkspace, { recursive: true });
+  await (0, import_promises170.rm)(absolutePathToWorkspace, { recursive: true });
 }
 async function migrateAndWriteGeneratorsYml4({ absolutePathToWorkspace }) {
   const generatorsConfiguration = await loadRawGeneratorsConfiguration2({ absolutePathToWorkspace });
@@ -933132,7 +933690,7 @@ async function migrateAndWriteGeneratorsYml4({ absolutePathToWorkspace }) {
     generatorsConfiguration,
     pathModificationStrategy: "MoveUp"
   });
-  await (0, import_promises169.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
+  await (0, import_promises170.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
 }
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/migration.js
@@ -933210,7 +933768,7 @@ var __default15 = versionMigrations15;
 
 // ../cli-migrations/lib/migrations/0.41.0-rc0/require-generators-yml/migration.js
 init_lib6();
-var import_promises170 = require("fs/promises");
+var import_promises171 = require("fs/promises");
 var import_yaml16 = __toESM(require_dist9(), 1);
 var migration16 = {
   name: "require-generators-yml",
@@ -933253,7 +933811,7 @@ async function addApiConfigurationToSingleWorkspace({ absolutePathToFernDirector
   if (existingGeneratorsYml == null) {
     if (openapiDirectory != null && openapiDirectory.contents[0] != null) {
       const absolutePathToGeneratorsYml = join8(absoluteFilepathToWorkspace, RelativeFilePath2.of("generators.yml"));
-      await (0, import_promises170.writeFile)(absolutePathToGeneratorsYml, jsYaml.dump({
+      await (0, import_promises171.writeFile)(absolutePathToGeneratorsYml, jsYaml.dump({
         api: {
           path: join8(relativize(absolutePathToFernDirectory, absoluteFilepathToWorkspace), RelativeFilePath2.of(openapiDirectory.name), RelativeFilePath2.of(openapiDirectory.contents[0]?.name))
         }
@@ -933268,7 +933826,7 @@ async function addApiConfigurationToSingleWorkspace({ absolutePathToFernDirector
       parsedDocument.set("api", {
         path: join8(relativize(absolutePathToFernDirectory, absoluteFilepathToWorkspace), RelativeFilePath2.of(openapiDirectory.name), RelativeFilePath2.of(openapiDirectory.contents[0]?.name))
       });
-      await (0, import_promises170.writeFile)(existingGeneratorsYml.absolutePath, parsedDocument.toString());
+      await (0, import_promises171.writeFile)(existingGeneratorsYml.absolutePath, parsedDocument.toString());
       context3.logger.info(source_default.green(`Updated ${existingGeneratorsYml.absolutePath}`));
     }
   }
@@ -933296,7 +933854,7 @@ var __default16 = versionMigrations16;
 
 // ../cli-migrations/lib/migrations/0.54.0-rc0/use-generators-yml-specs/migration.js
 init_lib6();
-var import_promises171 = require("fs/promises");
+var import_promises172 = require("fs/promises");
 var import_yaml17 = __toESM(require_dist9(), 1);
 var migration17 = {
   name: "generators-yml-use-api-specs",
@@ -933476,7 +934034,7 @@ async function addApiConfigurationToSingleWorkspace2({ absoluteFilepathToWorkspa
   if (schemaComment && documentToWrite.indexOf(schemaComment) === -1) {
     documentToWrite = `${schemaComment}${documentToWrite}`;
   }
-  await (0, import_promises171.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
+  await (0, import_promises172.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
   context3.logger.info(source_default.green(`Updated ${generatorsYmlFile.absolutePath}`));
 }
 async function parseApiSpec({ oldSpec, absoluteFilepathToWorkspace, files, directories, context: context3, namespace }) {
@@ -933523,7 +934081,7 @@ async function parseApiSpec({ oldSpec, absoluteFilepathToWorkspace, files, direc
   }
   let specContent;
   try {
-    const fileContents = await (0, import_promises171.readFile)(absoluteSpecPath, { encoding: "utf-8" });
+    const fileContents = await (0, import_promises172.readFile)(absoluteSpecPath, { encoding: "utf-8" });
     specContent = jsYaml.load(fileContents);
   } catch (e5) {
     context3.logger.warn(`Failed to read API spec file ${spec.path}. Error: ${e5}. Skipping...`);
@@ -933627,7 +934185,7 @@ var __default17 = versionMigrations17;
 
 // ../cli-migrations/lib/migrations/0.82.1/add-path-parameter-order-setting/migration.js
 init_lib6();
-var import_promises172 = require("fs/promises");
+var import_promises173 = require("fs/promises");
 var migration18 = {
   name: "add-path-parameter-order-setting",
   summary: `Adds the 'path-parameter-order' setting to existing API configurations to maintain backwards compatibility.
@@ -933715,7 +934273,7 @@ async function updateGeneratorsYml({ context: context3, files }) {
     documentToWrite = `${schemaComment}
 ${documentToWrite}`;
   }
-  await (0, import_promises172.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
+  await (0, import_promises173.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
   context3.logger.info(source_default.green(`Updated ${generatorsYmlFile.absolutePath}`));
 }
 async function getFilesAndDirectories3(absoluteFilepath) {
@@ -933752,7 +934310,7 @@ var __default18 = versionMigrations18;
 
 // ../cli-migrations/lib/migrations/1.0.0/update-settings-defaults/migration.js
 init_lib6();
-var import_promises173 = require("fs/promises");
+var import_promises174 = require("fs/promises");
 var migration19 = {
   name: "update-1_0_0-defaults",
   summary: `The defaults of the API spec settings have changed. 
@@ -933927,7 +934485,7 @@ async function updateGeneratorsYml2({ context: context3, files }) {
     documentToWrite = `${schemaComment}
 ${documentToWrite}`;
   }
-  await (0, import_promises173.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
+  await (0, import_promises174.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
   context3.logger.info(source_default.green(`Updated ${generatorsYmlFile.absolutePath}`));
 }
 async function getFilesAndDirectories4(absoluteFilepath) {
@@ -933997,7 +934555,7 @@ var __default19 = versionMigrations19;
 
 // ../cli-migrations/lib/migrations/2.0.0-rc0/update-settings-defaults/migration.js
 init_lib6();
-var import_promises174 = require("fs/promises");
+var import_promises175 = require("fs/promises");
 var migration20 = {
   name: "update-2_0_0-defaults",
   summary: `The default of 'coerce-enums-to-literals' has changed from true to false. 
@@ -934172,7 +934730,7 @@ async function updateGeneratorsYml3({ context: context3, files }) {
     documentToWrite = `${schemaComment}
 ${documentToWrite}`;
   }
-  await (0, import_promises174.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
+  await (0, import_promises175.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
   context3.logger.info(source_default.green(`Updated ${generatorsYmlFile.absolutePath}`));
 }
 async function getFilesAndDirectories5(absoluteFilepath) {
@@ -934219,7 +934777,7 @@ var __default20 = versionMigrations20;
 
 // ../cli-migrations/lib/migrations/2.13.0/migrate-deprecated-generator-api-settings/migration.js
 init_lib6();
-var import_promises175 = require("fs/promises");
+var import_promises176 = require("fs/promises");
 var migration21 = {
   name: "migrate-deprecated-generator-api-settings",
   summary: `Migrates deprecated generator-level API settings keys to their new equivalents:
@@ -934310,7 +934868,7 @@ async function updateGeneratorsYml4({ context: context3, files }) {
     documentToWrite = `${schemaComment}
 ${documentToWrite}`;
   }
-  await (0, import_promises175.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
+  await (0, import_promises176.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
   context3.logger.info(source_default.green(`Updated ${generatorsYmlFile.absolutePath}`));
 }
 function migrateDeprecatedSettings(settings, context3) {
@@ -934357,7 +934915,7 @@ var __default21 = versionMigrations21;
 
 // ../cli-migrations/lib/migrations/3.0.0/enable-smart-casing/migration.js
 init_lib6();
-var import_promises176 = require("fs/promises");
+var import_promises177 = require("fs/promises");
 var migration22 = {
   name: "enable-smart-casing",
   summary: `Sets 'smart-casing: false' for existing generators to preserve backwards compatibility.
@@ -934441,7 +934999,7 @@ async function updateGeneratorsYml5({ context: context3, files }) {
     documentToWrite = `${schemaComment}
 ${documentToWrite}`;
   }
-  await (0, import_promises176.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
+  await (0, import_promises177.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
   context3.logger.info(source_default.green(`Updated ${generatorsYmlFile.absolutePath}`));
 }
 function setSmartCasingFalseIfNotConfigured(generator, context3) {
@@ -934582,7 +935140,7 @@ ${source_default.dim(migration23.summary)}`
 }
 
 // src/commands/upgrade/upgrade.ts
-var import_promises177 = require("fs/promises");
+var import_promises178 = require("fs/promises");
 
 // src/cwd.ts
 var FERN_CWD_ENV_VAR = "FERN_CWD";
@@ -934909,7 +935467,7 @@ async function upgrade({
     const newProjectConfig = produce(projectConfig2.rawConfig, (draft) => {
       draft.version = resolvedTargetVersion;
     });
-    await (0, import_promises177.writeFile)(
+    await (0, import_promises178.writeFile)(
       projectConfig2._absolutePath,
       ensureFinalNewline2(JSON.stringify(newProjectConfig, void 0, 2))
     );
@@ -935011,7 +935569,7 @@ async function validateDocsBrokenLinks({
 }
 
 // src/commands/validate/validateMdx.ts
-var import_fs37 = require("fs");
+var import_fs38 = require("fs");
 var import_gray_matter10 = __toESM(require_gray_matter(), 1);
 var import_path95 = __toESM(require("path"), 1);
 function calculateVisualColumn(text9, charIndex, tabWidth = 4) {
@@ -935087,7 +935645,7 @@ async function validateMdxFiles({
   });
   const filesToCheck = Array.from(new Set(allPages));
   for (const filepath of filesToCheck) {
-    const content5 = (0, import_fs37.readFileSync)(filepath, "utf-8");
+    const content5 = (0, import_fs38.readFileSync)(filepath, "utf-8");
     try {
       parseMarkdownToTree(content5);
     } catch (error50) {
@@ -935534,7 +936092,7 @@ async function validateWorkspaces({
 
 // src/commands/write-definition/writeDefinitionForWorkspaces.ts
 init_lib6();
-var import_promises178 = require("fs/promises");
+var import_promises179 = require("fs/promises");
 var import_path96 = __toESM(require("path"), 1);
 async function writeDefinitionForWorkspaces({
   project,
@@ -935615,28 +936173,28 @@ async function writeFernDefinition({
     return a4.localeCompare(b7);
   };
   if (await doesPathExist(absolutePathToOutputDirectory)) {
-    await (0, import_promises178.rm)(absolutePathToOutputDirectory, { recursive: true });
+    await (0, import_promises179.rm)(absolutePathToOutputDirectory, { recursive: true });
   }
-  await (0, import_promises178.mkdir)(absolutePathToOutputDirectory, { recursive: true });
-  await (0, import_promises178.writeFile)(
+  await (0, import_promises179.mkdir)(absolutePathToOutputDirectory, { recursive: true });
+  await (0, import_promises179.writeFile)(
     join8(absolutePathToOutputDirectory, RelativeFilePath2.of(ROOT_API_FILENAME)),
     jsYaml.dump(definition3.rootApiFile.contents, { sortKeys })
   );
   for (const [relativePath, packageMarker] of Object.entries(definition3.packageMarkers)) {
     const absoluteFilepath = join8(absolutePathToOutputDirectory, RelativeFilePath2.of(relativePath));
-    await (0, import_promises178.mkdir)(dirname6(absoluteFilepath), { recursive: true });
-    await (0, import_promises178.writeFile)(absoluteFilepath, jsYaml.dump(packageMarker.contents, { sortKeys }));
+    await (0, import_promises179.mkdir)(dirname6(absoluteFilepath), { recursive: true });
+    await (0, import_promises179.writeFile)(absoluteFilepath, jsYaml.dump(packageMarker.contents, { sortKeys }));
   }
   for (const [relativePath, definitionFile] of Object.entries(definition3.namedDefinitionFiles)) {
     const absoluteFilepath = join8(absolutePathToOutputDirectory, RelativeFilePath2.of(relativePath));
-    await (0, import_promises178.mkdir)(dirname6(absoluteFilepath), { recursive: true });
-    await (0, import_promises178.writeFile)(absoluteFilepath, jsYaml.dump(definitionFile.contents, { sortKeys }));
+    await (0, import_promises179.mkdir)(dirname6(absoluteFilepath), { recursive: true });
+    await (0, import_promises179.writeFile)(absoluteFilepath, jsYaml.dump(definitionFile.contents, { sortKeys }));
   }
 }
 
 // src/commands/write-docs-definition/writeDocsDefinitionForProject.ts
 init_lib6();
-var import_promises179 = require("fs/promises");
+var import_promises180 = require("fs/promises");
 async function writeDocsDefinitionForProject({
   project,
   outputPath,
@@ -935668,7 +936226,7 @@ async function writeDocsDefinitionForProject({
       targetAudiences: docsWorkspace.config.instances[0]?.audiences ? Array.isArray(docsWorkspace.config.instances[0].audiences) ? docsWorkspace.config.instances[0].audiences : [docsWorkspace.config.instances[0].audiences] : void 0
     });
     const docsDefinition = await docsResolver.resolve();
-    await (0, import_promises179.writeFile)(AbsoluteFilePath2.of(outputPath), JSON.stringify(docsDefinition, null, 2));
+    await (0, import_promises180.writeFile)(AbsoluteFilePath2.of(outputPath), JSON.stringify(docsDefinition, null, 2));
     context3.logger.info(source_default.green(`Docs definition written to ${outputPath}`));
   });
 }
@@ -935676,8 +936234,8 @@ async function writeDocsDefinitionForProject({
 // src/commands/write-translation/writeTranslationForProject.ts
 init_lib6();
 var import_cli_progress2 = __toESM(require_cli_progress(), 1);
-var import_fs40 = require("fs");
-var import_promises183 = require("fs/promises");
+var import_fs41 = require("fs");
+var import_promises184 = require("fs/promises");
 var import_is_ci3 = __toESM(require_is_ci(), 1);
 var import_path99 = __toESM(require("path"), 1);
 
@@ -936170,7 +936728,7 @@ function shouldProcessFile(filePath, stub) {
 
 // src/commands/write-translation/docs-config-utils.ts
 init_lib6();
-var import_promises180 = require("fs/promises");
+var import_promises181 = require("fs/promises");
 
 // src/commands/write-translation/url-utils.ts
 function addLanguageSuffixToUrl(url3, language) {
@@ -936327,7 +936885,7 @@ async function createLanguageSpecificDocsConfig({
   stub = false
 }) {
   try {
-    const originalConfigContent = await (0, import_promises180.readFile)(originalDocsConfigPath, "utf-8");
+    const originalConfigContent = await (0, import_promises181.readFile)(originalDocsConfigPath, "utf-8");
     const transformation = {
       filePath: DOCS_CONFIGURATION_FILENAME,
       language,
@@ -936341,7 +936899,7 @@ async function createLanguageSpecificDocsConfig({
     const modifiedConfigContent = jsYaml.dump(modifiedConfig, {
       sortKeys: false
     });
-    await (0, import_promises180.writeFile)(modifiedConfigPath, modifiedConfigContent, "utf-8");
+    await (0, import_promises181.writeFile)(modifiedConfigPath, modifiedConfigContent, "utf-8");
     context3.logger.debug(`Created language-specific docs config: ${modifiedConfigPath}`);
   } catch (error50) {
     if (error50 instanceof Error && error50.message.includes("403")) {
@@ -936353,19 +936911,19 @@ async function createLanguageSpecificDocsConfig({
 
 // src/commands/write-translation/file-collection-utils.ts
 init_lib6();
-var import_fs38 = require("fs");
-var import_promises181 = require("fs/promises");
+var import_fs39 = require("fs");
+var import_promises182 = require("fs/promises");
 var import_path97 = __toESM(require("path"), 1);
 async function collectFiles(baseDirectory, relativeBase) {
   const discoveredFiles = {};
-  const entries23 = await (0, import_promises181.readdir)(baseDirectory);
+  const entries23 = await (0, import_promises182.readdir)(baseDirectory);
   for (const entry of entries23) {
     if (entry === "translations") {
       continue;
     }
     const fullPath = import_path97.default.join(baseDirectory, entry);
     const relativePath = relativeBase ? join8(relativeBase, RelativeFilePath2.of(entry)) : RelativeFilePath2.of(entry);
-    const stat7 = (0, import_fs38.statSync)(fullPath);
+    const stat7 = (0, import_fs39.statSync)(fullPath);
     if (stat7.isDirectory()) {
       const subdirectoryFiles = await collectFiles(fullPath, relativePath);
       for (const [subPath, subRelativePath] of Object.entries(subdirectoryFiles)) {
@@ -936380,19 +936938,19 @@ async function collectFiles(baseDirectory, relativeBase) {
 
 // src/commands/write-translation/hash-utils.ts
 var import_crypto13 = require("crypto");
-var import_fs39 = require("fs");
-var import_promises182 = require("fs/promises");
+var import_fs40 = require("fs");
+var import_promises183 = require("fs/promises");
 var import_path98 = __toESM(require("path"), 1);
 function calculateContentHash(content5) {
   return (0, import_crypto13.createHash)("sha256").update(content5, "utf-8").digest("hex");
 }
 async function loadHashMappings(translationsDirectory) {
   const hashesFilePath = import_path98.default.join(translationsDirectory, "hashes");
-  if (!(0, import_fs39.existsSync)(hashesFilePath)) {
+  if (!(0, import_fs40.existsSync)(hashesFilePath)) {
     return {};
   }
   try {
-    const hashesContent = await (0, import_promises182.readFile)(hashesFilePath, "utf-8");
+    const hashesContent = await (0, import_promises183.readFile)(hashesFilePath, "utf-8");
     const parsed = JSON.parse(hashesContent);
     const { _comment, ...hashMappings } = parsed;
     return hashMappings;
@@ -936413,11 +936971,11 @@ async function saveHashMappings(translationsDirectory, hashMappings) {
     _comment: "This file is auto-generated by Fern to track source file changes for translation purposes. Do not edit manually - it will be overwritten on the next translation update.",
     ...sortedMappings
   };
-  await (0, import_promises182.writeFile)(hashesFilePath, JSON.stringify(fileContent, null, 2), "utf-8");
+  await (0, import_promises183.writeFile)(hashesFilePath, JSON.stringify(fileContent, null, 2), "utf-8");
 }
 async function hasFileChanged(filePath, relativePath, previousHashes) {
   try {
-    const content5 = await (0, import_promises182.readFile)(filePath, "utf-8");
+    const content5 = await (0, import_promises183.readFile)(filePath, "utf-8");
     const currentHash = calculateContentHash(content5);
     const previousHash = previousHashes[relativePath];
     return currentHash !== previousHash;
@@ -936471,22 +937029,22 @@ async function writeTranslationForProject({
         code: CliError.Code.InternalError
       });
     }
-    if (!(0, import_fs40.existsSync)(translationsDirectory)) {
+    if (!(0, import_fs41.existsSync)(translationsDirectory)) {
       context3.logger.debug(`Creating translations directory at: ${translationsDirectory}`);
-      await (0, import_promises183.mkdir)(translationsDirectory, { recursive: true });
+      await (0, import_promises184.mkdir)(translationsDirectory, { recursive: true });
     }
     const languageStats = {};
     const targetLanguages = languages.filter((lang) => lang !== sourceLanguage);
     const originalDocsConfigPath = join8(fernDirectory, RelativeFilePath2.of(DOCS_CONFIGURATION_FILENAME));
-    const hasDocsConfig = (0, import_fs40.existsSync)(originalDocsConfigPath);
+    const hasDocsConfig = (0, import_fs41.existsSync)(originalDocsConfigPath);
     for (const language of targetLanguages) {
       const languageDirectory = join8(
         translationsDirectory,
         RelativeFilePath2.of(language),
         RelativeFilePath2.of("fern")
       );
-      if (!(0, import_fs40.existsSync)(languageDirectory)) {
-        await (0, import_promises183.mkdir)(languageDirectory, { recursive: true });
+      if (!(0, import_fs41.existsSync)(languageDirectory)) {
+        await (0, import_promises184.mkdir)(languageDirectory, { recursive: true });
       }
       languageStats[language] = {
         filesProcessed: 0,
@@ -936588,7 +937146,7 @@ async function writeTranslationForProject({
                 `[COMPLETED] ${DOCS_CONFIGURATION_FILENAME} -> ${language}/${DOCS_CONFIGURATION_FILENAME}`
               );
             }
-            const originalConfigContent = await (0, import_promises183.readFile)(originalDocsConfigPath, "utf-8");
+            const originalConfigContent = await (0, import_promises184.readFile)(originalDocsConfigPath, "utf-8");
             await updateAndSaveHashForFile(
               translationsDirectory,
               hashMappings,
@@ -936633,7 +937191,7 @@ async function writeTranslationForProject({
             continue;
           }
           cliContext.logger.debug(`[PROCESSING] ${relativePath} (detected changes)`);
-          const originalContent = await (0, import_promises183.readFile)(filePath, "utf-8");
+          const originalContent = await (0, import_promises184.readFile)(filePath, "utf-8");
           await updateAndSaveHashForFile(translationsDirectory, hashMappings, relativePath, originalContent);
           const sourceStats = languageStats[sourceLanguage];
           if (sourceStats) {
@@ -936657,8 +937215,8 @@ async function writeTranslationForProject({
             );
             const destPath = join8(languageDirectory, relativePath);
             const destDir = import_path99.default.dirname(destPath);
-            if (!(0, import_fs40.existsSync)(destDir)) {
-              await (0, import_promises183.mkdir)(destDir, { recursive: true });
+            if (!(0, import_fs41.existsSync)(destDir)) {
+              await (0, import_promises184.mkdir)(destDir, { recursive: true });
             }
             const transformation = {
               filePath: relativePath,
@@ -936671,7 +937229,7 @@ async function writeTranslationForProject({
               cliContext,
               stub
             });
-            await (0, import_promises183.writeFile)(destPath, transformedContent, "utf-8");
+            await (0, import_promises184.writeFile)(destPath, transformedContent, "utf-8");
             const languageStatsForLang = languageStats[language];
             if (languageStatsForLang) {
               languageStatsForLang.filesProcessed++;
@@ -936701,10 +937259,10 @@ async function writeTranslationForProject({
             );
             const destPath = join8(languageDirectory, relativePath);
             const destDir = import_path99.default.dirname(destPath);
-            if (!(0, import_fs40.existsSync)(destDir)) {
-              await (0, import_promises183.mkdir)(destDir, { recursive: true });
+            if (!(0, import_fs41.existsSync)(destDir)) {
+              await (0, import_promises184.mkdir)(destDir, { recursive: true });
             }
-            await (0, import_promises183.copyFile)(filePath, destPath);
+            await (0, import_promises184.copyFile)(filePath, destPath);
             assetsCopied++;
             cliContext.logger.debug(`[ASSET COPIED] ${relativePath} -> ${language}/${relativePath}`);
           }
@@ -938845,13 +939403,13 @@ function addAutomationsGenerateCommand(cli, cliContext) {
     // hidden
     (yargs) => yargs.option("api", {
       type: "string",
-      description: "Target a specific API in a multi-API repo (e.g. 'foo' for fern/apis/foo/). Required when the project has multiple APIs."
+      description: "Filter to a specific API in a multi-API repo (e.g. 'foo' for fern/apis/foo/). Omit to fan out across every API in the project."
     }).option("group", {
       type: "string",
-      description: "The generator group to run (e.g. 'sdk'). Falls back to default-group in generators.yml if omitted."
+      description: "Filter to a specific generator group (e.g. 'sdk'). Omit to fan out across every group. The default-group field in generators.yml is intentionally ignored."
     }).option("generator", {
       type: "string",
-      description: "Target a specific generator by 0-based index (e.g. '0', '1') or by name. Index is preferred for deterministic targeting when duplicate names exist."
+      description: "Target a specific generator by 0-based index (e.g. '0', '1') or by name. When targeting an opted-out generator by index, the command rejects with an error rather than silently skipping. Omit to fan out across every eligible generator in the selected APIs and groups."
     }).option("version", {
       type: "string",
       description: "Version for generated packages. Use 'AUTO' for AI-based semantic versioning that analyzes the diff and determines MAJOR/MINOR/PATCH automatically."
@@ -938859,39 +939417,21 @@ function addAutomationsGenerateCommand(cli, cliContext) {
       boolean: true,
       default: false,
       description: "Enable GitHub automerge on generated PRs. Automerge is skipped when breaking changes (MAJOR bump) are detected, regardless of this flag."
+    }).option("json-file-output", {
+      type: "string",
+      description: "Write a JSON summary of per-generator results to the given path. CI-neutral companion to the markdown summary auto-written to $GITHUB_STEP_SUMMARY."
     }),
     async (argv) => {
-      const { generatorName: genName, generatorIndex: genIndex } = parseGeneratorArg(argv.generator);
-      await cliContext.runTask(async () => {
-        await generateAPIWorkspaces({
-          project: await loadProjectAndRegisterWorkspacesWithContext(cliContext, {
-            commandLineApiWorkspace: argv.api,
-            defaultToAllApiWorkspaces: false
-          }),
-          cliContext,
+      await executeAutomationsGenerate({
+        cliContext,
+        options: {
+          api: argv.api,
+          group: argv.group,
+          generator: argv.generator,
           version: argv.version,
-          groupName: argv.group,
-          generatorName: genName,
-          generatorIndex: genIndex,
-          shouldLogS3Url: false,
-          keepDocker: false,
-          useLocalDocker: false,
-          preview: false,
-          mode: void 0,
-          force: true,
-          runner: void 0,
-          inspect: false,
-          lfsOverride: void 0,
-          fernignorePath: void 0,
-          skipFernignore: false,
-          dynamicIrOnly: false,
-          outputDir: void 0,
-          noReplay: false,
-          retryRateLimited: false,
-          requireEnvVars: false,
-          automationMode: true,
-          autoMerge: argv["auto-merge"]
-        });
+          autoMerge: argv["auto-merge"],
+          jsonOutputPath: argv["json-file-output"]
+        }
       });
     }
   );