@fern-api/fern-api-dev 3.47.3 → 3.47.4

package/cli.cjs

@@ -26912,7 +26912,7 @@ var require_public_api = __commonJS({
         return docs;
       return Object.assign([], { empty: true }, composer$1.streamInfo());
     }
-    function parseDocument3(source2, options2 = {}) {
+    function parseDocument4(source2, options2 = {}) {
       const { lineCounter: lineCounter2, prettyErrors } = parseOptions2(options2);
       const parser$1 = new parser4.Parser(lineCounter2?.addNewLine);
       const composer$1 = new composer.Composer(options2);
@@ -26938,7 +26938,7 @@ var require_public_api = __commonJS({
       } else if (options2 === void 0 && reviver && typeof reviver === "object") {
         options2 = reviver;
       }
-      const doc = parseDocument3(src, options2);
+      const doc = parseDocument4(src, options2);
       if (!doc)
         return null;
       doc.warnings.forEach((warning) => log2.warn(doc.options.logLevel, warning));
@@ -26972,7 +26972,7 @@ var require_public_api = __commonJS({
     }
     exports2.parse = parse18;
     exports2.parseAllDocuments = parseAllDocuments;
-    exports2.parseDocument = parseDocument3;
+    exports2.parseDocument = parseDocument4;
     exports2.stringify = stringify5;
   }
 });
@@ -74452,8 +74452,8 @@ var require_graceful_fs = __commonJS({
       fs34.createReadStream = createReadStream3;
       fs34.createWriteStream = createWriteStream7;
       var fs$readFile = fs34.readFile;
-      fs34.readFile = readFile84;
-      function readFile84(path76, options2, cb2) {
+      fs34.readFile = readFile85;
+      function readFile85(path76, options2, cb2) {
         if (typeof options2 === "function")
           cb2 = options2, options2 = null;
         return go$readFile(path76, options2, cb2);
@@ -75818,7 +75818,7 @@ var require_jsonfile = __commonJS({
       }
       return obj;
     }
-    var readFile84 = universalify.fromPromise(_readFile);
+    var readFile85 = universalify.fromPromise(_readFile);
     function readFileSync12(file2, options2 = {}) {
       if (typeof options2 === "string") {
         options2 = { encoding: options2 };
@@ -75850,7 +75850,7 @@ var require_jsonfile = __commonJS({
       return fs33.writeFileSync(file2, str3, options2);
     }
     module2.exports = {
-      readFile: readFile84,
+      readFile: readFile85,
       readFileSync: readFileSync12,
       writeFile: writeFile68,
       writeFileSync: writeFileSync4
@@ -185194,8 +185194,8 @@ var require_graceful_fs2 = __commonJS({
       fs34.createReadStream = createReadStream3;
       fs34.createWriteStream = createWriteStream7;
       var fs$readFile = fs34.readFile;
-      fs34.readFile = readFile84;
-      function readFile84(path76, options2, cb2) {
+      fs34.readFile = readFile85;
+      function readFile85(path76, options2, cb2) {
         if (typeof options2 === "function")
           cb2 = options2, options2 = null;
         return go$readFile(path76, options2, cb2);
@@ -1302292,6 +1302292,7 @@ function withContext(handler3) {
     const context2 = createContext(args);
     try {
       await handler3(context2, args);
+      process.exit(0);
     } catch (error49) {
       handleError(context2, error49);
       process.exit(1);
@@ -1323757,36 +1323758,6 @@ async function stringifyLargeObject(obj, { pretty, onWrite } = {}) {
   return fileContents.toString();
 }
 
-// ../yaml/loader/lib/ValidationIssue.js
-var ValidationIssue = class {
-  /** The validation error message */
-  message;
-  /** The source location where the issue was found */
-  location;
-  /** The path to the value in the YAML document (e.g., ["cli", "version"]) */
-  yamlPath;
-  constructor({ message, location: location2, yamlPath }) {
-    this.message = message;
-    this.location = location2;
-    this.yamlPath = yamlPath;
-  }
-  /**
-   * Formats as `<file>:<line>:<col>: <message>` for CLI output.
-   *
-   * @example
-   * ```
-   * fern.yml:6:13: org must be a string
-   * ```
-   */
-  toString() {
-    return `${this.location}: ${this.message}`;
-  }
-};
-
-// ../yaml/loader/lib/YamlParser.js
-var import_promises6 = require("fs/promises");
-var import_yaml2 = __toESM(require_dist(), 1);
-
 // ../source/lib/constants.js
 var LOCATION_PROPERTY = "$loc";
 
@@ -1323952,16 +1323923,22 @@ var SourcedNullish = class {
 };
 
 // ../source/lib/SourceLocation.js
-var SourceLocation = class {
+var SourceLocation = class _SourceLocation {
   absoluteFilePath;
   relativeFilePath;
   line;
   column;
-  constructor({ absoluteFilePath, relativeFilePath, line, column }) {
+  /**
+   * If this location was resolved from a `$ref`, this contains the location
+   * of the file that contained the `$ref` reference.
+   */
+  refFrom;
+  constructor({ absoluteFilePath, relativeFilePath, line, column, refFrom }) {
     this.absoluteFilePath = absoluteFilePath;
     this.relativeFilePath = relativeFilePath;
     this.line = line;
     this.column = column;
+    this.refFrom = refFrom;
   }
   /**
    * Formats as "filepath:line:column" using the relative file path.
@@ -1323981,6 +1323958,50 @@ var SourceLocation = class {
   toAbsoluteString() {
     return `${this.absoluteFilePath}:${this.line}:${this.column}`;
   }
+  /**
+   * Creates a new SourceLocation with the given `$ref` location.
+   * This is used when resolving `$ref` references to track where
+   * the reference originated.
+   */
+  withRefFrom(refFrom) {
+    return new _SourceLocation({
+      absoluteFilePath: this.absoluteFilePath,
+      relativeFilePath: this.relativeFilePath,
+      line: this.line,
+      column: this.column,
+      refFrom
+    });
+  }
+};
+
+// ../yaml/loader/lib/ReferenceResolver.js
+var import_promises6 = require("fs/promises");
+var import_yaml2 = __toESM(require_dist(), 1);
+
+// ../yaml/loader/lib/ValidationIssue.js
+var ValidationIssue = class {
+  /** The validation error message */
+  message;
+  /** The source location where the issue was found */
+  location;
+  /** The path to the value in the YAML document (e.g., ["cli", "version"]) */
+  yamlPath;
+  constructor({ message, location: location2, yamlPath }) {
+    this.message = message;
+    this.location = location2;
+    this.yamlPath = yamlPath;
+  }
+  /**
+   * Formats as `<file>:<line>:<col>: <message>` for CLI output.
+   *
+   * @example
+   * ```
+   * fern.yml:6:13: org must be a string
+   * ```
+   */
+  toString() {
+    return `${this.location}: ${this.message}`;
+  }
 };
 
 // ../yaml/loader/lib/YamlDocument.js
@@ -1324049,7 +1324070,276 @@ var YamlDocument = class {
   }
 };
 
+// ../yaml/loader/lib/ReferenceResolver.js
+var REF_KEY = "$ref";
+var ReferenceResolver = class {
+  cwd;
+  constructor({ cwd: cwd2 }) {
+    this.cwd = cwd2;
+  }
+  /**
+   * Resolves all `$ref` references in the given YAML document.
+   *
+   * @param document - The parsed YAML document
+   * @returns Result with either the resolved data or resolution issues
+   */
+  async resolve({ document: document4 }) {
+    const originalFile = document4.absoluteFilePath;
+    const context2 = {
+      cwd: this.cwd,
+      document: document4,
+      originalFile,
+      currentFile: originalFile,
+      resolutionStack: /* @__PURE__ */ new Set([originalFile]),
+      referencedDocuments: {},
+      issues: [],
+      pathMappings: [],
+      yamlPathIndex: 0,
+      refFromLocation: void 0
+    };
+    const resolved = await this.resolveValue({ context: context2, yamlPath: [], value: document4.toJS() });
+    if (context2.issues.length > 0) {
+      return {
+        success: false,
+        issues: context2.issues
+      };
+    }
+    return {
+      success: true,
+      data: resolved,
+      pathMappings: context2.pathMappings
+    };
+  }
+  /**
+   * Looks up the source location for a path, checking path mappings for referenced files.
+   *
+   * @param document - The original document.
+   * @param pathMappings - Path mappings returned from resolution.
+   * @param yamlPath - The path to look up.
+   * @returns The source location, with refFrom attached if the path is in a referenced file.
+   */
+  getSourceLocationWithMappings({ document: document4, pathMappings, yamlPath }) {
+    let bestMatch;
+    for (const mapping of pathMappings) {
+      if (this.yamlPathStartsWith(yamlPath, mapping.yamlPath)) {
+        if (bestMatch == null || mapping.yamlPath.length > bestMatch.yamlPath.length) {
+          bestMatch = mapping;
+        }
+      }
+    }
+    if (bestMatch != null) {
+      const localYamlPath = yamlPath.slice(bestMatch.yamlPath.length);
+      const location2 = bestMatch.document.getSourceLocation(localYamlPath);
+      return location2.withRefFrom(bestMatch.refFromLocation);
+    }
+    return document4.getSourceLocation(yamlPath);
+  }
+  async resolveValue({ context: context2, yamlPath, value }) {
+    if (value == null) {
+      return value;
+    }
+    if (Array.isArray(value)) {
+      return Promise.all(value.map((item, index3) => this.resolveValue({ context: context2, yamlPath: [...yamlPath, index3], value: item })));
+    }
+    if (typeof value === "object") {
+      const obj = value;
+      if (REF_KEY in obj) {
+        const refYamlPath = [...yamlPath, REF_KEY];
+        return this.resolveRef({
+          context: context2,
+          yamlPath: refYamlPath,
+          location: this.getSourceLocation({ context: context2, yamlPath: refYamlPath }),
+          obj,
+          refValue: obj[REF_KEY]
+        });
+      }
+      const resolved = {};
+      for (const key of Object.keys(obj)) {
+        resolved[key] = await this.resolveValue({ context: context2, yamlPath: [...yamlPath, key], value: obj[key] });
+      }
+      return resolved;
+    }
+    return value;
+  }
+  async resolveRef({ context: context2, yamlPath, location: location2, obj, refValue }) {
+    if (typeof refValue !== "string") {
+      context2.issues.push(new ValidationIssue({
+        message: `$ref must be a string, got ${typeof refValue}`,
+        location: location2,
+        yamlPath
+      }));
+      return obj;
+    }
+    const keys11 = Object.keys(obj);
+    if (keys11.length > 1) {
+      const siblingKeys = keys11.filter((k18) => k18 !== REF_KEY);
+      context2.issues.push(new ValidationIssue({
+        message: `$ref cannot have sibling keys; found ${siblingKeys.join(", ")}`,
+        location: location2,
+        yamlPath
+      }));
+      return obj;
+    }
+    if (refValue.includes("#")) {
+      context2.issues.push(new ValidationIssue({
+        message: `JSON pointer and in-document references are not supported: ${refValue}`,
+        location: location2,
+        yamlPath
+      }));
+      return obj;
+    }
+    const referencedFilePath = this.resolveFilePath({ currentFile: context2.currentFile, refValue });
+    if (context2.resolutionStack.has(referencedFilePath)) {
+      const cycle = [...context2.resolutionStack, referencedFilePath].join(" -> ");
+      context2.issues.push(new ValidationIssue({
+        message: `Circular $ref detected: ${cycle}`,
+        location: location2,
+        yamlPath
+      }));
+      return obj;
+    }
+    const resolvedReference = await this.parseFile({
+      context: context2,
+      referencedFilePath,
+      yamlPath,
+      location: location2,
+      refValue
+    });
+    if (resolvedReference === void 0) {
+      return obj;
+    }
+    if (resolvedReference === null) {
+      context2.issues.push(new ValidationIssue({
+        message: `$ref resolves to null: ${refValue}`,
+        location: location2,
+        yamlPath
+      }));
+      return obj;
+    }
+    const parentYamlPath = yamlPath.slice(0, -1);
+    const referencedDocument = context2.referencedDocuments[referencedFilePath];
+    if (referencedDocument != null) {
+      context2.pathMappings.push({
+        yamlPath: parentYamlPath,
+        document: referencedDocument,
+        refFromLocation: location2
+      });
+    }
+    const fullyResolvedReference = await this.resolveReferencedFile({
+      context: context2,
+      referencedFilePath,
+      refFromLocation: location2,
+      yamlPath: parentYamlPath,
+      value: resolvedReference
+    });
+    return fullyResolvedReference;
+  }
+  /**
+   * Resolves a value within the context of a referenced file, handling
+   * the bookkeeping for tracking the current file and YAML path index.
+   */
+  async resolveReferencedFile({ context: context2, referencedFilePath, refFromLocation, yamlPath, value }) {
+    const previousFile = context2.currentFile;
+    const previousYamlPathIndex = context2.yamlPathIndex;
+    const previousRefFromLocation = context2.refFromLocation;
+    context2.currentFile = referencedFilePath;
+    context2.yamlPathIndex = yamlPath.length;
+    context2.refFromLocation = refFromLocation;
+    context2.resolutionStack.add(referencedFilePath);
+    try {
+      return await this.resolveValue({ context: context2, yamlPath, value });
+    } finally {
+      context2.resolutionStack.delete(referencedFilePath);
+      context2.currentFile = previousFile;
+      context2.yamlPathIndex = previousYamlPathIndex;
+      context2.refFromLocation = previousRefFromLocation;
+    }
+  }
+  async parseFile({ context: context2, referencedFilePath, yamlPath, location: location2, refValue }) {
+    if (!await doesPathExist(referencedFilePath)) {
+      context2.issues.push(new ValidationIssue({
+        message: `Referenced file does not exist: ${refValue}`,
+        location: location2,
+        yamlPath
+      }));
+      return void 0;
+    }
+    const content5 = await (0, import_promises6.readFile)(referencedFilePath, "utf-8");
+    const parsedDocument = (0, import_yaml2.parseDocument)(content5);
+    if (parsedDocument.errors.length > 0) {
+      const errorMessages = parsedDocument.errors.map((e6) => e6.message).join("; ");
+      context2.issues.push(new ValidationIssue({
+        message: `Failed to parse referenced file ${refValue}: ${errorMessages}`,
+        location: location2,
+        yamlPath
+      }));
+      return void 0;
+    }
+    const yamlDocument = new YamlDocument({
+      absoluteFilePath: referencedFilePath,
+      relativeFilePath: RelativeFilePath2.of(relative3(context2.cwd, referencedFilePath)),
+      document: parsedDocument,
+      source: content5
+    });
+    context2.referencedDocuments[referencedFilePath] = yamlDocument;
+    return yamlDocument.toJS();
+  }
+  /**
+   * Returns the source location for a value at the given path.
+   *
+   * For the original document, we use the YamlDocument's precise location tracking.
+   * For referenced files, we look up the cached YamlDocument and compute the
+   * local path within that file, attaching the original `$ref` location via `withRefFrom`.
+   */
+  getSourceLocation({ context: context2, yamlPath }) {
+    if (context2.currentFile === context2.originalFile) {
+      return context2.document.getSourceLocation(yamlPath);
+    }
+    const location2 = this.getSourceLocationFromCurrentFile({ context: context2, yamlPath });
+    if (context2.refFromLocation != null) {
+      return location2.withRefFrom(context2.refFromLocation);
+    }
+    return location2;
+  }
+  /**
+   * Checks if a YAML path starts with a given prefix.
+   */
+  yamlPathStartsWith(path76, prefix2) {
+    if (prefix2.length > path76.length) {
+      return false;
+    }
+    for (let i11 = 0; i11 < prefix2.length; i11++) {
+      if (path76[i11] !== prefix2[i11]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  getSourceLocationFromCurrentFile({ context: context2, yamlPath }) {
+    const doc = context2.referencedDocuments[context2.currentFile];
+    if (doc != null) {
+      const localYamlPath = yamlPath.slice(context2.yamlPathIndex);
+      return doc.getSourceLocation(localYamlPath);
+    }
+    return this.createLocationForReferencedFile({ context: context2, absoluteFilePath: context2.currentFile });
+  }
+  createLocationForReferencedFile({ context: context2, absoluteFilePath }) {
+    return new SourceLocation({
+      absoluteFilePath,
+      relativeFilePath: RelativeFilePath2.of(relative3(context2.cwd, absoluteFilePath)),
+      line: 1,
+      column: 1
+    });
+  }
+  resolveFilePath({ currentFile, refValue }) {
+    const currentDir = dirname4(currentFile);
+    return join2(currentDir, RelativeFilePath2.of(refValue));
+  }
+};
+
 // ../yaml/loader/lib/YamlParser.js
+var import_promises7 = require("fs/promises");
+var import_yaml3 = __toESM(require_dist(), 1);
 var YamlParser = class {
   /**
    * Loads and parses a YAML file.
@@ -1324059,8 +1324349,8 @@ var YamlParser = class {
    * @throws Error if the file cannot be read or contains invalid YAML.
    */
   async parse(absoluteFilePath) {
-    const source2 = await (0, import_promises6.readFile)(absoluteFilePath, "utf-8");
-    return (0, import_yaml2.parse)(source2);
+    const source2 = await (0, import_promises7.readFile)(absoluteFilePath, "utf-8");
+    return (0, import_yaml3.parse)(source2);
   }
   /**
    * Loads and parses a YAML file, preserving source location information.
@@ -1324073,8 +1324363,8 @@ var YamlParser = class {
    * @throws Error if the file cannot be read or contains invalid YAML.
    */
   async parseDocument({ absoluteFilePath, cwd: cwd2 }) {
-    const source2 = await (0, import_promises6.readFile)(absoluteFilePath, "utf-8");
-    const document4 = (0, import_yaml2.parseDocument)(source2);
+    const source2 = await (0, import_promises7.readFile)(absoluteFilePath, "utf-8");
+    const document4 = (0, import_yaml3.parseDocument)(source2);
     const relativeFilePath = RelativeFilePath.of(relative2(cwd2, absoluteFilePath));
     return new YamlDocument({
       absoluteFilePath,
@@ -1324133,15 +1324423,18 @@ var YamlSourceResolver = class {
 var YamlConfigLoader = class {
   parser;
   cwd;
+  referenceResolver;
   constructor({ cwd: cwd2 }) {
     this.parser = new YamlParser();
     this.cwd = cwd2;
+    this.referenceResolver = new ReferenceResolver({ cwd: cwd2 });
   }
   /**
    * Loads and validates a YAML configuration file with source location tracking.
    *
    * @param absoluteFilePath - The absolute path to the YAML file.
    * @param schema - The zod schema to validate against.
+   * @param resolveReferences - Whether to resolve `$ref` references before validation (default: true).
    * @returns Result with either the parsed config (both plain and sourced) or validation errors.
    *
    * @example
@@ -1324154,16 +1324447,27 @@ var YamlConfigLoader = class {
    * }
    * ```
    */
-  async load({ absoluteFilePath, schema: schema2 }) {
+  async load({ absoluteFilePath, schema: schema2, resolveReferences = true }) {
     const document4 = await this.parseDocument(absoluteFilePath);
-    const parseResult = schema2.safeParse(document4.toJS());
+    const resolved = await this.resolveReferences({ document: document4, resolveReferences });
+    if (!resolved.success) {
+      return {
+        success: false,
+        issues: resolved.issues
+      };
+    }
+    const parseResult = schema2.safeParse(resolved.data);
     if (!parseResult.success) {
       const issues = parseResult.error.issues.map((issue2) => {
         const yamlPath = issue2.path.filter((p9) => typeof p9 !== "symbol");
         return new ValidationIssue({
           yamlPath,
           message: this.formatZodIssue(issue2),
-          location: document4.getSourceLocation(yamlPath)
+          location: this.referenceResolver.getSourceLocationWithMappings({
+            document: document4,
+            pathMappings: resolved.pathMappings,
+            yamlPath
+          })
         });
       });
       return {
@@ -1324171,11 +1324475,11 @@ var YamlConfigLoader = class {
         issues
       };
     }
-    const resolver2 = new YamlSourceResolver(document4);
+    const sourceResolver = new YamlSourceResolver(document4);
     return {
       success: true,
       data: parseResult.data,
-      sourced: resolver2.toSourced(parseResult.data),
+      sourced: sourceResolver.toSourced(parseResult.data),
       absoluteFilePath,
       relativeFilePath: RelativeFilePath2.of(relative3(this.cwd, absoluteFilePath))
     };
@@ -1324187,6 +1324491,23 @@ var YamlConfigLoader = class {
       throw new Error(`Failed to parse YAML file ${absoluteFilePath}: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
+  async resolveReferences({ document: document4, resolveReferences }) {
+    if (!resolveReferences) {
+      return {
+        success: true,
+        data: document4.toJS(),
+        pathMappings: []
+      };
+    }
+    const resolveResult = await this.referenceResolver.resolve({ document: document4 });
+    if (!resolveResult.success) {
+      return {
+        success: false,
+        issues: resolveResult.issues
+      };
+    }
+    return resolveResult;
+  }
   formatZodIssue(issue2) {
     const path76 = issue2.path.join(".");
     switch (issue2.code) {
@@ -1324513,13 +1324834,18 @@ var FernYmlSchemaLoader = class {
   }
   /**
    * Finds, loads, and validates a fern.yml configuration file.
+   * This also resolves and validates any `$ref` nodes in the
+   * configuration.
    *
    * @returns Result with either the parsed config or validation errors.
    * @throws Error if fern.yml is not found.
    */
   async load() {
     const absoluteFilePath = await this.finder.findOrThrow(FernYml.FILENAME);
-    return await this.loader.load({ absoluteFilePath, schema: FernYmlSchema });
+    return await this.loader.load({
+      absoluteFilePath,
+      schema: FernYmlSchema
+    });
   }
 };
 
@@ -1331450,10 +1331776,10 @@ var ProductFileConfig = schemas_exports4.object({
 });
 
 // ../configuration/lib/fernignoreUtils.js
-var import_promises7 = require("fs/promises");
+var import_promises8 = require("fs/promises");
 var NEW_LINE_REGEX = /\r?\n/;
 async function getFernIgnorePaths({ absolutePathToFernignore }) {
-  const fernIgnoreFileContents = (await (0, import_promises7.readFile)(absolutePathToFernignore)).toString();
+  const fernIgnoreFileContents = (await (0, import_promises8.readFile)(absolutePathToFernignore)).toString();
   return parseFernIgnoreContents(fernIgnoreFileContents);
 }
 function parseFernIgnoreContents(fernIgnoreFileContents) {
@@ -1334289,7 +1334615,7 @@ function isPath(value) {
 }
 
 // ../configuration-loader/lib/dependencies-yml/loadRawDependenciesConfiguration.js
-var import_promises8 = require("fs/promises");
+var import_promises9 = require("fs/promises");
 
 // ../../../node_modules/.pnpm/js-yaml@4.1.1/node_modules/js-yaml/dist/js-yaml.mjs
 function isNothing(subject) {
@@ -1336926,7 +1337252,7 @@ async function loadRawDependenciesConfiguration({ absolutePathToWorkspace, conte
   if (!await doesPathExist(absolutePathToDependenciesConfiguration)) {
     return void 0;
   }
-  const contentsStr = await (0, import_promises8.readFile)(absolutePathToDependenciesConfiguration);
+  const contentsStr = await (0, import_promises9.readFile)(absolutePathToDependenciesConfiguration);
   const contentsParsed = jsYaml.load(contentsStr.toString());
   return await validateSchema({
     schema: DependenciesConfigurationSchema,
@@ -1410577,15 +1410903,15 @@ var Pruner = class _Pruner {
 };
 
 // ../configuration-loader/lib/docs-yml/parseDocsConfiguration.js
-var import_promises11 = require("fs/promises");
+var import_promises12 = require("fs/promises");
 var import_path16 = __toESM(require("path"), 1);
 
 // ../configuration-loader/lib/docs-yml/getAllPages.js
-var import_promises9 = require("fs/promises");
+var import_promises10 = require("fs/promises");
 var BATCH_SIZE = 100;
 async function loadBatch({ files, absolutePathToFernFolder }) {
   const pairs2 = await Promise.all(files.map(async (file2) => {
-    const content5 = await (0, import_promises9.readFile)(file2, "utf-8");
+    const content5 = await (0, import_promises10.readFile)(file2, "utf-8");
     return [relativize(absolutePathToFernFolder, file2), content5];
   }));
   return Object.fromEntries(pairs2);
@@ -1410694,7 +1411020,7 @@ function getAllPagesFromApiReferenceLayoutItem({ item }) {
 }
 
 // ../configuration-loader/lib/docs-yml/navigationUtils.js
-var import_promises10 = require("fs/promises");
+var import_promises11 = require("fs/promises");
 var import_gray_matter = __toESM(require_gray_matter(), 1);
 function nameToSlug({ name: name3 }) {
   return name3.replace(/\.(md|mdx)$/i, "").toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
@@ -1410702,7 +1411028,7 @@ function nameToSlug({ name: name3 }) {
 function nameToTitle({ name: name3 }) {
   return name3.replace(/\.(md|mdx)$/i, "").replace(/[-_]/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
 }
-async function getFrontmatterPosition({ absolutePath, readFileFn = (path76, encoding) => (0, import_promises10.readFile)(path76, encoding) }) {
+async function getFrontmatterPosition({ absolutePath, readFileFn = (path76, encoding) => (0, import_promises11.readFile)(path76, encoding) }) {
   try {
     const content5 = await readFileFn(absolutePath, "utf-8");
     const { data: data2 } = (0, import_gray_matter.default)(content5);
@@ -1410718,7 +1411044,7 @@ async function getFrontmatterPosition({ absolutePath, readFileFn = (path76, enco
     return void 0;
   }
 }
-async function buildNavigationForDirectory({ directoryPath, getDir = getDirectoryContents, readFileFn = (path76, encoding) => (0, import_promises10.readFile)(path76, encoding) }) {
+async function buildNavigationForDirectory({ directoryPath, getDir = getDirectoryContents, readFileFn = (path76, encoding) => (0, import_promises11.readFile)(path76, encoding) }) {
   const contents = await getDir(directoryPath);
   const markdownFiles = contents.filter((item) => item.type === "file" && (item.name.endsWith(".md") || item.name.endsWith(".mdx")));
   const subdirectories = contents.filter((item) => item.type === "directory");
@@ -1410975,7 +1411301,7 @@ async function convertCssConfig(css, absoluteFilepathToDocsConfig) {
   const cssFilePaths = typeof css === "string" ? [css] : css;
   return {
     inline: await Promise.all(cssFilePaths.map(async (cssFilePath) => {
-      const content5 = await (0, import_promises11.readFile)(resolveFilepath(cssFilePath, absoluteFilepathToDocsConfig));
+      const content5 = await (0, import_promises12.readFile)(resolveFilepath(cssFilePath, absoluteFilepathToDocsConfig));
       return content5.toString();
     }))
   };
@@ -1411134,7 +1411460,7 @@ async function getVersionedNavigationConfiguration({ versions, absolutePathToFer
   const versionedNavbars = [];
   for (const version7 of versions) {
     const absoluteFilepathToVersionFile = resolve5(absolutePathToFernFolder, version7.path);
-    const versionContent = jsYaml.load((await (0, import_promises11.readFile)(absoluteFilepathToVersionFile)).toString());
+    const versionContent = jsYaml.load((await (0, import_promises12.readFile)(absoluteFilepathToVersionFile)).toString());
     const removedPaths = [];
     const sanitizedVersionContent = sanitizeNullValues(versionContent, [], removedPaths);
     if (removedPaths.length > 0) {
@@ -1411182,7 +1411508,7 @@ async function getNavigationConfiguration({ tabs, products, versions, navigation
       if ("path" in product) {
         let navigation2;
         const absoluteFilepathToProductFile = resolve5(absolutePathToFernFolder, product.path);
-        const content5 = jsYaml.load((await (0, import_promises11.readFile)(absoluteFilepathToProductFile)).toString());
+        const content5 = jsYaml.load((await (0, import_promises12.readFile)(absoluteFilepathToProductFile)).toString());
         const removedPaths = [];
         const sanitizedContent = sanitizeNullValues(content5, [], removedPaths);
         if (removedPaths.length > 0) {
@@ -1411876,7 +1412202,7 @@ function parseAudiences(raw2) {
 }
 
 // ../configuration-loader/lib/fern-config-json/loadProjectConfig.js
-var import_promises12 = require("fs/promises");
+var import_promises13 = require("fs/promises");
 
 // ../configuration-loader/lib/fern-config-json/schema/ProjectConfigSchema.js
 var ProjectConfigSchema = external_exports2.strictObject({
@@ -1411887,7 +1412213,7 @@ var ProjectConfigSchema = external_exports2.strictObject({
 // ../configuration-loader/lib/fern-config-json/loadProjectConfig.js
 async function loadProjectConfig({ directory, context: context2 }) {
   const pathToConfig = join2(directory, RelativeFilePath2.of(PROJECT_CONFIG_FILENAME));
-  const projectConfigStr = await (0, import_promises12.readFile)(pathToConfig);
+  const projectConfigStr = await (0, import_promises13.readFile)(pathToConfig);
   const projectConfigParsed = JSON.parse(projectConfigStr.toString());
   const rawProjectConfig = await validateSchema({
     schema: ProjectConfigSchema,
@@ -1412289,7 +1412615,7 @@ async function addGenerator({ generatorName, generatorsConfiguration, groupName
 }
 
 // ../../commons/github/lib/ClonedRepository.js
-var import_promises13 = require("fs/promises");
+var import_promises14 = require("fs/promises");
 var import_path17 = __toESM(require("path"), 1);
 
 // ../../../node_modules/.pnpm/simple-git@3.30.0/node_modules/simple-git/dist/esm/index.js
@@ -1417037,18 +1417363,18 @@ var ClonedRepository = class _ClonedRepository {
   }
   async overwriteLocalContents(sourceDirectoryPath) {
     const [sourceContents, destContents] = await Promise.all([
-      (0, import_promises13.readdir)(sourceDirectoryPath),
-      (0, import_promises13.readdir)(this.clonePath)
+      (0, import_promises14.readdir)(sourceDirectoryPath),
+      (0, import_promises14.readdir)(this.clonePath)
     ]);
     await Promise.all(destContents.filter((content5) => !DEFAULT_IGNORED_FILES.includes(content5)).map(async (content5) => {
-      await (0, import_promises13.rm)((0, import_path17.resolve)(this.clonePath, content5), {
+      await (0, import_promises14.rm)((0, import_path17.resolve)(this.clonePath, content5), {
         recursive: true,
         force: true
       });
     }));
     await Promise.all(sourceContents.filter((content5) => !DEFAULT_IGNORED_FILES.includes(content5)).map(async (content5) => {
       const path76 = (0, import_path17.resolve)(sourceDirectoryPath, content5);
-      await (0, import_promises13.cp)(path76, (0, import_path17.resolve)(this.clonePath, content5), { recursive: true });
+      await (0, import_promises14.cp)(path76, (0, import_path17.resolve)(this.clonePath, content5), { recursive: true });
     }));
   }
   async readFile({ relativeFilePath }) {
@@ -1417056,12 +1417382,12 @@ var ClonedRepository = class _ClonedRepository {
     if (!await doesPathExist2(absoluteFilePath)) {
       return void 0;
     }
-    return await (0, import_promises13.readFile)(absoluteFilePath, "utf-8");
+    return await (0, import_promises14.readFile)(absoluteFilePath, "utf-8");
   }
 };
 async function doesPathExist2(filepath) {
   try {
-    await (0, import_promises13.lstat)(filepath);
+    await (0, import_promises14.lstat)(filepath);
     return true;
   } catch {
     return false;
@@ -1417394,7 +1417720,7 @@ var LruObject = class {
 // ../configuration-loader/lib/generators-yml/convertGeneratorsConfiguration.js
 var import_fiddle_sdk = __toESM(require_fiddle_sdk(), 1);
 var import_api = __toESM(require_api2(), 1);
-var import_promises14 = require("fs/promises");
+var import_promises15 = require("fs/promises");
 var import_path18 = __toESM(require("path"), 1);
 var UNDEFINED_API_DEFINITION_SETTINGS = {
   shouldUseTitleAsName: void 0,
@@ -1418031,7 +1418357,7 @@ async function getGithubLicense({ absolutePathToGeneratorsConfiguration, githubL
     }
   }
   const absolutePathToLicense = join2(AbsoluteFilePath2.of(import_path18.default.dirname(absolutePathToGeneratorsConfiguration)), RelativeFilePath2.of(githubLicense.custom));
-  const licenseContent = await (0, import_promises14.readFile)(absolutePathToLicense);
+  const licenseContent = await (0, import_promises15.readFile)(absolutePathToLicense);
   return import_fiddle_sdk.FernFiddle.GithubLicense.custom({
     contents: licenseContent.toString()
   });
@@ -1418210,14 +1418536,14 @@ function isGithubSelfhosted(github) {
 }
 
 // ../configuration-loader/lib/generators-yml/loadGeneratorsConfiguration.js
-var import_promises15 = require("fs/promises");
+var import_promises16 = require("fs/promises");
 var import_path19 = __toESM(require("path"), 1);
 async function loadRawGeneratorsConfiguration({ absolutePathToWorkspace, context: context2 }) {
   const filepath = await getPathToGeneratorsConfiguration({ absolutePathToWorkspace });
   if (filepath == null) {
     return void 0;
   }
-  const contentsStr = await (0, import_promises15.readFile)(filepath);
+  const contentsStr = await (0, import_promises16.readFile)(filepath);
   try {
     const contentsParsed = jsYaml.load(contentsStr.toString());
     const parsed = generators_yml_exports.serialization.GeneratorsConfigurationSchema.parse(contentsParsed, {
@@ -1418294,7 +1418620,7 @@ async function getFernDirectory(nameOverride) {
 }
 
 // ../init/lib/initializeAPI.js
-var import_promises23 = require("fs/promises");
+var import_promises24 = require("fs/promises");
 var import_fs_extra = __toESM(require_lib6(), 1);
 var import_path23 = __toESM(require("path"), 1);
 
@@ -1422888,7 +1423214,7 @@ async function createOrganizationIfDoesNotExist({ organization, token, context:
 }
 
 // ../auth/lib/persistence/getToken.js
-var import_promises16 = require("fs/promises");
+var import_promises17 = require("fs/promises");
 
 // ../auth/lib/persistence/getPathToTokenFile.js
 var import_os = require("os");
@@ -1422919,7 +1423245,7 @@ async function getUserToken() {
   if (!doesTokenFileExist) {
     return void 0;
   }
-  const tokenFileContents = await (0, import_promises16.readFile)(pathToTokenFile);
+  const tokenFileContents = await (0, import_promises17.readFile)(pathToTokenFile);
   const tokenString = tokenFileContents.toString().trim();
   if (tokenString.length === 0) {
     return void 0;
@@ -1422931,11 +1423257,11 @@ async function getUserToken() {
 }
 
 // ../auth/lib/persistence/removeToken.js
-var import_promises17 = require("fs/promises");
+var import_promises18 = require("fs/promises");
 async function removeToken() {
   const pathToTokenFile = getPathToTokenFile();
   try {
-    await (0, import_promises17.unlink)(pathToTokenFile);
+    await (0, import_promises18.unlink)(pathToTokenFile);
   } catch (error49) {
     if (error49.code !== "ENOENT") {
       throw error49;
@@ -1422944,12 +1423270,12 @@ async function removeToken() {
 }
 
 // ../auth/lib/persistence/storeToken.js
-var import_promises18 = require("fs/promises");
+var import_promises19 = require("fs/promises");
 var import_path20 = __toESM(require("path"), 1);
 async function storeToken(token) {
   const pathToTokenFile = getPathToTokenFile();
-  await (0, import_promises18.mkdir)(import_path20.default.dirname(pathToTokenFile), { recursive: true });
-  await (0, import_promises18.writeFile)(pathToTokenFile, token);
+  await (0, import_promises19.mkdir)(import_path20.default.dirname(pathToTokenFile), { recursive: true });
+  await (0, import_promises19.writeFile)(pathToTokenFile, token);
 }
 
 // ../auth/lib/users/getCurrentUser.js
@@ -1428934,7 +1429260,7 @@ var AccessTokenPosthogManager = class {
         properties: {
           ...event,
           ...event.properties,
-          version: "3.47.3",
+          version: "3.47.4",
           usingAccessToken: true
         }
       });
@@ -1428956,7 +1429282,7 @@ var NoopPosthogManager = class {
 };
 
 // ../posthog-manager/lib/UserPosthogManager.js
-var import_promises19 = require("fs/promises");
+var import_promises20 = require("fs/promises");
 var import_os2 = require("os");
 var import_path22 = require("path");
 
@@ -1429033,7 +1429359,7 @@ var UserPosthogManager = class {
       distinctId: this.userId ?? await this.getPersistedDistinctId(),
       event: "CLI",
       properties: {
-        version: "3.47.3",
+        version: "3.47.4",
         ...event,
         ...event.properties,
         usingAccessToken: false,
@@ -1429072,10 +1429398,10 @@ var UserPosthogManager = class {
     if (this.persistedDistinctId == null) {
       const pathToFile = join2(AbsoluteFilePath2.of((0, import_os2.homedir)()), RelativeFilePath2.of(LOCAL_STORAGE_FOLDER2), RelativeFilePath2.of(DISTINCT_ID_FILENAME));
       if (!await doesPathExist(pathToFile)) {
-        await (0, import_promises19.mkdir)((0, import_path22.dirname)(pathToFile), { recursive: true });
-        await (0, import_promises19.writeFile)(pathToFile, v4_default());
+        await (0, import_promises20.mkdir)((0, import_path22.dirname)(pathToFile), { recursive: true });
+        await (0, import_promises20.writeFile)(pathToFile, v4_default());
       }
-      this.persistedDistinctId = (await (0, import_promises19.readFile)(pathToFile)).toString();
+      this.persistedDistinctId = (await (0, import_promises20.readFile)(pathToFile)).toString();
     }
     return this.persistedDistinctId;
   }
@@ -1433606,7 +1433932,7 @@ function constructAuth0LogoutUrl() {
 }
 
 // ../init/lib/createFernDirectoryAndOrganization.js
-var import_promises20 = require("fs/promises");
+var import_promises21 = require("fs/promises");
 var GITIGNORE_CONTENT = "**/.preview\n**/.definition\n";
 async function createFernDirectoryAndWorkspace({ organization, taskContext, versionOfCli }) {
   const pathToFernDirectory = join2(cwd(), RelativeFilePath2.of(FERN_DIRECTORY));
@@ -1433635,7 +1433961,7 @@ async function createFernDirectoryAndWorkspace({ organization, taskContext, vers
         }
       }
     }
-    await (0, import_promises20.mkdir)(FERN_DIRECTORY);
+    await (0, import_promises21.mkdir)(FERN_DIRECTORY);
     await writeProjectConfig({
       filepath: join2(pathToFernDirectory, RelativeFilePath2.of(PROJECT_CONFIG_FILENAME)),
       organization,
@@ -1433659,11 +1433985,11 @@ async function writeProjectConfig({ organization, filepath, versionOfCli }) {
     organization,
     version: versionOfCli
   };
-  await (0, import_promises20.writeFile)(filepath, JSON.stringify(projectConfig, void 0, 4));
+  await (0, import_promises21.writeFile)(filepath, JSON.stringify(projectConfig, void 0, 4));
 }
 async function writeGitignore({ absolutePathToFernDirectory }) {
   const gitignorePath = join2(absolutePathToFernDirectory, RelativeFilePath2.of(".gitignore"));
-  await (0, import_promises20.writeFile)(gitignorePath, GITIGNORE_CONTENT);
+  await (0, import_promises21.writeFile)(gitignorePath, GITIGNORE_CONTENT);
 }
 
 // ../fern-definition/formatter/lib/FernDefinitionFileFormatter.js
@@ -1433847,7 +1434173,7 @@ async function formatDefinitionFile({ fileContents }) {
 }
 
 // ../fern-definition/formatter/lib/formatWorkspace.js
-var import_promises21 = require("fs/promises");
+var import_promises22 = require("fs/promises");
 async function formatFernWorkspace({ workspace, context: context2, shouldFix }) {
   for (const [relativeFilepath, file2] of entries(workspace.definition.namedDefinitionFiles)) {
     const formatted = await formatDefinitionFile({
@@ -1433855,7 +1434181,7 @@ async function formatFernWorkspace({ workspace, context: context2, shouldFix })
     });
     if (formatted !== file2.rawContents) {
       if (shouldFix) {
-        await (0, import_promises21.writeFile)(file2.absoluteFilePath, formatted);
+        await (0, import_promises22.writeFile)(file2.absoluteFilePath, formatted);
         context2.logger.info(source_default.green(`Formatted ${source_default.bold(relativeFilepath)}`));
       } else {
         context2.logger.info(source_default.red(`Invalid formatting: ${source_default.bold(relativeFilepath)}`));
@@ -1433866,7 +1434192,7 @@ async function formatFernWorkspace({ workspace, context: context2, shouldFix })
 }
 
 // ../init/lib/createWorkspace.js
-var import_promises22 = require("fs/promises");
+var import_promises23 = require("fs/promises");
 
 // ../init/lib/sampleImdbApi.js
 var SAMPLE_IMDB_API = `
@@ -1433934,7 +1434260,7 @@ errors:
 // ../init/lib/createWorkspace.js
 async function createFernWorkspace({ directoryOfWorkspace, cliVersion, context: context2 }) {
   if (!await doesPathExist(directoryOfWorkspace)) {
-    await (0, import_promises22.mkdir)(directoryOfWorkspace);
+    await (0, import_promises23.mkdir)(directoryOfWorkspace);
   }
   await writeGeneratorsConfiguration({
     filepath: join2(directoryOfWorkspace, RelativeFilePath2.of(GENERATORS_CONFIGURATION_FILENAME)),
@@ -1433948,7 +1434274,7 @@ async function createFernWorkspace({ directoryOfWorkspace, cliVersion, context:
 }
 async function createOpenAPIWorkspace({ directoryOfWorkspace, openAPIFilePath, cliVersion, context: context2 }) {
   if (!await doesPathExist(directoryOfWorkspace)) {
-    await (0, import_promises22.mkdir)(directoryOfWorkspace);
+    await (0, import_promises23.mkdir)(directoryOfWorkspace);
   }
   await writeGeneratorsConfiguration({
     filepath: join2(directoryOfWorkspace, RelativeFilePath2.of(GENERATORS_CONFIGURATION_FILENAME)),
@@ -1433994,7 +1434320,7 @@ async function getDefaultGeneratorsConfiguration({ cliVersion, context: context2
   return config3;
 }
 async function writeGeneratorsConfiguration({ filepath, cliVersion, context: context2, apiConfiguration }) {
-  await (0, import_promises22.writeFile)(filepath, "# yaml-language-server: $schema=https://schema.buildwithfern.dev/generators-yml.json\n" + jsYaml.dump(await getDefaultGeneratorsConfiguration({ cliVersion, context: context2, apiConfiguration }), {
+  await (0, import_promises23.writeFile)(filepath, "# yaml-language-server: $schema=https://schema.buildwithfern.dev/generators-yml.json\n" + jsYaml.dump(await getDefaultGeneratorsConfiguration({ cliVersion, context: context2, apiConfiguration }), {
     sortKeys: (a10, b18) => {
       if (a10 === "api") {
         return -1;
@@ -1434013,10 +1434339,10 @@ var ROOT_API = {
   }
 };
 async function writeSampleApiDefinition({ directoryOfDefinition }) {
-  await (0, import_promises22.mkdir)(directoryOfDefinition);
-  await (0, import_promises22.writeFile)(join2(directoryOfDefinition, RelativeFilePath2.of(ROOT_API_FILENAME)), jsYaml.dump(ROOT_API));
+  await (0, import_promises23.mkdir)(directoryOfDefinition);
+  await (0, import_promises23.writeFile)(join2(directoryOfDefinition, RelativeFilePath2.of(ROOT_API_FILENAME)), jsYaml.dump(ROOT_API));
   const absoluteFilepathToImdbYaml = join2(directoryOfDefinition, RelativeFilePath2.of("imdb.yml"));
-  await (0, import_promises22.writeFile)(absoluteFilepathToImdbYaml, await formatDefinitionFile({
+  await (0, import_promises23.writeFile)(absoluteFilepathToImdbYaml, await formatDefinitionFile({
     fileContents: SAMPLE_IMDB_API
   }));
 }
@@ -1434062,13 +1434388,13 @@ async function getDirectoryOfNewAPIWorkspace({ absolutePathToFernDirectory, task
     const apiWorkspaceDirectory = join2(absolutePathToFernDirectory, RelativeFilePath2.of(APIS_DIRECTORY), RelativeFilePath2.of("api"));
     const inlinedDefinitionDirectory = join2(absolutePathToFernDirectory, RelativeFilePath2.of(DEFINITION_DIRECTORY));
     const workspaceDefinitionDirectory = join2(apiWorkspaceDirectory, RelativeFilePath2.of(DEFINITION_DIRECTORY));
-    await (0, import_promises23.mkdir)(apiWorkspaceDirectory, { recursive: true });
+    await (0, import_promises24.mkdir)(apiWorkspaceDirectory, { recursive: true });
     await import_fs_extra.default.move(inlinedDefinitionDirectory, workspaceDefinitionDirectory);
     const inlinedGeneratorsYml = join2(absolutePathToFernDirectory, RelativeFilePath2.of(GENERATORS_CONFIGURATION_FILENAME));
     const workspaceGeneratorsYml = join2(apiWorkspaceDirectory, RelativeFilePath2.of(GENERATORS_CONFIGURATION_FILENAME));
     await import_fs_extra.default.move(inlinedGeneratorsYml, workspaceGeneratorsYml);
     const newApiDirectory = join2(absolutePathToFernDirectory, RelativeFilePath2.of(APIS_DIRECTORY), RelativeFilePath2.of("api1"));
-    await (0, import_promises23.mkdir)(workspaceDefinitionDirectory, { recursive: true });
+    await (0, import_promises24.mkdir)(workspaceDefinitionDirectory, { recursive: true });
     return newApiDirectory;
   }
   return absolutePathToFernDirectory;
@@ -1434083,7 +1434409,7 @@ async function hasInlinedAPIDefinitions({ absolutePathToFernDirectory }) {
 }
 
 // ../init/lib/initializeDocs.js
-var import_promises24 = require("fs/promises");
+var import_promises25 = require("fs/promises");
 
 // ../../commons/core-utils/src/titleCase.ts
 var import_title3 = __toESM(require_lib(), 1);
@@ -1434499,7 +1434825,7 @@ async function initializeDocs({ organization, taskContext, versionOfCli }) {
     } else {
       try {
         const docsConfig = getDocsConfig(createDirectoryResponse.organization);
-        await (0, import_promises24.writeFile)(docsYmlPath, jsYaml.dump(docsConfig));
+        await (0, import_promises25.writeFile)(docsYmlPath, jsYaml.dump(docsConfig));
         taskContext.logger.info(source_default.green("Created docs configuration"));
         return;
       } catch (writeError) {
@@ -1434547,7 +1434873,7 @@ var FernDocsBuilder = class {
 };
 
 // ../docs-importers/commons/lib/FernDocsBuilderImpl.js
-var import_promises25 = require("fs/promises");
+var import_promises26 = require("fs/promises");
 var FernDocsBuilderImpl = class extends FernDocsBuilder {
   openApiSpecs = {};
   nonTabbedNavigation = new NonTabbedNavigationBuilderImpl();
@@ -1434606,7 +1434932,7 @@ var FernDocsBuilderImpl = class extends FernDocsBuilder {
   }
   async build({ outputDirectory }) {
     const absolutePathToFernDirectory = join2(outputDirectory, RelativeFilePath2.of(FERN_DIRECTORY));
-    await (0, import_promises25.mkdir)(absolutePathToFernDirectory, { recursive: true });
+    await (0, import_promises26.mkdir)(absolutePathToFernDirectory, { recursive: true });
     if (Object.keys(this.tabbedNavigation).length > 0) {
       this.docsYml.tabs = Object.fromEntries(Object.entries(this.tabbedNavigation).map(([key, value]) => {
         return [value.tabId, value.tabConfig];
@@ -1434631,27 +1434957,27 @@ var FernDocsBuilderImpl = class extends FernDocsBuilder {
           }))
         };
       }
-      await (0, import_promises25.writeFile)(join2(absolutePathToFernDirectory, RelativeFilePath2.of(GENERATORS_CONFIGURATION_FILENAME)), jsYaml.dump(generators_yml_exports.serialization.GeneratorsConfigurationSchema.jsonOrThrow(this.generatorsYml)));
+      await (0, import_promises26.writeFile)(join2(absolutePathToFernDirectory, RelativeFilePath2.of(GENERATORS_CONFIGURATION_FILENAME)), jsYaml.dump(generators_yml_exports.serialization.GeneratorsConfigurationSchema.jsonOrThrow(this.generatorsYml)));
       await Promise.all(Object.entries(this.openApiSpecs).map(async ([relativePath, absolutePath]) => {
         const absolutePathToOpenAPI = join2(absolutePathToFernDirectory, RelativeFilePath2.of(relativePath));
-        await (0, import_promises25.mkdir)(dirname4(absolutePathToOpenAPI), { recursive: true });
-        await (0, import_promises25.cp)(absolutePath, absolutePathToOpenAPI);
+        await (0, import_promises26.mkdir)(dirname4(absolutePathToOpenAPI), { recursive: true });
+        await (0, import_promises26.cp)(absolutePath, absolutePathToOpenAPI);
       }));
     }
-    await (0, import_promises25.writeFile)(join2(absolutePathToFernDirectory, RelativeFilePath2.of(DOCS_CONFIGURATION_FILENAME)), jsYaml.dump(docs_yml_exports.RawSchemas.Serializer.DocsConfiguration.jsonOrThrow(this.docsYml, { omitUndefined: true })));
+    await (0, import_promises26.writeFile)(join2(absolutePathToFernDirectory, RelativeFilePath2.of(DOCS_CONFIGURATION_FILENAME)), jsYaml.dump(docs_yml_exports.RawSchemas.Serializer.DocsConfiguration.jsonOrThrow(this.docsYml, { omitUndefined: true })));
     await Promise.all(Object.entries(this.markdownPages).map(async ([filepath, page]) => {
       const absoluteFilepathToMarkdownPage = join2(absolutePathToFernDirectory, RelativeFilePath2.of(filepath));
-      await (0, import_promises25.mkdir)(dirname4(absoluteFilepathToMarkdownPage), { recursive: true });
+      await (0, import_promises26.mkdir)(dirname4(absoluteFilepathToMarkdownPage), { recursive: true });
       const frontmatter = Object.keys(page.frontmatter).length > 0 ? `---
 ${jsYaml.dump(JSON.parse(JSON.stringify(page.frontmatter)))}---
 
 ` : "";
-      await (0, import_promises25.writeFile)(absoluteFilepathToMarkdownPage, `${frontmatter}${page.markdown}`);
+      await (0, import_promises26.writeFile)(absoluteFilepathToMarkdownPage, `${frontmatter}${page.markdown}`);
     }));
     await Promise.all(Object.entries(this.assets).map(async ([filepath, asset]) => {
       const absolutePathToAsset = join2(absolutePathToFernDirectory, RelativeFilePath2.of(filepath));
-      await (0, import_promises25.mkdir)(dirname4(absolutePathToAsset), { recursive: true });
-      await (0, import_promises25.cp)(asset.absoluteFilePathToAsset, absolutePathToAsset);
+      await (0, import_promises26.mkdir)(dirname4(absolutePathToAsset), { recursive: true });
+      await (0, import_promises26.cp)(asset.absoluteFilePathToAsset, absolutePathToAsset);
     }));
   }
   setInstance({ companyName }) {
@@ -1434683,7 +1435009,7 @@ var NonTabbedNavigationBuilderImpl = class {
 };
 
 // ../docs-importers/mintlify/lib/MintlifyImporter.js
-var import_promises27 = require("fs/promises");
+var import_promises28 = require("fs/promises");
 
 // ../docs-importers/mintlify/lib/convertColors.js
 function convertColors(colors19) {
@@ -1434737,10 +1435063,10 @@ function convertLogo({ logo, builder, absolutePathToMintJson }) {
 }
 
 // ../docs-importers/mintlify/lib/convertMarkdown.js
-var import_promises26 = require("fs/promises");
+var import_promises27 = require("fs/promises");
 var import_gray_matter2 = __toESM(require_gray_matter(), 1);
 async function convertMarkdown({ absolutePathToMintJson, absoluteFilepathToMarkdown, relativeFilepathFromRoot, builder }) {
-  const text9 = await (0, import_promises26.readFile)(absoluteFilepathToMarkdown, "utf-8");
+  const text9 = await (0, import_promises27.readFile)(absoluteFilepathToMarkdown, "utf-8");
   const { data: data2, content: content5 } = parseMintlifyFrontmatter(text9);
   const slug = relativeFilepathFromRoot.replace(/\.(md|mdx)$/, "");
   const transformedContent = markReferencedAssets({
@@ -1434903,7 +1435229,7 @@ var MintlifyImporter = class extends DocsImporter {
   documentationTab = void 0;
   tabUrlToInfo = {};
   async import({ args, builder }) {
-    const mintJsonContent = await (0, import_promises27.readFile)(args.absolutePathToMintJson, "utf-8");
+    const mintJsonContent = await (0, import_promises28.readFile)(args.absolutePathToMintJson, "utf-8");
     const mint = JSON.parse(mintJsonContent);
     builder.setTitle({ title: mint.name });
     const relativePathToFavicon = RelativeFilePath2.of(mint.favicon.substring(1));
@@ -1435028,7 +1435354,7 @@ var MintlifyImporter = class extends DocsImporter {
 };
 
 // ../docs-importers/mintlify/lib/runMintlifyMigration.js
-var import_promises28 = require("fs/promises");
+var import_promises29 = require("fs/promises");
 async function runMintlifyMigration({ absolutePathToMintJson, outputPath, taskContext, versionOfCli, organization }) {
   const mintlifyImporter = new MintlifyImporter({
     context: taskContext
@@ -1435039,7 +1435365,7 @@ async function runMintlifyMigration({ absolutePathToMintJson, outputPath, taskCo
     builder
   });
   await builder.build({ outputDirectory: outputPath });
-  await (0, import_promises28.writeFile)(join2(AbsoluteFilePath2.of(outputPath), RelativeFilePath2.of(FERN_DIRECTORY), RelativeFilePath2.of(PROJECT_CONFIG_FILENAME)), JSON.stringify({
+  await (0, import_promises29.writeFile)(join2(AbsoluteFilePath2.of(outputPath), RelativeFilePath2.of(FERN_DIRECTORY), RelativeFilePath2.of(PROJECT_CONFIG_FILENAME)), JSON.stringify({
     version: versionOfCli,
     organization
   }, void 0, 4));
@@ -1435284,7 +1435610,7 @@ function assertIsStringArray(val) {
 }
 
 // ../docs-importers/readme/lib/ReadmeImporter.js
-var import_promises33 = require("fs/promises");
+var import_promises34 = require("fs/promises");
 
 // ../docs-importers/readme/lib/extract/favicon.js
 async function getFavicon(hast) {
@@ -1475136,7 +1475462,7 @@ init_AsyncIterableUtil();
 init_disposable();
 
 // ../../../node_modules/.pnpm/puppeteer-core@24.23.0/node_modules/puppeteer-core/lib/esm/puppeteer/node/ChromeLauncher.js
-var import_promises31 = require("fs/promises");
+var import_promises32 = require("fs/promises");
 var import_node_os8 = __toESM(require("os"), 1);
 var import_node_path16 = __toESM(require("path"), 1);
 
@@ -1476552,7 +1476878,7 @@ var TimeoutError2 = class extends Error {
 var import_node_assert2 = __toESM(require("assert"), 1);
 var import_node_child_process3 = require("child_process");
 var import_node_fs10 = require("fs");
-var import_promises30 = require("fs/promises");
+var import_promises31 = require("fs/promises");
 var import_node_os6 = __toESM(require("os"), 1);
 var import_node_path14 = __toESM(require("path"), 1);
 var import_progress = __toESM(require_progress(), 1);
@@ -1476560,7 +1476886,7 @@ var import_progress = __toESM(require_progress(), 1);
 // ../../../node_modules/.pnpm/@puppeteer+browsers@2.10.10/node_modules/@puppeteer/browsers/lib/esm/fileUtil.js
 var import_node_child_process2 = require("child_process");
 var import_node_fs9 = require("fs");
-var import_promises29 = require("fs/promises");
+var import_promises30 = require("fs/promises");
 var path28 = __toESM(require("path"), 1);
 var import_node_stream3 = require("stream");
 var import_debug5 = __toESM(require_src(), 1);
@@ -1476994,7 +1477320,7 @@ var ChromeLauncher = class extends BrowserLauncher {
     });
     if (userDataDirIndex < 0) {
       isTempUserDataDir = true;
-      chromeArguments.push(`--user-data-dir=${await (0, import_promises31.mkdtemp)(this.getProfilePath())}`);
+      chromeArguments.push(`--user-data-dir=${await (0, import_promises32.mkdtemp)(this.getProfilePath())}`);
       userDataDirIndex = chromeArguments.length - 1;
     }
     const userDataDir = chromeArguments[userDataDirIndex].split("=", 2)[1];
@@ -1477158,7 +1477484,7 @@ function removeMatchingFlags(array2, flag) {
 
 // ../../../node_modules/.pnpm/puppeteer-core@24.23.0/node_modules/puppeteer-core/lib/esm/puppeteer/node/FirefoxLauncher.js
 var import_node_fs13 = __toESM(require("fs"), 1);
-var import_promises32 = require("fs/promises");
+var import_promises33 = require("fs/promises");
 var import_node_os9 = __toESM(require("os"), 1);
 var import_node_path17 = __toESM(require("path"), 1);
 init_util2();
@@ -1477211,7 +1477537,7 @@ var FirefoxLauncher = class _FirefoxLauncher extends BrowserLauncher {
       }
       isTempUserDataDir = false;
     } else {
-      userDataDir = await (0, import_promises32.mkdtemp)(this.getProfilePath());
+      userDataDir = await (0, import_promises33.mkdtemp)(this.getProfilePath());
       firefoxArguments.push("--profile");
       firefoxArguments.push(userDataDir);
     }
@@ -1477252,8 +1477578,8 @@ var FirefoxLauncher = class _FirefoxLauncher extends BrowserLauncher {
           const prefsBackupPath = import_node_path17.default.join(userDataDir, file2 + backupSuffix);
           if (import_node_fs13.default.existsSync(prefsBackupPath)) {
             const prefsPath = import_node_path17.default.join(userDataDir, file2);
-            await (0, import_promises32.unlink)(prefsPath);
-            await (0, import_promises32.rename)(prefsBackupPath, prefsPath);
+            await (0, import_promises33.unlink)(prefsPath);
+            await (0, import_promises33.rename)(prefsBackupPath, prefsPath);
           }
         }));
         for (const result of results) {
@@ -1478285,7 +1478611,7 @@ var ReadmeImporter = class extends DocsImporter {
       if (response.ok) {
         const imageBuffer = Buffer.from(await response.arrayBuffer());
         const faviconPath = join2(assetsDirectory, RelativeFilePath2.of("favicon"));
-        await (0, import_promises33.writeFile)(faviconPath, new Uint8Array(imageBuffer));
+        await (0, import_promises34.writeFile)(faviconPath, new Uint8Array(imageBuffer));
         builder.setFavicon({ favicon: relativize(this.absolutePathToFernDirectory, faviconPath) });
       }
     }
@@ -1478302,7 +1478628,7 @@ var ReadmeImporter = class extends DocsImporter {
    */
   async getAndCreateAssetsDirectory() {
     const assetsDirectory = join2(this.absolutePathToFernDirectory, RelativeFilePath2.of("assets"));
-    await (0, import_promises33.mkdir)(assetsDirectory, { recursive: true });
+    await (0, import_promises34.mkdir)(assetsDirectory, { recursive: true });
     return assetsDirectory;
   }
   /**
@@ -1478352,7 +1478678,7 @@ var ReadmeImporter = class extends DocsImporter {
         absolutePathToOutputDirectory,
         section
       });
-      await (0, import_promises33.mkdir)(absolutePathToOutputDirectoryForSection, { recursive: true });
+      await (0, import_promises34.mkdir)(absolutePathToOutputDirectoryForSection, { recursive: true });
       await Promise.all(section.pages.filter((page) => page.type === "page").map(async (page) => {
         const url3 = new URL(page.slug.toString(), this.url);
         this.logger.debug(`Fetching page: ${url3.toString()}`);
@@ -1478367,7 +1478693,7 @@ var ReadmeImporter = class extends DocsImporter {
             absolutePathToOutputDirectoryForSection,
             page: page.slug
           });
-          await (0, import_promises33.writeFile)(absolutePathForPage, result.data.mdx);
+          await (0, import_promises34.writeFile)(absolutePathForPage, result.data.mdx);
           if (result.data.images.imageURLs.length > 0) {
             this.logger.debug(`Found ${result.data.images.imageURLs.length} images to download for ${url3.toString()}`);
             await Promise.all(Object.entries(result.data.images.imageURLToFilename).map(async ([imageUrl, filename]) => {
@@ -1478380,8 +1478706,8 @@ var ReadmeImporter = class extends DocsImporter {
                 const imageBuffer = Buffer.from(await response.arrayBuffer());
                 const imagePath = join2(absolutePathToOutputDirectoryForSection, RelativeFilePath2.of(filename));
                 const imageDir = dirname4(imagePath);
-                await (0, import_promises33.mkdir)(imageDir, { recursive: true });
-                await (0, import_promises33.writeFile)(imagePath, new Uint8Array(imageBuffer));
+                await (0, import_promises34.mkdir)(imageDir, { recursive: true });
+                await (0, import_promises34.writeFile)(imagePath, new Uint8Array(imageBuffer));
                 this.logger.debug(`Saved image to ${imagePath}`);
               } catch (error49) {
                 this.logger.warn(`Error downloading image ${imageUrl}: ${error49}`);
@@ -1478463,7 +1478789,7 @@ var ReadmeImporter = class extends DocsImporter {
 };
 
 // ../docs-importers/readme/lib/runReadmeMigration.js
-var import_promises34 = require("fs/promises");
+var import_promises35 = require("fs/promises");
 async function runReadmeMigration({ readmeUrl, outputPath, taskContext, versionOfCli, organization }) {
   const builder = new FernDocsBuilderImpl();
   builder.setInstance({ companyName: organization });
@@ -1478478,7 +1478804,7 @@ async function runReadmeMigration({ readmeUrl, outputPath, taskContext, versionO
     builder
   });
   await builder.build({ outputDirectory: outputPath });
-  await (0, import_promises34.writeFile)(join2(AbsoluteFilePath2.of(outputPath), RelativeFilePath2.of(FERN_DIRECTORY), RelativeFilePath2.of(PROJECT_CONFIG_FILENAME)), JSON.stringify({
+  await (0, import_promises35.writeFile)(join2(AbsoluteFilePath2.of(outputPath), RelativeFilePath2.of(FERN_DIRECTORY), RelativeFilePath2.of(PROJECT_CONFIG_FILENAME)), JSON.stringify({
     version: versionOfCli,
     organization
   }, void 0, 4));
@@ -1498096,7 +1498422,7 @@ var AbstractConverter = class _AbstractConverter {
 };
 
 // ../api-importers/v3-importer-commons/lib/ErrorCollector.js
-var import_promises35 = require("fs/promises");
+var import_promises36 = require("fs/promises");
 
 // ../../../node_modules/.pnpm/js-yaml-source-map@0.2.2_js-yaml@4.1.1/node_modules/js-yaml-source-map/dist/esm/index.js
 var SourceMap = class {
@@ -1498383,7 +1498709,7 @@ var BreadcrumbToLineNumber = class {
       return;
     }
     try {
-      const fileContent = await (0, import_promises35.readFile)(this.relativePathToFile, "utf-8");
+      const fileContent = await (0, import_promises36.readFile)(this.relativePathToFile, "utf-8");
       jsYaml.load(fileContent, { listener: this.map.listen() });
       this.initialized = true;
     } catch (error49) {
@@ -1505104,7 +1505430,7 @@ Yargs2.Parser = Parser5;
 var yargs_default2 = Yargs2;
 
 // ../init/src/utils/loadOpenApiFromUrl.ts
-var import_promises36 = require("fs/promises");
+var import_promises37 = require("fs/promises");
 var import_path24 = require("path");
 var import_tmp_promise3 = __toESM(require_tmp_promise(), 1);
 async function loadOpenAPIFromUrl({ url: url3, logger }) {
@@ -1505114,7 +1505440,7 @@ async function loadOpenAPIFromUrl({ url: url3, logger }) {
     const filePath = (0, import_path24.join)(tmpDir.path, url3.endsWith(".json") ? "openapi.json" : "openapi.yaml");
     logger.debug("tmpDir", tmpDir.path);
     logger.debug("filePath", filePath);
-    await (0, import_promises36.writeFile)(filePath, data2);
+    await (0, import_promises37.writeFile)(filePath, data2);
     return {
       status: "success" /* Success */,
       filePath
@@ -1508406,7 +1508732,7 @@ var CliContext = class {
     if (false) {
       this.logger.error("CLI_VERSION is not defined");
     }
-    return "3.47.3";
+    return "3.47.4";
   }
   getCliName() {
     if (false) {
@@ -1537781,7 +1538107,7 @@ __export(types_exports10, {
 });
 
 // ../api-importers/conjure/conjure-to-fern/lib/utils/listConjureFiles.js
-var import_promises37 = require("fs/promises");
+var import_promises38 = require("fs/promises");
 async function listConjureFiles(root6, extensionGlob) {
   const files = [];
   for (const absoluteFilepath of await listFiles(root6, extensionGlob)) {
@@ -1537793,7 +1538119,7 @@ async function listConjureFiles(root6, extensionGlob) {
   return files;
 }
 async function createConjureFile({ relativeFilepath, absoluteFilepath }) {
-  const rawContents = (await (0, import_promises37.readFile)(absoluteFilepath)).toString().replaceAll(/: rid(?:$|\s)/g, ": string\n").replaceAll("<rid>", "<string>").replaceAll("rid>", "string>").replaceAll(": safelong", ": long").replaceAll("<safelong>", "<long>").replaceAll("safelong>", "long>").replaceAll(": any", ": unknown").replaceAll("<any>", "<unknown>").replaceAll("any>", "unknown>");
+  const rawContents = (await (0, import_promises38.readFile)(absoluteFilepath)).toString().replaceAll(/: rid(?:$|\s)/g, ": string\n").replaceAll("<rid>", "<string>").replaceAll("rid>", "string>").replaceAll(": safelong", ": long").replaceAll("<safelong>", "<long>").replaceAll("safelong>", "long>").replaceAll(": any", ": unknown").replaceAll("<any>", "<unknown>").replaceAll("any>", "unknown>");
   return {
     relativeFilepath,
     absoluteFilepath,
@@ -1538295,7 +1538621,7 @@ function parseZodIssue(issue2) {
 }
 
 // ../workspace/lazy-fern-workspace/lib/utils/listFernFiles.js
-var import_promises38 = require("fs/promises");
+var import_promises39 = require("fs/promises");
 async function listFernFiles(root6, extensionGlob) {
   const files = [];
   for (const absoluteFilepath of await listFiles(root6, extensionGlob)) {
@@ -1538310,7 +1538636,7 @@ async function createFernFile({ relativeFilepath, absoluteFilepath }) {
   return {
     relativeFilepath,
     absoluteFilepath,
-    fileContents: (await (0, import_promises38.readFile)(absoluteFilepath)).toString()
+    fileContents: (await (0, import_promises39.readFile)(absoluteFilepath)).toString()
   };
 }
 
@@ -1538351,10 +1538677,10 @@ async function parseYamlFiles(files) {
 // ../workspace/lazy-fern-workspace/lib/utils/loadDependency.js
 var import_fiddle_sdk3 = __toESM(require_fiddle_sdk(), 1);
 var import_fs16 = require("fs");
-var import_promises40 = require("fs/promises");
+var import_promises41 = require("fs/promises");
 var import_os3 = require("os");
 var import_path29 = __toESM(require("path"), 1);
-var import_promises41 = require("stream/promises");
+var import_promises42 = require("stream/promises");
 
 // ../../../node_modules/.pnpm/@isaacs+fs-minipass@4.0.1/node_modules/@isaacs/fs-minipass/dist/esm/index.js
 var import_events10 = __toESM(require("events"), 1);
@@ -1542001,7 +1542327,7 @@ var chownrSync = (p9, uid, gid) => {
 
 // ../../../node_modules/.pnpm/tar@7.5.3/node_modules/tar/dist/esm/mkdir.js
 var import_node_fs19 = __toESM(require("fs"), 1);
-var import_promises39 = __toESM(require("fs/promises"), 1);
+var import_promises40 = __toESM(require("fs/promises"), 1);
 var import_node_path27 = __toESM(require("path"), 1);
 
 // ../../../node_modules/.pnpm/tar@7.5.3/node_modules/tar/dist/esm/cwd-error.js
@@ -1542072,7 +1542398,7 @@ var mkdir11 = (dir, opt, cb2) => {
     return checkCwd(dir, done);
   }
   if (preserve) {
-    return import_promises39.default.mkdir(dir, { mode, recursive: true }).then(
+    return import_promises40.default.mkdir(dir, { mode, recursive: true }).then(
       (made) => done(null, made ?? void 0),
       // oh, ts
       done
@@ -1543391,7 +1543717,7 @@ async function validateVersionedDependencyAndGetDefinition({ dependency, context
     }
     context2.logger.info("Downloading...");
     context2.logger.debug("Remote URL: " + response.body.definitionS3DownloadUrl);
-    await (0, import_promises40.mkdir)(pathToDefinition, { recursive: true });
+    await (0, import_promises41.mkdir)(pathToDefinition, { recursive: true });
     try {
       await downloadDependency({
         s3PreSignedReadUrl: response.body.definitionS3DownloadUrl,
@@ -1543402,9 +1543728,9 @@ async function validateVersionedDependencyAndGetDefinition({ dependency, context
       return void 0;
     }
     metadata = response.body;
-    await (0, import_promises40.writeFile)(pathToMetadata, JSON.stringify(metadata));
+    await (0, import_promises41.writeFile)(pathToMetadata, JSON.stringify(metadata));
   } else {
-    metadata = JSON.parse((await (0, import_promises40.readFile)(pathToMetadata)).toString());
+    metadata = JSON.parse((await (0, import_promises41.readFile)(pathToMetadata)).toString());
   }
   context2.logger.info("Parsing...");
   if (loadAPIWorkspace2 == null) {
@@ -1543434,7 +1543760,7 @@ async function downloadDependency({ s3PreSignedReadUrl, absolutePathToLocalOutpu
   });
   const tmpDir = await import_tmp_promise4.default.dir();
   const outputTarPath = import_path29.default.join(tmpDir.path, "api.tgz");
-  await (0, import_promises41.pipeline)(request6.data, (0, import_fs16.createWriteStream)(outputTarPath));
+  await (0, import_promises42.pipeline)(request6.data, (0, import_fs16.createWriteStream)(outputTarPath));
   await extract({ file: outputTarPath, cwd: absolutePathToLocalOutput });
 }
 function stringifyDependency(dependency) {
@@ -1552888,7 +1553214,7 @@ var LazyFernWorkspace = class extends AbstractAPIWorkspace {
 };
 
 // ../workspace/lazy-fern-workspace/lib/loaders/OpenAPILoader.js
-var import_promises46 = require("fs/promises");
+var import_promises47 = require("fs/promises");
 
 // ../workspace/lazy-fern-workspace/lib/utils/convertOpenAPIV2ToV3.js
 var import_swagger2openapi = __toESM(require_swagger2openapi(), 1);
@@ -1552898,14 +1553224,14 @@ async function convertOpenAPIV2ToV3(openAPI) {
 }
 
 // ../workspace/lazy-fern-workspace/lib/utils/loadAsyncAPI.js
-var import_promises43 = require("fs/promises");
+var import_promises44 = require("fs/promises");
 
 // ../workspace/lazy-fern-workspace/lib/loaders/mergeWithOverrides.js
-var import_promises42 = require("fs/promises");
+var import_promises43 = require("fs/promises");
 async function mergeWithOverrides2({ absoluteFilePathToOverrides, data: data2, context: context2, allowNullKeys }) {
   let parsedOverrides = null;
   try {
-    const contents = (await (0, import_promises42.readFile)(absoluteFilePathToOverrides, "utf8")).toString();
+    const contents = (await (0, import_promises43.readFile)(absoluteFilePathToOverrides, "utf8")).toString();
     try {
       parsedOverrides = JSON.parse(contents);
     } catch (err) {
@@ -1552919,7 +1553245,7 @@ async function mergeWithOverrides2({ absoluteFilePathToOverrides, data: data2, c
 
 // ../workspace/lazy-fern-workspace/lib/utils/loadAsyncAPI.js
 async function loadAsyncAPI({ context: context2, absoluteFilePath, absoluteFilePathToOverrides }) {
-  const contents = (await (0, import_promises43.readFile)(absoluteFilePath)).toString();
+  const contents = (await (0, import_promises44.readFile)(absoluteFilePath)).toString();
   const parsed = await jsYaml.load(contents);
   if (absoluteFilePathToOverrides != null) {
     return await mergeWithOverrides2({
@@ -1552932,10 +1553258,10 @@ async function loadAsyncAPI({ context: context2, absoluteFilePath, absoluteFileP
 }
 
 // ../workspace/lazy-fern-workspace/lib/utils/loadOpenAPI.js
-var import_promises45 = require("fs/promises");
+var import_promises46 = require("fs/promises");
 
 // ../workspace/lazy-fern-workspace/lib/loaders/applyOverlays.js
-var import_promises44 = require("fs/promises");
+var import_promises45 = require("fs/promises");
 var import_path31 = __toESM(require("path"), 1);
 var import_tmp_promise5 = __toESM(require_tmp_promise(), 1);
 var tempDir;
@@ -1552960,14 +1553286,14 @@ async function applyOverlays({ absoluteFilePathToOverlay, absoluteFilePathToOpen
   const originalFileName = import_path31.default.basename(absoluteFilePathToOpenAPI);
   const outputFileName = `${import_path31.default.parse(originalFileName).name}.overlaid.json`;
   const outputPath = import_path31.default.join(dir, outputFileName);
-  await (0, import_promises44.writeFile)(outputPath, JSON.stringify(result, null, 2), "utf8");
+  await (0, import_promises45.writeFile)(outputPath, JSON.stringify(result, null, 2), "utf8");
   context2.logger.info(`Wrote overlaid OpenAPI spec to: ${outputPath}`);
   return result;
 }
 async function parseOverlayFile(absoluteFilePathToOverlay, context2) {
   let contents;
   try {
-    contents = await (0, import_promises44.readFile)(absoluteFilePathToOverlay, "utf8");
+    contents = await (0, import_promises45.readFile)(absoluteFilePathToOverlay, "utf8");
   } catch (err) {
     return context2.failAndThrow(`Failed to read overlay file at ${absoluteFilePathToOverlay}: ${err}`);
   }
@@ -1553122,7 +1553448,7 @@ async function loadOpenAPI({ context: context2, absolutePathToOpenAPI, absoluteP
   if (loadAiExamples) {
     const aiExamplesOverrideFilepath = join2(dirname4(absolutePathToOpenAPI), RelativeFilePath2.of("ai_examples_override.yml"));
     try {
-      const overrideContent = await (0, import_promises45.readFile)(aiExamplesOverrideFilepath, "utf-8");
+      const overrideContent = await (0, import_promises46.readFile)(aiExamplesOverrideFilepath, "utf-8");
       const overrideData = jsYaml.load(overrideContent);
       if (overrideData?.paths && result.paths) {
         for (const [path76, methods] of Object.entries(overrideData.paths)) {
@@ -1553177,7 +1553503,7 @@ var OpenAPILoader = class {
     const documents = [];
     for (const spec of specs) {
       try {
-        const contents = (await (0, import_promises46.readFile)(spec.absoluteFilepath)).toString();
+        const contents = (await (0, import_promises47.readFile)(spec.absoluteFilepath)).toString();
         let sourceRelativePath = relative3(this.absoluteFilePath, spec.source.file);
         if (spec.source.relativePathToDependency != null) {
           sourceRelativePath = join2(spec.source.relativePathToDependency, sourceRelativePath);
@@ -1557877,7 +1558203,7 @@ var OpenRPCConverterContext3_1 = class extends AbstractConverterContext {
 };
 
 // ../workspace/lazy-fern-workspace/lib/OSSWorkspace.js
-var import_promises50 = require("fs/promises");
+var import_promises51 = require("fs/promises");
 
 // ../../commons/casings-generator/src/reserved.ts
 var RESERVED_KEYWORDS2 = {
@@ -1558638,9 +1558964,9 @@ function preprocessName2(name3) {
 }
 
 // ../workspace/lazy-fern-workspace/lib/utils/loadOpenRpc.js
-var import_promises47 = require("fs/promises");
+var import_promises48 = require("fs/promises");
 async function loadOpenRpc({ context: context2, absoluteFilePath, absoluteFilePathToOverrides }) {
-  const contents = (await (0, import_promises47.readFile)(absoluteFilePath)).toString();
+  const contents = (await (0, import_promises48.readFile)(absoluteFilePath)).toString();
   let parsed;
   try {
     parsed = JSON.parse(contents);
@@ -1558693,7 +1559019,7 @@ function createLoggingExecutable(executable, { logger, ...loggingExecaOptions }
 }
 
 // ../workspace/lazy-fern-workspace/lib/protobuf/ProtobufIRGenerator.js
-var import_promises48 = require("fs/promises");
+var import_promises49 = require("fs/promises");
 var import_path35 = __toESM(require("path"), 1);
 var import_tmp_promise7 = __toESM(require_tmp_promise(), 1);
 
@@ -1558849,7 +1559175,7 @@ var ProtobufIRGenerator = class {
       this.context.logger.info(`Using buf export with version: ${version7}`);
       const tmpBufConfigFile = await import_tmp_promise7.default.file({ postfix: ".yaml" });
       const configContent = version7 === "v1" ? PROTOBUF_EXPORT_CONFIG_V1 : PROTOBUF_EXPORT_CONFIG_V2;
-      await (0, import_promises48.writeFile)(tmpBufConfigFile.path, configContent, "utf8");
+      await (0, import_promises49.writeFile)(tmpBufConfigFile.path, configContent, "utf8");
       try {
         const result = await runExeca(this.context.logger, "buf", [
           "export",
@@ -1558878,7 +1559204,7 @@ var ProtobufIRGenerator = class {
     }
   }
   async copyProtobufFilesFromRoot({ protobufGeneratorConfigPath, absoluteFilepathToProtobufRoot }) {
-    await (0, import_promises48.cp)(absoluteFilepathToProtobufRoot, protobufGeneratorConfigPath, {
+    await (0, import_promises49.cp)(absoluteFilepathToProtobufRoot, protobufGeneratorConfigPath, {
       recursive: true,
       filter: (src) => {
         const basename6 = import_path35.default.basename(src);
@@ -1558887,7 +1559213,7 @@ var ProtobufIRGenerator = class {
     });
   }
   async setupRemainingProtobufConfig({ protobufGeneratorConfigPath }) {
-    await (0, import_promises48.writeFile)(join2(protobufGeneratorConfigPath, RelativeFilePath2.of("package.json")), PROTOBUF_MODULE_PACKAGE_JSON);
+    await (0, import_promises49.writeFile)(join2(protobufGeneratorConfigPath, RelativeFilePath2.of("package.json")), PROTOBUF_MODULE_PACKAGE_JSON);
     await runExeca(void 0, "npm", ["install"], {
       cwd: protobufGeneratorConfigPath,
       stdout: "ignore",
@@ -1558898,10 +1559224,10 @@ var ProtobufIRGenerator = class {
       stdout: "ignore",
       stderr: "pipe"
     });
-    await (0, import_promises48.writeFile)(join2(protobufGeneratorConfigPath, RelativeFilePath2.of(PROTOBUF_GENERATOR_CONFIG_FILENAME)), PROTOBUF_GEN_CONFIG);
+    await (0, import_promises49.writeFile)(join2(protobufGeneratorConfigPath, RelativeFilePath2.of(PROTOBUF_GENERATOR_CONFIG_FILENAME)), PROTOBUF_GEN_CONFIG);
     const shellProxyPath = join2(protobufGeneratorConfigPath, RelativeFilePath2.of(PROTOBUF_SHELL_PROXY_FILENAME));
-    await (0, import_promises48.writeFile)(shellProxyPath, PROTOBUF_SHELL_PROXY);
-    await (0, import_promises48.chmod)(shellProxyPath, 493);
+    await (0, import_promises49.writeFile)(shellProxyPath, PROTOBUF_SHELL_PROXY);
+    await (0, import_promises49.chmod)(shellProxyPath, 493);
   }
   async doGenerateLocal({ cwd: cwd2, deps }) {
     const which = createLoggingExecutable("which", {
@@ -1558923,13 +1559249,13 @@ var ProtobufIRGenerator = class {
       stderr: "pipe"
     });
     try {
-      await (0, import_promises48.writeFile)(bufYamlPath, configContent);
+      await (0, import_promises49.writeFile)(bufYamlPath, configContent);
       if (deps.length > 0) {
         if (this.isAirGapped) {
           this.context.logger.debug("Air-gapped mode: skipping buf dep update");
           const bufLockPath = join2(cwd2, RelativeFilePath2.of("buf.lock"));
           try {
-            await (0, import_promises48.access)(bufLockPath);
+            await (0, import_promises49.access)(bufLockPath);
           } catch {
             this.context.failAndThrow("Air-gapped mode requires a pre-cached buf.lock file. Please run 'buf dep update' at build time to cache dependencies.");
           }
@@ -1558941,9 +1559267,9 @@ var ProtobufIRGenerator = class {
       if (bufGenerateResult.exitCode !== 0) {
         this.context.failAndThrow(bufGenerateResult.stderr);
       }
-      await (0, import_promises48.unlink)(bufYamlPath);
+      await (0, import_promises49.unlink)(bufYamlPath);
     } catch (error49) {
-      await (0, import_promises48.unlink)(bufYamlPath);
+      await (0, import_promises49.unlink)(bufYamlPath);
       throw error49;
     }
     return join2(cwd2, RelativeFilePath2.of(PROTOBUF_GENERATOR_OUTPUT_FILEPATH));
@@ -1558954,7 +1559280,7 @@ var ProtobufIRGenerator = class {
 };
 
 // ../workspace/lazy-fern-workspace/lib/protobuf/ProtobufOpenAPIGenerator.js
-var import_promises49 = require("fs/promises");
+var import_promises50 = require("fs/promises");
 var import_tmp_promise8 = __toESM(require_tmp_promise(), 1);
 var PROTOBUF_GENERATOR_CONFIG_FILENAME2 = "buf.gen.yaml";
 var PROTOBUF_GENERATOR_OUTPUT_PATH2 = "output";
@@ -1558995,8 +1559321,8 @@ var ProtobufOpenAPIGenerator = class {
   }
   async setupProtobufGeneratorConfig({ absoluteFilepathToProtobufRoot, relativeFilepathToProtobufRoot }) {
     const protobufGeneratorConfigPath = AbsoluteFilePath2.of((await import_tmp_promise8.default.dir()).path);
-    await (0, import_promises49.cp)(absoluteFilepathToProtobufRoot, protobufGeneratorConfigPath, { recursive: true });
-    await (0, import_promises49.writeFile)(join2(protobufGeneratorConfigPath, RelativeFilePath2.of(PROTOBUF_GENERATOR_CONFIG_FILENAME2)), getProtobufGeneratorConfig({ relativeFilepathToProtobufRoot }));
+    await (0, import_promises50.cp)(absoluteFilepathToProtobufRoot, protobufGeneratorConfigPath, { recursive: true });
+    await (0, import_promises50.writeFile)(join2(protobufGeneratorConfigPath, RelativeFilePath2.of(PROTOBUF_GENERATOR_CONFIG_FILENAME2)), getProtobufGeneratorConfig({ relativeFilepathToProtobufRoot }));
     return protobufGeneratorConfigPath;
   }
   async doGenerateLocal({ cwd: cwd2, target, deps, existingBufLockContents }) {
@@ -1559027,15 +1559353,15 @@ var ProtobufOpenAPIGenerator = class {
       stderr: "pipe"
     });
     try {
-      await (0, import_promises49.writeFile)(bufYamlPath, configContent);
+      await (0, import_promises50.writeFile)(bufYamlPath, configContent);
       if (existingBufLockContents != null) {
-        await (0, import_promises49.writeFile)(bufLockPath, existingBufLockContents);
+        await (0, import_promises50.writeFile)(bufLockPath, existingBufLockContents);
         cleanupBufLock = true;
       } else if (deps.length > 0) {
         if (this.isAirGapped) {
           this.context.logger.debug("Air-gapped mode: skipping buf dep update");
           try {
-            await (0, import_promises49.access)(bufLockPath);
+            await (0, import_promises50.access)(bufLockPath);
           } catch {
             this.context.failAndThrow("Air-gapped mode requires a pre-cached buf.lock file. Please run 'buf dep update' at build time to cache dependencies.");
           }
@@ -1559043,7 +1559369,7 @@ var ProtobufOpenAPIGenerator = class {
           await buf(["dep", "update"]);
         }
         try {
-          bufLockContents = await (0, import_promises49.readFile)(bufLockPath, "utf-8");
+          bufLockContents = await (0, import_promises50.readFile)(bufLockPath, "utf-8");
         } catch {
           bufLockContents = void 0;
         }
@@ -1559053,14 +1559379,14 @@ var ProtobufOpenAPIGenerator = class {
         this.context.failAndThrow(bufGenerateResult.stderr);
       }
       if (cleanupBufLock) {
-        await (0, import_promises49.unlink)(bufLockPath);
+        await (0, import_promises50.unlink)(bufLockPath);
       }
-      await (0, import_promises49.unlink)(bufYamlPath);
+      await (0, import_promises50.unlink)(bufYamlPath);
     } catch (error49) {
       if (cleanupBufLock) {
-        await (0, import_promises49.unlink)(bufLockPath);
+        await (0, import_promises50.unlink)(bufLockPath);
       }
-      await (0, import_promises49.unlink)(bufYamlPath);
+      await (0, import_promises50.unlink)(bufYamlPath);
       throw error49;
     }
     return {
@@ -1559361,7 +1559687,7 @@ var OSSWorkspace = class _OSSWorkspace extends BaseOpenAPIWorkspace {
             local: true,
             deps: spec.dependencies
           });
-          const result = await (0, import_promises50.readFile)(protobufIRFilepath, "utf-8");
+          const result = await (0, import_promises51.readFile)(protobufIRFilepath, "utf-8");
           const casingsGenerator = constructCasingsGenerator2({
             generationLanguage: "typescript",
             keywords: void 0,
@@ -1559618,7 +1559944,7 @@ function parseIssue(issue2) {
 }
 
 // ../workspace/loader/lib/listFernFiles.js
-var import_promises51 = require("fs/promises");
+var import_promises52 = require("fs/promises");
 async function listFernFiles2(root6, extensionGlob) {
   const files = [];
   for (const absoluteFilepath of await listFiles(root6, extensionGlob)) {
@@ -1559633,7 +1559959,7 @@ async function createFernFile2({ relativeFilepath, absoluteFilepath }) {
   return {
     relativeFilepath,
     absoluteFilepath,
-    fileContents: (await (0, import_promises51.readFile)(absoluteFilepath)).toString()
+    fileContents: (await (0, import_promises52.readFile)(absoluteFilepath)).toString()
   };
 }
 
@@ -1559885,7 +1560211,7 @@ async function loadAPIWorkspace({ absolutePathToWorkspace, context: context2, cl
 }
 
 // ../workspace/loader/lib/loadDocsWorkspace.js
-var import_promises52 = require("fs/promises");
+var import_promises53 = require("fs/promises");
 
 // ../workspace/loader/lib/docs-yml.schema.json
 var docs_yml_schema_exports = {};
@@ -1565063,7 +1565389,7 @@ async function loadDocsConfiguration({ absolutePathToDocsDefinition, context: co
   });
 }
 async function loadRawDocsConfiguration({ absolutePathOfConfiguration, context: context2 }) {
-  const contentsStr = await (0, import_promises52.readFile)(absolutePathOfConfiguration);
+  const contentsStr = await (0, import_promises53.readFile)(absolutePathOfConfiguration);
   const contentsJson = jsYaml.load(contentsStr.toString());
   const result = validateAgainstJsonSchema(contentsJson, docs_yml_schema_exports, {
     filePath: absolutePathOfConfiguration
@@ -1565092,7 +1565418,7 @@ ${result.error?.message ?? "Unknown error"}`);
 }
 
 // ../project-loader/lib/loadProject.js
-var import_promises53 = require("fs/promises");
+var import_promises54 = require("fs/promises");
 async function loadProject({ context: context2, nameOverride, ...args }) {
   const fernDirectory = await getFernDirectory(nameOverride);
   if (fernDirectory == null) {
@@ -1565147,7 +1565473,7 @@ async function loadApis({ cliName, fernDirectory, context: context2, cliVersion,
   const apisDirectory = join2(fernDirectory, RelativeFilePath2.of(APIS_DIRECTORY));
   const apisDirectoryExists = await doesPathExist(apisDirectory);
   if (apisDirectoryExists) {
-    const apiDirectoryContents = await (0, import_promises53.readdir)(apisDirectory, { withFileTypes: true });
+    const apiDirectoryContents = await (0, import_promises54.readdir)(apisDirectory, { withFileTypes: true });
     const apiWorkspaceDirectoryNames = apiDirectoryContents.reduce((all9, item) => {
       if (item.isDirectory()) {
         all9.push(item.name);
@@ -1565224,10 +1565550,10 @@ async function loadProjectAndRegisterWorkspacesWithContext(cliContext, args, reg
 
 // src/cliV2.ts
 var import_generators_sdk4 = __toESM(require_generators_sdk(), 1);
-var import_promises58 = require("fs/promises");
+var import_promises59 = require("fs/promises");
 
 // src/commands/generator-list/getGeneratorList.ts
-var import_promises54 = require("fs/promises");
+var import_promises55 = require("fs/promises");
 var GenerationModeFilter = {
   GitHub: "github",
   Local: "local-file-system",
@@ -1565287,7 +1565613,7 @@ async function getGeneratorList({
     return;
   }
   try {
-    await (0, import_promises54.writeFile)(outputLocation, generatorsListYaml);
+    await (0, import_promises55.writeFile)(outputLocation, generatorsListYaml);
   } catch (error49) {
     cliContext.failAndThrow(`Could not write file to the specified location: ${outputLocation}`, error49);
   }
@@ -1565353,7 +1565679,7 @@ async function getGeneratorMetadata({
 }
 
 // src/commands/organization/getOrganization.ts
-var import_promises55 = require("fs/promises");
+var import_promises56 = require("fs/promises");
 async function getOrganization({
   project,
   outputLocation,
@@ -1565365,20 +1565691,20 @@ async function getOrganization({
     return;
   }
   try {
-    await (0, import_promises55.writeFile)(outputLocation, org);
+    await (0, import_promises56.writeFile)(outputLocation, org);
   } catch (error49) {
     context2.failAndThrow(`Could not write file to the specified location: ${outputLocation}`, error49);
   }
 }
 
 // src/commands/upgrade/upgradeGenerator.ts
-var import_promises57 = require("fs/promises");
+var import_promises58 = require("fs/promises");
 var import_path37 = __toESM(require("path"), 1);
 var import_semver8 = __toESM(require_semver2(), 1);
-var import_yaml3 = __toESM(require_dist(), 1);
+var import_yaml4 = __toESM(require_dist(), 1);
 
 // src/commands/upgrade/migrations/loader.ts
-var import_promises56 = require("fs/promises");
+var import_promises57 = require("fs/promises");
 var import_os4 = require("os");
 var import_path36 = require("path");
 var import_semver7 = __toESM(require_semver2(), 1);
@@ -1565389,7 +1565715,7 @@ function getMigrationCacheDir() {
 async function loadMigrationModule(params2) {
   const { generatorName, logger } = params2;
   const cacheDir = getMigrationCacheDir();
-  await (0, import_promises56.mkdir)(cacheDir, { recursive: true });
+  await (0, import_promises57.mkdir)(cacheDir, { recursive: true });
   try {
     await loggingExeca(logger, "npm", [
       "install",
@@ -1565402,7 +1565728,7 @@ async function loadMigrationModule(params2) {
     ]);
     const packageDir = (0, import_path36.join)(cacheDir, "node_modules", MIGRATION_PACKAGE_NAME);
     const packageJsonPath = (0, import_path36.join)(packageDir, "package.json");
-    const packageJsonContent = await (0, import_promises56.readFile)(packageJsonPath, "utf-8");
+    const packageJsonContent = await (0, import_promises57.readFile)(packageJsonPath, "utf-8");
     const packageJson2 = JSON.parse(packageJsonContent);
     if (packageJson2.main == null) {
       throw new Error(`No main field found in package.json for ${MIGRATION_PACKAGE_NAME}`);
@@ -1565553,15 +1565879,15 @@ async function loadAndUpdateGenerators({
     context2.logger.debug("Generators configuration file was not found, no generators to upgrade.");
     return { updatedConfiguration: void 0, skippedMajorUpgrades: [], appliedUpgrades: [], alreadyUpToDate: [] };
   }
-  const contents = await (0, import_promises57.readFile)(filepath);
+  const contents = await (0, import_promises58.readFile)(filepath);
   context2.logger.debug(`Found generators: ${contents.toString()}`);
-  const parsedDocument = import_yaml3.default.parseDocument(contents.toString());
+  const parsedDocument = import_yaml4.default.parseDocument(contents.toString());
   const generatorGroups = parsedDocument.get("groups");
   if (generatorGroups == null) {
     context2.logger.debug("No groups were found within the generators configuration, no generators to upgrade.");
     return { updatedConfiguration: void 0, skippedMajorUpgrades: [], appliedUpgrades: [], alreadyUpToDate: [] };
   }
-  if (!import_yaml3.default.isMap(generatorGroups)) {
+  if (!import_yaml4.default.isMap(generatorGroups)) {
     context2.failAndThrow(`Expected 'groups' to be a map in ${import_path37.default.relative(process.cwd(), filepath)}`);
     return { updatedConfiguration: void 0, skippedMajorUpgrades: [], appliedUpgrades: [], alreadyUpToDate: [] };
   }
@@ -1565572,7 +1565898,7 @@ async function loadAndUpdateGenerators({
   for (const groupBlock of generatorGroups.items) {
     const groupName = groupBlock.key.value;
     const group = groupBlock.value;
-    if (!import_yaml3.default.isMap(group)) {
+    if (!import_yaml4.default.isMap(group)) {
       context2.failAndThrow(
         `Expected group ${groupName} to be a map in ${import_path37.default.relative(process.cwd(), filepath)}`
       );
@@ -1565583,7 +1565909,7 @@ async function loadAndUpdateGenerators({
       continue;
     }
     const generators = group.get("generators");
-    if (!import_yaml3.default.isSeq(generators)) {
+    if (!import_yaml4.default.isSeq(generators)) {
       context2.failAndThrow(
         `Expected group ${groupName} to have a 'generators' key in ${import_path37.default.relative(process.cwd(), filepath)}`
       );
@@ -1565591,7 +1565917,7 @@ async function loadAndUpdateGenerators({
     }
     context2.logger.debug(`Generators found: ${generators.toString()}`);
     for (const generator of generators.items) {
-      if (!import_yaml3.default.isMap(generator)) {
+      if (!import_yaml4.default.isMap(generator)) {
         context2.failAndThrow(
           `Expected generator in group ${groupName} to be a map in ${import_path37.default.relative(process.cwd(), filepath)}`
         );
@@ -1565734,7 +1566060,7 @@ async function upgradeGenerator({
           absolutePathToWorkspace: workspace.absoluteFilePath
         });
         if (absolutePathToGeneratorsConfiguration != null && result.updatedConfiguration != null) {
-          await (0, import_promises57.writeFile)(absolutePathToGeneratorsConfiguration, result.updatedConfiguration);
+          await (0, import_promises58.writeFile)(absolutePathToGeneratorsConfiguration, result.updatedConfiguration);
         }
         allSkippedMajorUpgrades.push(...result.skippedMajorUpgrades);
         if (result.appliedUpgrades.length > 0) {
@@ -1566088,7 +1566414,7 @@ function addGeneratorCommands(cli, cliContext) {
         }
         if (argv.output) {
           try {
-            await (0, import_promises58.writeFile)(argv.output, JSON.stringify(generatorMetadata, null, 2));
+            await (0, import_promises59.writeFile)(argv.output, JSON.stringify(generatorMetadata, null, 2));
           } catch (error49) {
             cliContext.failAndThrow(
               `Could not write file to the specified location: ${argv.output}`,
@@ -1566102,7 +1566428,7 @@ function addGeneratorCommands(cli, cliContext) {
 }
 
 // src/commands/add-generator/addGeneratorToWorkspaces.ts
-var import_promises59 = require("fs/promises");
+var import_promises60 = require("fs/promises");
 async function addGeneratorToWorkspaces({
   project: { apiWorkspaces },
   generatorName,
@@ -1566129,7 +1566455,7 @@ async function addGeneratorToWorkspaces({
         if (absolutePathToGeneratorsConfiguration == null) {
           return;
         }
-        await (0, import_promises59.writeFile)(
+        await (0, import_promises60.writeFile)(
           absolutePathToGeneratorsConfiguration,
           "# yaml-language-server: $schema=https://schema.buildwithfern.dev/generators-yml.json\n" + jsYaml.dump(newConfiguration)
         );
@@ -1566140,7 +1566466,7 @@ async function addGeneratorToWorkspaces({
 }
 
 // src/commands/diff/diff.ts
-var import_promises60 = require("fs/promises");
+var import_promises61 = require("fs/promises");
 var import_semver9 = __toESM(require_semver2(), 1);
 async function diff({
   context: context2,
@@ -1566183,7 +1566509,7 @@ async function readIr({
     context2.failWithoutThrowing(`File not found: ${absoluteFilepath}`);
     throw new FernCliError();
   }
-  const ir14 = await (0, import_promises60.readFile)(absoluteFilepath, "utf-8");
+  const ir14 = await (0, import_promises61.readFile)(absoluteFilepath, "utf-8");
   const parsed = serialization_exports4.IntermediateRepresentation.parse(JSON.parse(ir14));
   if (!parsed.ok) {
     context2.failWithoutThrowing(`Invalid --${flagName}; expected a filepath containing a valid IR`);
@@ -1583936,9 +1584262,9 @@ function replaceFrontmatterImagesforLogo(data2, mapImage) {
 }
 
 // ../docs-markdown-utils/lib/replaceReferencedCode.js
-var import_promises61 = require("fs/promises");
+var import_promises62 = require("fs/promises");
 async function defaultFileLoader(filepath) {
-  const file2 = await (0, import_promises61.readFile)(filepath);
+  const file2 = await (0, import_promises62.readFile)(filepath);
   return file2.toString();
 }
 function isUrl2(src) {
@@ -1584105,10 +1584431,10 @@ ${replacement}
 }
 
 // ../docs-markdown-utils/lib/replaceReferencedMarkdown.js
-var import_promises62 = require("fs/promises");
+var import_promises63 = require("fs/promises");
 var import_gray_matter5 = __toESM(require_gray_matter(), 1);
 async function defaultMarkdownLoader(filepath) {
-  const { content: content5 } = (0, import_gray_matter5.default)(await (0, import_promises62.readFile)(filepath));
+  const { content: content5 } = (0, import_gray_matter5.default)(await (0, import_promises63.readFile)(filepath));
   return content5;
 }
 function extractAttributes(markdownTag) {
@@ -1591860,7 +1592186,7 @@ function computeServiceTypeReferenceInfo(irGraph) {
 // ../docs-resolver/lib/DocsDefinitionResolver.js
 var import_dayjs3 = __toESM(require_dayjs_min(), 1);
 var import_utc3 = __toESM(require_utc(), 1);
-var import_promises66 = require("fs/promises");
+var import_promises67 = require("fs/promises");
 var import_gray_matter6 = __toESM(require_gray_matter(), 1);
 
 // ../../../node_modules/.pnpm/@fern-api+ui-core-utils@0.129.4-b6c699ad2/node_modules/@fern-api/ui-core-utils/dist/assertNever.js
@@ -1595974,7 +1596300,111 @@ var OpenAPIPruner = class {
 };
 
 // ../register/lib/ai-example-enhancer/enhanceExamplesWithAI.js
-var import_promises65 = require("fs/promises");
+var import_promises66 = require("fs/promises");
+
+// ../register/lib/ai-example-enhancer/filterHelpers.js
+function isFdrTypedValueWrapper(value) {
+  if (value === null || value === void 0 || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const obj = value;
+  const keys11 = Object.keys(obj);
+  if (keys11.length === 0 || keys11.length > 2) {
+    return false;
+  }
+  const hasType = "type" in obj && typeof obj.type === "string";
+  const hasValue = "value" in obj;
+  return hasType && keys11.length === 1 || hasType && hasValue && keys11.length === 2 || hasValue && keys11.length === 1;
+}
+function unwrapExampleValue(value) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(unwrapExampleValue);
+  }
+  if (typeof value !== "object") {
+    return value;
+  }
+  const obj = value;
+  if (isFdrTypedValueWrapper(obj)) {
+    if ("value" in obj) {
+      return unwrapExampleValue(obj.value);
+    }
+    return void 0;
+  }
+  const result = {};
+  for (const [key, val] of Object.entries(obj)) {
+    const unwrapped = unwrapExampleValue(val);
+    if (unwrapped !== void 0) {
+      result[key] = unwrapped;
+    }
+  }
+  return result;
+}
+function isEmptyObject2(value) {
+  if (value === null || value === void 0) {
+    return true;
+  }
+  if (typeof value !== "object") {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return value.length === 0;
+  }
+  return Object.keys(value).length === 0;
+}
+function filterRequestBody(requestBody, pathParameters, queryParameters, headers2) {
+  const extractedPathParams = {};
+  const extractedQueryParams = {};
+  const extractedHeaders = {};
+  if (requestBody === null || requestBody === void 0 || typeof requestBody !== "object" || Array.isArray(requestBody)) {
+    return { filteredBody: requestBody, extractedPathParams, extractedQueryParams, extractedHeaders };
+  }
+  const bodyRecord = requestBody;
+  const filteredBody = {};
+  const pathParamKeys = new Set(Object.keys(pathParameters ?? {}));
+  const queryParamKeys = new Set(Object.keys(queryParameters ?? {}));
+  const headerKeys = new Set(Object.keys(headers2 ?? {}));
+  for (const [key, value] of Object.entries(bodyRecord)) {
+    const normalizedKey = key.toLowerCase().replace(/[-_]/g, "");
+    let isPathParam = false;
+    let isQueryParam = false;
+    let isHeader = false;
+    for (const pathKey of pathParamKeys) {
+      const normalizedPathKey = pathKey.toLowerCase().replace(/[-_]/g, "");
+      if (normalizedKey === normalizedPathKey) {
+        isPathParam = true;
+        extractedPathParams[pathKey] = value;
+        break;
+      }
+    }
+    if (!isPathParam) {
+      for (const queryKey of queryParamKeys) {
+        const normalizedQueryKey = queryKey.toLowerCase().replace(/[-_]/g, "");
+        if (normalizedKey === normalizedQueryKey) {
+          isQueryParam = true;
+          extractedQueryParams[queryKey] = value;
+          break;
+        }
+      }
+    }
+    if (!isPathParam && !isQueryParam) {
+      for (const headerKey of headerKeys) {
+        const normalizedHeaderKey = headerKey.toLowerCase().replace(/[-_]/g, "");
+        if (normalizedKey === normalizedHeaderKey) {
+          isHeader = true;
+          extractedHeaders[headerKey] = value;
+          break;
+        }
+      }
+    }
+    if (!isPathParam && !isQueryParam && !isHeader) {
+      filteredBody[key] = value;
+    }
+  }
+  return { filteredBody, extractedPathParams, extractedQueryParams, extractedHeaders };
+}
 
 // ../register/lib/ai-example-enhancer/lambdaClient.js
 var DEFAULT_AI_ENHANCEMENT_MAX_RETRIES = 0;
@@ -1596191,12 +1596621,12 @@ var SpinnerStatusCoordinator = class _SpinnerStatusCoordinator {
 };
 
 // ../register/lib/ai-example-enhancer/validateAiExamples.js
-var import_promises63 = require("fs/promises");
+var import_promises64 = require("fs/promises");
 async function parseAiExamplesOverride(sourceFilePath, context2) {
   const overrideFilePath = AbsoluteFilePath2.of(`${dirname4(sourceFilePath)}/ai_examples_override.yml`);
   const aiExamples = [];
   try {
-    const existingContent = await (0, import_promises63.readFile)(overrideFilePath, "utf-8");
+    const existingContent = await (0, import_promises64.readFile)(overrideFilePath, "utf-8");
     const parsed = jsYaml.load(existingContent);
     if (parsed && typeof parsed === "object" && "paths" in parsed) {
       const paths = parsed.paths;
@@ -1596245,7 +1596675,7 @@ async function validateAiExamplesFromFile({ sourceFilePath, context: context2 })
   }
   let spec;
   try {
-    const specContent = await (0, import_promises63.readFile)(sourceFilePath, "utf-8");
+    const specContent = await (0, import_promises64.readFile)(sourceFilePath, "utf-8");
     try {
       spec = JSON.parse(specContent);
     } catch {
@@ -1596304,7 +1596734,7 @@ async function removeInvalidAiExamples({ sourceFilePath, context: context2 }) {
   }
   const overrideFilePath = AbsoluteFilePath2.of(`${dirname4(sourceFilePath)}/ai_examples_override.yml`);
   try {
-    const existingContent = await (0, import_promises63.readFile)(overrideFilePath, "utf-8");
+    const existingContent = await (0, import_promises64.readFile)(overrideFilePath, "utf-8");
     const parsed = jsYaml.load(existingContent);
     if (!parsed || !parsed.paths) {
       return {
@@ -1596348,79 +1596778,12 @@ async function removeInvalidAiExamples({ sourceFilePath, context: context2 }) {
 }
 
 // ../register/lib/ai-example-enhancer/writeAiExamplesOverride.js
-var import_promises64 = require("fs/promises");
-
-// ../register/lib/ai-example-enhancer/filterHelpers.js
-function isEmptyObject2(value) {
-  if (value === null || value === void 0) {
-    return true;
-  }
-  if (typeof value !== "object") {
-    return false;
-  }
-  if (Array.isArray(value)) {
-    return value.length === 0;
-  }
-  return Object.keys(value).length === 0;
-}
-function filterRequestBody(requestBody, pathParameters, queryParameters, headers2) {
-  const extractedPathParams = {};
-  const extractedQueryParams = {};
-  const extractedHeaders = {};
-  if (requestBody === null || requestBody === void 0 || typeof requestBody !== "object" || Array.isArray(requestBody)) {
-    return { filteredBody: requestBody, extractedPathParams, extractedQueryParams, extractedHeaders };
-  }
-  const bodyRecord = requestBody;
-  const filteredBody = {};
-  const pathParamKeys = new Set(Object.keys(pathParameters ?? {}));
-  const queryParamKeys = new Set(Object.keys(queryParameters ?? {}));
-  const headerKeys = new Set(Object.keys(headers2 ?? {}));
-  for (const [key, value] of Object.entries(bodyRecord)) {
-    const normalizedKey = key.toLowerCase().replace(/[-_]/g, "");
-    let isPathParam = false;
-    let isQueryParam = false;
-    let isHeader = false;
-    for (const pathKey of pathParamKeys) {
-      const normalizedPathKey = pathKey.toLowerCase().replace(/[-_]/g, "");
-      if (normalizedKey === normalizedPathKey) {
-        isPathParam = true;
-        extractedPathParams[pathKey] = value;
-        break;
-      }
-    }
-    if (!isPathParam) {
-      for (const queryKey of queryParamKeys) {
-        const normalizedQueryKey = queryKey.toLowerCase().replace(/[-_]/g, "");
-        if (normalizedKey === normalizedQueryKey) {
-          isQueryParam = true;
-          extractedQueryParams[queryKey] = value;
-          break;
-        }
-      }
-    }
-    if (!isPathParam && !isQueryParam) {
-      for (const headerKey of headerKeys) {
-        const normalizedHeaderKey = headerKey.toLowerCase().replace(/[-_]/g, "");
-        if (normalizedKey === normalizedHeaderKey) {
-          isHeader = true;
-          extractedHeaders[headerKey] = value;
-          break;
-        }
-      }
-    }
-    if (!isPathParam && !isQueryParam && !isHeader) {
-      filteredBody[key] = value;
-    }
-  }
-  return { filteredBody, extractedPathParams, extractedQueryParams, extractedHeaders };
-}
-
-// ../register/lib/ai-example-enhancer/writeAiExamplesOverride.js
+var import_promises65 = require("fs/promises");
 async function loadExistingOverrideCoverage(sourceFilePath, context2) {
   const overrideFilePath = AbsoluteFilePath2.of(`${dirname4(sourceFilePath)}/ai_examples_override.yml`);
   const coveredEndpoints = /* @__PURE__ */ new Set();
   try {
-    const existingContent = await (0, import_promises64.readFile)(overrideFilePath, "utf-8");
+    const existingContent = await (0, import_promises65.readFile)(overrideFilePath, "utf-8");
     const parsed = jsYaml.load(existingContent);
     if (parsed && typeof parsed === "object" && "paths" in parsed) {
       const paths = parsed.paths;
@@ -1596477,9 +1596840,26 @@ async function writeAiExamplesOverride({ enhancedExamples, sourceFilePath, conte
             }
           }
         }
-        let filteredRequestBody = example.requestBody;
-        if (example.requestBody !== void 0) {
-          const { filteredBody, extractedPathParams, extractedQueryParams, extractedHeaders } = filterRequestBody(example.requestBody, pathParams, queryParams, headersForFiltering);
+        const queryParamsForFiltering = {};
+        if (example.queryParameterNames) {
+          for (const queryName of example.queryParameterNames) {
+            queryParamsForFiltering[queryName] = queryParams[queryName] ?? "";
+          }
+        }
+        const pathParamsForFiltering = {};
+        if (example.pathParameterNames) {
+          for (const pathName of example.pathParameterNames) {
+            pathParamsForFiltering[pathName] = pathParams[pathName] ?? "";
+          }
+        }
+        let requestBodyToProcess = example.requestBody;
+        if (requestBodyToProcess !== null && requestBodyToProcess !== void 0 && typeof requestBodyToProcess === "object" && !Array.isArray(requestBodyToProcess) && "body" in requestBodyToProcess) {
+          requestBodyToProcess = requestBodyToProcess.body;
+        }
+        const unwrappedRequestBody = unwrapExampleValue(requestBodyToProcess);
+        let filteredRequestBody = unwrappedRequestBody;
+        if (unwrappedRequestBody !== void 0) {
+          const { filteredBody, extractedPathParams, extractedQueryParams, extractedHeaders } = filterRequestBody(unwrappedRequestBody, pathParamsForFiltering, queryParamsForFiltering, headersForFiltering);
           filteredRequestBody = filteredBody;
           for (const [key, value] of Object.entries(extractedPathParams)) {
             if (value !== void 0 && value !== null && value !== "") {
@@ -1596507,13 +1596887,12 @@ async function writeAiExamplesOverride({ enhancedExamples, sourceFilePath, conte
           fernExample.headers = headerParams;
         }
         if (filteredRequestBody !== void 0 && !isEmptyObject2(filteredRequestBody)) {
-          fernExample.request = {
-            body: filteredRequestBody
-          };
+          fernExample.request = filteredRequestBody;
         }
-        if (example.responseBody !== void 0 && !isEmptyObject2(example.responseBody)) {
+        const unwrappedResponseBody = unwrapExampleValue(example.responseBody);
+        if (unwrappedResponseBody !== void 0 && !isEmptyObject2(unwrappedResponseBody)) {
           fernExample.response = {
-            body: example.responseBody
+            body: unwrappedResponseBody
           };
         }
         return fernExample;
@@ -1596530,7 +1596909,7 @@ async function writeAiExamplesOverride({ enhancedExamples, sourceFilePath, conte
   try {
     let existingOverride = {};
     try {
-      const existingContent = await (0, import_promises64.readFile)(overrideFilePath, "utf-8");
+      const existingContent = await (0, import_promises65.readFile)(overrideFilePath, "utf-8");
       const parsed = jsYaml.load(existingContent);
       if (parsed && typeof parsed === "object") {
         existingOverride = parsed;
@@ -1596573,7 +1596952,7 @@ async function writeAiExamplesOverride({ enhancedExamples, sourceFilePath, conte
       lineWidth: -1,
       noRefs: true
     });
-    await (0, import_promises64.writeFile)(overrideFilePath, yamlContent, "utf-8");
+    await (0, import_promises65.writeFile)(overrideFilePath, yamlContent, "utf-8");
     context2.logger.debug(`AI enhanced examples written to: ${overrideFilePath}`);
   } catch (error49) {
     context2.logger.warn(`Failed to write AI examples override file: ${error49}`);
@@ -1596663,7 +1597042,10 @@ var ConcurrentEndpointProcessor = class {
       this.stats.completed++;
       this.results.set(result.endpointKey, {
         enhancedReq: result.enhancedReq,
-        enhancedRes: result.enhancedRes
+        enhancedRes: result.enhancedRes,
+        extractedHeaders: result.extractedHeaders,
+        extractedPathParams: result.extractedPathParams,
+        extractedQueryParams: result.extractedQueryParams
       });
     } else {
       this.stats.failed++;
@@ -1596705,7 +1597087,7 @@ function findMatchingOpenAPIPath2(examplePath, availablePaths) {
   }
   return void 0;
 }
-function extractHeaderParameterNames(openApiSpecJson, endpointPath, method) {
+function extractParameterNamesByType(openApiSpecJson, endpointPath, method, paramType) {
   try {
     const spec = JSON.parse(openApiSpecJson);
     if (!spec.paths) {
@@ -1596724,21 +1597106,30 @@ function extractHeaderParameterNames(openApiSpecJson, endpointPath, method) {
     if (!operation) {
       return [];
     }
-    const headerNames = [];
+    const paramNames = [];
     const allParameters = [...pathItem.parameters ?? [], ...operation.parameters ?? []];
     for (const param of allParameters) {
       if ("$ref" in param) {
         continue;
       }
-      if (param.in === "header") {
-        headerNames.push(param.name);
+      if (param.in === paramType) {
+        paramNames.push(param.name);
       }
     }
-    return headerNames;
+    return paramNames;
   } catch {
     return [];
   }
 }
+function extractHeaderParameterNames(openApiSpecJson, endpointPath, method) {
+  return extractParameterNamesByType(openApiSpecJson, endpointPath, method, "header");
+}
+function extractQueryParameterNames(openApiSpecJson, endpointPath, method) {
+  return extractParameterNamesByType(openApiSpecJson, endpointPath, method, "query");
+}
+function extractPathParameterNames(openApiSpecJson, endpointPath, method) {
+  return extractParameterNamesByType(openApiSpecJson, endpointPath, method, "path");
+}
 async function pruneOpenAPISpecForBatch(openApiSpecContent, endpointSelectors, context2) {
   try {
     let parsedSpec;
@@ -1596810,7 +1597201,7 @@ async function performAIEnhancement(apiDefinition, config3, context2, token, org
   let endpointsNeedingRegeneration = /* @__PURE__ */ new Set();
   if (sourceFilePath != null) {
     try {
-      const specContent = await (0, import_promises65.readFile)(sourceFilePath, "utf-8");
+      const specContent = await (0, import_promises66.readFile)(sourceFilePath, "utf-8");
       if (!isOpenApiSpec(specContent)) {
         context2.logger.debug("Non-OpenAPI spec detected, skipping AI example enhancement");
         return apiDefinition;
@@ -1597022,6 +1597413,9 @@ async function processEndpointsConcurrently(allWorkItems, enhancer, context2, or
             endpointKey: result.endpointKey,
             enhancedReq: result.enhancedReq,
             enhancedRes: result.enhancedRes,
+            extractedHeaders: result.extractedHeaders,
+            extractedPathParams: result.extractedPathParams,
+            extractedQueryParams: result.extractedQueryParams,
             success: true
           };
         } else {
@@ -1597086,6 +1597480,44 @@ async function processEndpoint(workItem, enhancer, context2, organizationId, sta
     const responseChanged = result.enhancedResponseExample !== request6.originalResponseExample;
     if (requestChanged || responseChanged) {
       const headerParameterNames = prunedOpenApiSpec ? extractHeaderParameterNames(prunedOpenApiSpec, workItem.example.path, workItem.endpoint.method) : [];
+      const queryParameterNames = prunedOpenApiSpec ? extractQueryParameterNames(prunedOpenApiSpec, workItem.example.path, workItem.endpoint.method) : [];
+      const pathParameterNames = prunedOpenApiSpec ? extractPathParameterNames(prunedOpenApiSpec, workItem.example.path, workItem.endpoint.method) : [];
+      const headersForFiltering = { ...workItem.example.headers ?? {} };
+      if (headerParameterNames.length > 0) {
+        for (const headerName of headerParameterNames) {
+          if (!(headerName in headersForFiltering)) {
+            headersForFiltering[headerName] = "";
+          }
+        }
+      }
+      const queryParamsForFiltering = {};
+      for (const queryName of queryParameterNames) {
+        queryParamsForFiltering[queryName] = workItem.example.queryParameters?.[queryName] ?? "";
+      }
+      const pathParamsForFiltering = {};
+      for (const pathName of pathParameterNames) {
+        pathParamsForFiltering[pathName] = workItem.example.pathParameters?.[pathName] ?? "";
+      }
+      const unwrappedRequestBody = unwrapExampleValue(result.enhancedRequestExample);
+      const { filteredBody, extractedPathParams, extractedQueryParams, extractedHeaders } = filterRequestBody(unwrappedRequestBody, pathParamsForFiltering, queryParamsForFiltering, headersForFiltering);
+      const mergedHeaders = { ...workItem.example.headers ?? {} };
+      for (const [key, value] of Object.entries(extractedHeaders)) {
+        if (value !== void 0 && value !== null && value !== "") {
+          mergedHeaders[key] = value;
+        }
+      }
+      const mergedPathParams = { ...workItem.example.pathParameters ?? {} };
+      for (const [key, value] of Object.entries(extractedPathParams)) {
+        if (value !== void 0 && value !== null && value !== "") {
+          mergedPathParams[key] = value;
+        }
+      }
+      const mergedQueryParams = { ...workItem.example.queryParameters ?? {} };
+      for (const [key, value] of Object.entries(extractedQueryParams)) {
+        if (value !== void 0 && value !== null && value !== "") {
+          mergedQueryParams[key] = value;
+        }
+      }
       const enhancedExampleRecord = {
         endpoint: workItem.example.path,
         method: workItem.endpoint.method,
@@ -1597094,7 +1597526,9 @@ async function processEndpoint(workItem, enhancer, context2, organizationId, sta
         headers: workItem.example.headers,
         requestBody: requestChanged ? result.enhancedRequestExample : void 0,
         responseBody: responseChanged ? result.enhancedResponseExample : void 0,
-        headerParameterNames: headerParameterNames.length > 0 ? headerParameterNames : void 0
+        headerParameterNames: headerParameterNames.length > 0 ? headerParameterNames : void 0,
+        queryParameterNames: queryParameterNames.length > 0 ? queryParameterNames : void 0,
+        pathParameterNames: pathParameterNames.length > 0 ? pathParameterNames : void 0
       };
       enhancedExampleRecords.push(enhancedExampleRecord);
       stats.count++;
@@ -1597108,8 +1597542,11 @@ async function processEndpoint(workItem, enhancer, context2, organizationId, sta
       }
       return {
         endpointKey,
-        enhancedReq: result.enhancedRequestExample,
-        enhancedRes: result.enhancedResponseExample
+        enhancedReq: filteredBody,
+        enhancedRes: result.enhancedResponseExample,
+        extractedHeaders: Object.keys(mergedHeaders).length > 0 ? mergedHeaders : void 0,
+        extractedPathParams: Object.keys(mergedPathParams).length > 0 ? mergedPathParams : void 0,
+        extractedQueryParams: Object.keys(mergedQueryParams).length > 0 ? mergedQueryParams : void 0
       };
     }
     context2.logger.debug(`No changes needed for ${workItem.endpoint.method} ${workItem.example.path}`);
@@ -1597135,18 +1597572,55 @@ function applyEnhancementResults(pkg2, enhancementResults) {
         const enhancedExample = {
           ...example
         };
-        if (enhancementResult.enhancedReq !== void 0 && example.requestBodyV3) {
+        if (enhancementResult.enhancedReq !== void 0) {
           enhancedExample.requestBody = enhancementResult.enhancedReq;
-          enhancedExample.requestBodyV3 = {
-            ...example.requestBodyV3,
-            value: enhancementResult.enhancedReq
-          };
+          if (example.requestBodyV3) {
+            const isFormData2 = typeof example.requestBodyV3.value === "object" && example.requestBodyV3.value !== null && !Array.isArray(example.requestBodyV3.value) && Object.values(example.requestBodyV3.value).some((v21) => isFdrTypedValueWrapper(v21));
+            if (isFormData2) {
+              const enhancedReq = enhancementResult.enhancedReq;
+              const originalValue = example.requestBodyV3.value;
+              const updatedValue = {};
+              for (const [key, wrapper] of Object.entries(originalValue)) {
+                if (key in enhancedReq) {
+                  updatedValue[key] = { ...wrapper, value: enhancedReq[key] };
+                } else {
+                  updatedValue[key] = wrapper;
+                }
+              }
+              enhancedExample.requestBodyV3 = {
+                ...example.requestBodyV3,
+                value: updatedValue
+              };
+            } else {
+              enhancedExample.requestBodyV3 = {
+                ...example.requestBodyV3,
+                value: enhancementResult.enhancedReq
+              };
+            }
+          } else {
+            enhancedExample.requestBodyV3 = { type: "json", value: enhancementResult.enhancedReq };
+          }
         }
-        if (enhancementResult.enhancedRes !== void 0 && example.responseBodyV3) {
+        if (enhancementResult.enhancedRes !== void 0) {
           enhancedExample.responseBody = enhancementResult.enhancedRes;
-          enhancedExample.responseBodyV3 = {
-            ...example.responseBodyV3,
-            value: enhancementResult.enhancedRes
+          enhancedExample.responseBodyV3 = example.responseBodyV3 ? { ...example.responseBodyV3, value: enhancementResult.enhancedRes } : { type: "json", value: enhancementResult.enhancedRes };
+        }
+        if (enhancementResult.extractedHeaders !== void 0) {
+          enhancedExample.headers = {
+            ...example.headers ?? {},
+            ...enhancementResult.extractedHeaders
+          };
+        }
+        if (enhancementResult.extractedPathParams !== void 0) {
+          enhancedExample.pathParameters = {
+            ...example.pathParameters ?? {},
+            ...enhancementResult.extractedPathParams
+          };
+        }
+        if (enhancementResult.extractedQueryParams !== void 0) {
+          enhancedExample.queryParameters = {
+            ...example.queryParameters ?? {},
+            ...enhancementResult.extractedQueryParams
           };
         }
         return enhancedExample;
@@ -1599673,7 +1600147,7 @@ var DocsDefinitionResolver = class {
       const jsFilePaths = /* @__PURE__ */ new Set();
       await Promise.all(this._parsedDocsConfig.experimental.mdxComponents.map(async (filepath) => {
         const absoluteFilePath = resolve5(this.docsWorkspace.absoluteFilePath, filepath);
-        const stats = await (0, import_promises66.stat)(absoluteFilePath);
+        const stats = await (0, import_promises67.stat)(absoluteFilePath);
         if (stats.isDirectory()) {
           const files = await listFiles(absoluteFilePath, "{js,ts,jsx,tsx,md,mdx}");
           files.forEach((file2) => {
@@ -1599685,7 +1600159,7 @@ var DocsDefinitionResolver = class {
       }));
       jsFiles = Object.fromEntries(await Promise.all([...jsFilePaths].map(async (filePath) => {
         const relativeFilePath = this.toRelativeFilepath(filePath);
-        const contents = (await (0, import_promises66.readFile)(filePath)).toString();
+        const contents = (await (0, import_promises67.readFile)(filePath)).toString();
         return [relativeFilePath, contents];
       })));
       const mdxTime = performance.now() - mdxStart;
@@ -1607732,7 +1608206,7 @@ async function generateFdrFromOpenApiWorkspace(workspace, context2) {
 // ../docs-preview/lib/runAppPreviewServer.js
 var import_cors = __toESM(require_lib16(), 1);
 var import_express = __toESM(require_express3(), 1);
-var import_promises72 = require("fs/promises");
+var import_promises73 = require("fs/promises");
 var import_http6 = __toESM(require("http"), 1);
 var import_path42 = __toESM(require("path"), 1);
 
@@ -1609404,13 +1609878,13 @@ var watcher_default = Watcher;
 init_wrapper();
 
 // ../docs-preview/lib/DebugLogger.js
-var import_promises67 = require("fs/promises");
+var import_promises68 = require("fs/promises");
 var import_os5 = require("os");
 var import_path40 = __toESM(require("path"), 1);
 var LOCAL_STORAGE_FOLDER4 = ".fern-dev";
 var LOGS_FOLDER_NAME = "logs";
 function getCliSource() {
-  const version7 = "3.47.3";
+  const version7 = "3.47.4";
   return `cli@${version7}`;
 }
 var DebugLogger = class {
@@ -1609430,7 +1609904,7 @@ var DebugLogger = class {
     const localStorageFolder = join2(AbsoluteFilePath2.of((0, import_os5.homedir)()), RelativeFilePath2.of(LOCAL_STORAGE_FOLDER4));
     const logsDir = join2(localStorageFolder, RelativeFilePath2.of(LOGS_FOLDER_NAME));
     if (!await doesPathExist(logsDir)) {
-      await (0, import_promises67.mkdir)(logsDir, { recursive: true });
+      await (0, import_promises68.mkdir)(logsDir, { recursive: true });
     }
     const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     const logFileName = `${timestamp2}.debug.log`;
@@ -1609443,7 +1609917,7 @@ var DebugLogger = class {
       "================================================================================",
       ""
     ].join("\n");
-    await (0, import_promises67.writeFile)(this.logFilePath, header, "utf-8");
+    await (0, import_promises68.writeFile)(this.logFilePath, header, "utf-8");
     this.initialized = true;
   }
   /**
@@ -1609461,7 +1609935,7 @@ var DebugLogger = class {
     }
     const line = JSON.stringify(entry) + "\n";
     try {
-      await (0, import_promises67.appendFile)(this.logFilePath, line, "utf-8");
+      await (0, import_promises68.appendFile)(this.logFilePath, line, "utf-8");
     } catch (error49) {
     }
   }
@@ -1609585,7 +1610059,7 @@ var DebugLogger = class {
 // ../docs-preview/lib/downloadLocalDocsBundle.js
 var import_cli_progress = __toESM(require_cli_progress(), 1);
 var import_decompress = __toESM(require_decompress(), 1);
-var import_promises68 = require("fs/promises");
+var import_promises69 = require("fs/promises");
 var import_os6 = require("os");
 var import_tmp_promise9 = __toESM(require_tmp_promise(), 1);
 var import_xml2js = __toESM(require_xml2js(), 1);
@@ -1609673,7 +1610147,7 @@ async function downloadBundle({ bucketUrl, logger, preferCached, app = false, tr
     let currentETag = void 0;
     if (currentETagExists) {
       logger.debug("Reading existing ETag");
-      currentETag = (await (0, import_promises68.readFile)(eTagFilepath)).toString();
+      currentETag = (await (0, import_promises69.readFile)(eTagFilepath)).toString();
     }
     if (currentETag != null && currentETag === eTag) {
       logger.debug("ETag matches. Using already downloaded bundle");
@@ -1609737,16 +1610211,16 @@ async function downloadBundle({ bucketUrl, logger, preferCached, app = false, tr
       }
     }
     const nodeBuffer = Buffer.concat(chunks);
-    await (0, import_promises68.writeFile)(outputZipPath, new Uint8Array(nodeBuffer));
+    await (0, import_promises69.writeFile)(outputZipPath, new Uint8Array(nodeBuffer));
     logger.debug(`Wrote ${tryTar ? "output.tar.gz" : "output.zip"} to ${outputZipPath}`);
     const absolutePathToPreviewFolder = getPathToPreviewFolder({ app });
     if (await doesPathExist(absolutePathToPreviewFolder)) {
       logger.debug(`Removing previously cached bundle at: ${absolutePathToPreviewFolder}`);
-      await (0, import_promises68.rm)(absolutePathToPreviewFolder, { recursive: true });
+      await (0, import_promises69.rm)(absolutePathToPreviewFolder, { recursive: true });
     }
-    await (0, import_promises68.mkdir)(absolutePathToPreviewFolder, { recursive: true });
+    await (0, import_promises69.mkdir)(absolutePathToPreviewFolder, { recursive: true });
     const absolutePathToBundleFolder = getPathToBundleFolder({ app });
-    await (0, import_promises68.mkdir)(absolutePathToBundleFolder, { recursive: true });
+    await (0, import_promises69.mkdir)(absolutePathToBundleFolder, { recursive: true });
     logger.debug(`Decompressing bundle from ${outputZipPath} to ${absolutePathToBundleFolder}`);
     let unzipProgressBar;
     let unzipInterval;
@@ -1609781,7 +1610255,7 @@ async function downloadBundle({ bucketUrl, logger, preferCached, app = false, tr
         unzipProgressBar.stop();
       }
     }
-    await (0, import_promises68.writeFile)(eTagFilepath, eTag);
+    await (0, import_promises69.writeFile)(eTagFilepath, eTag);
     logger.debug(`Downloaded bundle to ${absolutePathToBundleFolder}`);
     if (app) {
       logger.debug("Checking if pnpm is installed");
@@ -1609863,15 +1610337,15 @@ async function downloadBundle({ bucketUrl, logger, preferCached, app = false, tr
         }
         if (!pnpmfileExists) {
           logger.debug(`Writing pnpmfile.cjs at ${pnpmfilePath}`);
-          await (0, import_promises68.writeFile)(pnpmfilePath, PNPMFILE_CJS_CONTENTS);
+          await (0, import_promises69.writeFile)(pnpmfilePath, PNPMFILE_CJS_CONTENTS);
         }
         if (!npmrcExists) {
           logger.debug(`Writing .npmrc at ${npmrcPath}`);
-          await (0, import_promises68.writeFile)(npmrcPath, NPMRC_CONTENTS);
+          await (0, import_promises69.writeFile)(npmrcPath, NPMRC_CONTENTS);
         }
         if (instrumentationJsExists) {
           logger.debug(`Removing instrumentation.js at ${absPathToInstrumentationJs}`);
-          await (0, import_promises68.rm)(absPathToInstrumentationJs);
+          await (0, import_promises69.rm)(absPathToInstrumentationJs);
         }
         try {
           logger.debug("Running pnpm install within standalone");
@@ -1609891,7 +1610365,7 @@ async function downloadBundle({ bucketUrl, logger, preferCached, app = false, tr
     logger.error(`Error: ${error49}`);
     const absolutePathToPreviewFolder = getPathToPreviewFolder({ app });
     if (await doesPathExist(absolutePathToPreviewFolder)) {
-      await (0, import_promises68.rm)(absolutePathToPreviewFolder, { recursive: true });
+      await (0, import_promises69.rm)(absolutePathToPreviewFolder, { recursive: true });
     }
     logger.debug(`Removing incomplete bundle: rm -rf ${absolutePathToPreviewFolder}`);
     return {
@@ -1609901,7 +1610375,7 @@ async function downloadBundle({ bucketUrl, logger, preferCached, app = false, tr
 }
 
 // ../docs-preview/lib/previewDocs.js
-var import_promises71 = require("fs/promises");
+var import_promises72 = require("fs/promises");
 var import_gray_matter10 = __toESM(require_gray_matter(), 1);
 
 // ../docs-markdown-utils/src/extract-literals.ts
@@ -1610744,9 +1611218,9 @@ function replaceFrontmatterImagesforLogo2(data2, mapImage) {
 }
 
 // ../docs-markdown-utils/src/replaceReferencedCode.ts
-var import_promises69 = require("fs/promises");
+var import_promises70 = require("fs/promises");
 async function defaultFileLoader2(filepath) {
-  const file2 = await (0, import_promises69.readFile)(filepath);
+  const file2 = await (0, import_promises70.readFile)(filepath);
   return file2.toString();
 }
 function isUrl3(src) {
@@ -1610920,10 +1611394,10 @@ ${replacement}
 }
 
 // ../docs-markdown-utils/src/replaceReferencedMarkdown.ts
-var import_promises70 = require("fs/promises");
+var import_promises71 = require("fs/promises");
 var import_gray_matter9 = __toESM(require_gray_matter(), 1);
 async function defaultMarkdownLoader2(filepath) {
-  const { content: content5 } = (0, import_gray_matter9.default)(await (0, import_promises70.readFile)(filepath));
+  const { content: content5 } = (0, import_gray_matter9.default)(await (0, import_promises71.readFile)(filepath));
   return content5;
 }
 function extractAttributes2(markdownTag) {
@@ -1611122,7 +1611596,7 @@ async function getPreviewDocsDefinition({ domain: domain3, project, context: con
         navAffectingChange = true;
         continue;
       }
-      const markdown = (await (0, import_promises71.readFile)(absoluteFilePath)).toString();
+      const markdown = (await (0, import_promises72.readFile)(absoluteFilePath)).toString();
       const isNewFile = previousValue == null;
       if (isNewFile) {
         navAffectingChange = true;
@@ -1611512,7 +1611986,7 @@ var SnippetDependencyTracker = class {
       const markdownFiles = await this.findMarkdownFiles(docsWorkspace.absoluteFilePath);
       for (const markdownFile of markdownFiles) {
         try {
-          const content5 = await (0, import_promises72.readFile)(markdownFile, "utf-8");
+          const content5 = await (0, import_promises73.readFile)(markdownFile, "utf-8");
           const referencedFiles = this.extractReferences(content5, markdownFile, docsWorkspace.absoluteFilePath);
           this.pageToSnippets.set(markdownFile, referencedFiles);
           for (const referencedFile of referencedFiles) {
@@ -1611594,7 +1612068,7 @@ async function runAppPreviewServer({ initialProject, reloadProject, validateProj
     const appPreviewFolder = getPathToPreviewFolder({ app: true });
     if (await doesPathExist(appPreviewFolder)) {
       context2.logger.info("Force download requested. Deleting cached bundle...");
-      await (0, import_promises72.rm)(appPreviewFolder, { recursive: true });
+      await (0, import_promises73.rm)(appPreviewFolder, { recursive: true });
     }
   }
   if (bundlePath != null) {
@@ -1614088,7 +1614562,7 @@ async function validateVersionConfigFileSchema({ value }) {
 }
 
 // ../yaml/docs-validator/lib/docsAst/visitDocsConfigFileYamlAst.js
-var import_promises74 = require("fs/promises");
+var import_promises75 = require("fs/promises");
 
 // ../yaml/docs-validator/lib/docsAst/products-yml.schema.json
 var products_yml_schema_exports = {};
@@ -1615939,7 +1616413,7 @@ async function visitFilepath({ absoluteFilepathToConfiguration, rawUnresolvedFil
 }
 
 // ../yaml/docs-validator/lib/docsAst/visitNavigationAst.js
-var import_promises73 = require("fs/promises");
+var import_promises74 = require("fs/promises");
 
 // ../yaml/docs-validator/lib/utils/asyncPool.js
 async function asyncPool(limit, items, fn4) {
@@ -1616090,13 +1616564,13 @@ async function visitNavigationItem2({ absolutePathToFernFolder, navigationItem,
   if (navigationItemIsPage(navigationItem)) {
     const absoluteFilepath = resolve5(dirname4(absoluteFilepathToConfiguration), navigationItem.path);
     if (await doesPathExist(absoluteFilepath)) {
-      const fileStats = await (0, import_promises73.stat)(absoluteFilepath);
+      const fileStats = await (0, import_promises74.stat)(absoluteFilepath);
       const fileSizeMB = fileStats.size / (1024 * 1024);
       if (fileSizeMB > 1) {
         context2.logger.trace(`Processing large markdown file: ${navigationItem.path} (${fileSizeMB.toFixed(2)} MB)`);
       }
       const startTime = performance.now();
-      const content5 = (await (0, import_promises73.readFile)(absoluteFilepath, "utf8")).toString();
+      const content5 = (await (0, import_promises74.readFile)(absoluteFilepath, "utf8")).toString();
       const readTime = performance.now() - startTime;
       if (readTime > 2e3) {
         context2.logger.debug(`Slow file read: ${navigationItem.path} took ${readTime.toFixed(0)}ms`);
@@ -1616143,12 +1616617,12 @@ async function visitNavigationItem2({ absolutePathToFernFolder, navigationItem,
     context2.logger.trace(`Starting changelog processing for directory: ${changelogDir}`);
     if (await doesPathExist(changelogDir)) {
       const startTime = performance.now();
-      const files = await (0, import_promises73.readdir)(changelogDir);
+      const files = await (0, import_promises74.readdir)(changelogDir);
       const markdownFiles = files.filter((file2) => file2.endsWith(".md") || file2.endsWith(".mdx"));
       context2.logger.debug(`Processing ${markdownFiles.length} changelog files in ${changelogDir}`);
       await asyncPool(VALIDATION_CONCURRENCY, markdownFiles, async (file2) => {
         const absoluteFilepath = resolve5(changelogDir, file2);
-        const content5 = (await (0, import_promises73.readFile)(absoluteFilepath, "utf8")).toString();
+        const content5 = (await (0, import_promises74.readFile)(absoluteFilepath, "utf8")).toString();
         context2.logger.trace(`Validating changelog file: ${file2}`);
         await visitor.markdownPage?.({
           title: file2,
@@ -1616338,7 +1616812,7 @@ async function visitDocsConfigFileYamlAst({ contents, visitor, absoluteFilepathT
             willBeUploaded: false
           });
           const absoluteFilepath = resolve5(dirname4(absoluteFilepathToConfiguration), product.path);
-          const content5 = jsYaml.load((await (0, import_promises74.readFile)(absoluteFilepath)).toString());
+          const content5 = jsYaml.load((await (0, import_promises75.readFile)(absoluteFilepath)).toString());
           if (await doesPathExist(absoluteFilepath)) {
             await visitor.productFile?.({
               path: product.path,
@@ -1616416,7 +1616890,7 @@ async function visitDocsConfigFileYamlAst({ contents, visitor, absoluteFilepathT
           willBeUploaded: false
         });
         const absoluteFilepath = resolve5(dirname4(absoluteFilepathToConfiguration), version7.path);
-        const content5 = jsYaml.load((await (0, import_promises74.readFile)(absoluteFilepath)).toString());
+        const content5 = jsYaml.load((await (0, import_promises75.readFile)(absoluteFilepath)).toString());
         if (await doesPathExist(absoluteFilepath)) {
           await visitor.versionFile?.({
             path: version7.path,
@@ -1616850,7 +1617324,7 @@ var import_web = require("stream/web");
 var import_node_stream5 = require("stream");
 
 // ../../../node_modules/.pnpm/strtok3@9.1.1/node_modules/strtok3/lib/index.js
-var import_promises76 = require("fs/promises");
+var import_promises77 = require("fs/promises");
 
 // ../../../node_modules/.pnpm/peek-readable@5.4.2/node_modules/peek-readable/lib/EndOfStreamError.js
 var defaultMessages = "End-Of-Stream";
@@ -1617221,14 +1617695,14 @@ function fromBuffer(uint8Array, options2) {
 }
 
 // ../../../node_modules/.pnpm/strtok3@9.1.1/node_modules/strtok3/lib/FileTokenizer.js
-var import_promises75 = require("fs/promises");
+var import_promises76 = require("fs/promises");
 var FileTokenizer = class _FileTokenizer extends AbstractTokenizer {
   /**
    * Create tokenizer from provided file path
    * @param sourceFilePath File path
    */
   static async fromFile(sourceFilePath) {
-    const fileHandle = await (0, import_promises75.open)(sourceFilePath, "r");
+    const fileHandle = await (0, import_promises76.open)(sourceFilePath, "r");
     const stat3 = await fileHandle.stat();
     return new _FileTokenizer(fileHandle, { fileInfo: { path: sourceFilePath, size: stat3.size } });
   }
@@ -1619190,7 +1619664,7 @@ var supportedExtensions = new Set(extensions);
 var supportedMimeTypes = new Set(mimeTypes);
 
 // ../yaml/docs-validator/lib/rules/valid-file-types/valid-file-types.js
-var import_promises77 = require("fs/promises");
+var import_promises78 = require("fs/promises");
 var import_path44 = __toESM(require("path"), 1);
 var ALLOWED_FILE_TYPES = /* @__PURE__ */ new Set([
   // image files
@@ -1619311,7 +1619785,7 @@ var ValidFileTypes = {
   }
 };
 var getViolationsForFile = async (absoluteFilepath) => {
-  const file2 = new Uint8Array(await (0, import_promises77.readFile)(absoluteFilepath));
+  const file2 = new Uint8Array(await (0, import_promises78.readFile)(absoluteFilepath));
   const fileType = await fileTypeFromBuffer(file2);
   if (fileType != null) {
     if (ALLOWED_FILE_TYPES.has(fileType.mime)) {
@@ -1619350,7 +1619824,7 @@ var getViolationsForFile = async (absoluteFilepath) => {
 };
 
 // ../yaml/docs-validator/lib/rules/valid-frontmatter/valid-frontmatter.js
-var import_promises78 = require("fs/promises");
+var import_promises79 = require("fs/promises");
 var import_gray_matter11 = __toESM(require_gray_matter(), 1);
 var ValidFrontmatter = {
   name: "valid-frontmatter",
@@ -1619361,7 +1619835,7 @@ var ValidFrontmatter = {
           return [];
         }
         try {
-          const fileContents = await (0, import_promises78.readFile)(absoluteFilepath, "utf-8");
+          const fileContents = await (0, import_promises79.readFile)(absoluteFilepath, "utf-8");
           (0, import_gray_matter11.default)(fileContents);
           return [];
         } catch (error49) {
@@ -1623818,7 +1624292,7 @@ function compile(vfileCompatible, compileOptions) {
 }
 
 // ../../../node_modules/.pnpm/vfile-matter@5.0.1/node_modules/vfile-matter/lib/index.js
-var import_yaml4 = __toESM(require_dist(), 1);
+var import_yaml5 = __toESM(require_dist(), 1);
 var regex4 = /^---(?:\r?\n|\r)(?:([\s\S]*?)(?:\r?\n|\r))?---(?:\r?\n|\r|$)/;
 var emptyOptions10 = {};
 var emptyYamlOptions = {};
@@ -1623829,7 +1624303,7 @@ function matter2(file2, options2) {
   let document4 = String(file2);
   const match3 = regex4.exec(document4);
   if (match3) {
-    file2.data.matter = import_yaml4.default.parse(match3[1] || "", yamlOptions) || {};
+    file2.data.matter = import_yaml5.default.parse(match3[1] || "", yamlOptions) || {};
     if (strip) {
       document4 = document4.slice(match3[0].length);
       file2.value = file2.value && typeof file2.value === "object" ? new TextEncoder().encode(document4) : document4;
@@ -1624237,7 +1624711,7 @@ async function parseMarkdown({ markdown, absoluteFilepath, absolutePathToFernFol
 }
 
 // ../yaml/docs-validator/lib/rules/valid-markdown-file-reference/valid-markdown-file-reference.js
-var import_promises79 = require("fs/promises");
+var import_promises80 = require("fs/promises");
 var import_gray_matter12 = __toESM(require_gray_matter(), 1);
 var ValidMarkdownFileReferences = {
   name: "valid-markdown-file-references",
@@ -1624248,7 +1624722,7 @@ var ValidMarkdownFileReferences = {
           return [];
         }
         try {
-          const fileContents = await (0, import_promises79.readFile)(absoluteFilepath, "utf-8");
+          const fileContents = await (0, import_promises80.readFile)(absoluteFilepath, "utf-8");
           const { content: content5 } = (0, import_gray_matter12.default)(fileContents, {});
           const tree = parseMarkdownToTree(content5);
           const errors4 = [];
@@ -1624925,7 +1625399,7 @@ var MDX_NODE_TYPES = [
   "mdxTextExpression",
   "mdxjsEsm"
 ];
-function collectLinksAndSources({ readFile: readFile84 = (path76) => (0, import_node_fs27.readFileSync)(path76, "utf-8"), ...opts }) {
+function collectLinksAndSources({ readFile: readFile85 = (path76) => (0, import_node_fs27.readFileSync)(path76, "utf-8"), ...opts }) {
   const visitedAbsoluteFilepaths = /* @__PURE__ */ new Set();
   const contentQueue = [opts];
   const links = [];
@@ -1624963,7 +1625437,7 @@ function collectLinksAndSources({ readFile: readFile84 = (path76) => (0, import_
                 const resolvedImportPath = resolve5(dirname4(absoluteFilepath), importPath);
                 if (resolvedImportPath.endsWith(".mdx") || resolvedImportPath.endsWith(".md")) {
                   contentQueue.push({
-                    content: readFile84(resolvedImportPath),
+                    content: readFile85(resolvedImportPath),
                     absoluteFilepath: resolvedImportPath
                   });
                 }
@@ -1625006,7 +1625480,7 @@ function collectLinksAndSources({ readFile: readFile84 = (path76) => (0, import_
           if (absoluteFilepath && typeof src === "string") {
             const resolvedImportPath = resolve5(dirname4(absoluteFilepath), src);
             contentQueue.push({
-              content: readFile84(resolvedImportPath),
+              content: readFile85(resolvedImportPath),
               absoluteFilepath: resolvedImportPath
             });
           }
@@ -1625390,7 +1625864,7 @@ function createDocsConfigFileAstVisitorForRules({ relativeFilepath, allRuleVisit
 }
 
 // ../yaml/docs-validator/lib/rules/no-non-component-refs/no-non-component-refs.js
-var import_promises80 = require("fs/promises");
+var import_promises81 = require("fs/promises");
 var NoNonComponentRefsRule = {
   name: "no-non-component-refs",
   create: ({ ossWorkspaces, logger, workspace: docsWorkspace }) => {
@@ -1625404,7 +1625878,7 @@ var NoNonComponentRefsRule = {
               if (!processedFiles.has(spec.absoluteFilepath)) {
                 processedFiles.add(spec.absoluteFilepath);
                 try {
-                  const contents = (await (0, import_promises80.readFile)(spec.absoluteFilepath)).toString();
+                  const contents = (await (0, import_promises81.readFile)(spec.absoluteFilepath)).toString();
                   const relativePath = relative3(docsWorkspace.absoluteFilePath, spec.absoluteFilepath);
                   const isOpenApiV2 = contents.includes("swagger:") && (contents.includes('swagger: "2.0"') || contents.includes("swagger: '2.0'") || contents.includes("swagger: 2.0"));
                   if (isOpenApiV2) {
@@ -1625444,7 +1625918,7 @@ var NoNonComponentRefsRule = {
 };
 
 // ../yaml/docs-validator/lib/rules/no-openapi-v2-in-docs/no-openapi-v2-in-docs.js
-var import_promises81 = require("fs/promises");
+var import_promises82 = require("fs/promises");
 var NoOpenApiV2InDocsRule = {
   name: "no-openapi-v2-in-docs",
   create: ({ ossWorkspaces, logger, workspace: docsWorkspace }) => {
@@ -1625457,7 +1625931,7 @@ var NoOpenApiV2InDocsRule = {
             if (spec.type === "openapi" && !processedFiles.has(spec.absoluteFilepath)) {
               processedFiles.add(spec.absoluteFilepath);
               try {
-                const contents = (await (0, import_promises81.readFile)(spec.absoluteFilepath)).toString();
+                const contents = (await (0, import_promises82.readFile)(spec.absoluteFilepath)).toString();
                 const relativePath = relative3(docsWorkspace.absoluteFilePath, spec.absoluteFilepath);
                 if (contents.includes("swagger:") && (contents.includes('swagger: "2.0"') || contents.includes("swagger: '2.0'") || contents.includes("swagger: 2.0"))) {
                   violations.push({
@@ -1625580,7 +1626054,7 @@ var ValidInstanceUrlRule = {
 };
 
 // ../yaml/docs-validator/lib/rules/valid-local-references/valid-local-references.js
-var import_promises82 = require("fs/promises");
+var import_promises83 = require("fs/promises");
 function validateReference(ref2, spec) {
   const pathParts = ref2.replace(/^#\//, "").split("/").map((part) => (
     // Decode JSON Pointer escapes: ~1 -> /, ~0 -> ~
@@ -1625647,7 +1626121,7 @@ var ValidLocalReferencesRule = {
             if (spec.type === "openapi" && !processedFiles.has(spec.absoluteFilepath)) {
               processedFiles.add(spec.absoluteFilepath);
               try {
-                const contents = (await (0, import_promises82.readFile)(spec.absoluteFilepath)).toString();
+                const contents = (await (0, import_promises83.readFile)(spec.absoluteFilepath)).toString();
                 const relativePath = relative3(docsWorkspace.absoluteFilePath, spec.absoluteFilepath);
                 const isOpenApiV2 = contents.includes("swagger:") && (contents.includes('swagger: "2.0"') || contents.includes("swagger: '2.0'") || contents.includes("swagger: 2.0"));
                 if (isOpenApiV2) {
@@ -1625700,7 +1626174,7 @@ var ValidLocalReferencesRule = {
 };
 
 // ../yaml/docs-validator/lib/rules/valid-openapi-examples/valid-openapi-examples.js
-var import_promises83 = require("fs/promises");
+var import_promises84 = require("fs/promises");
 var ValidOpenApiExamples = {
   name: "valid-openapi-examples",
   create: ({ ossWorkspaces, logger, workspace: docsWorkspace }) => {
@@ -1625798,7 +1626272,7 @@ var ValidOpenApiExamples = {
 };
 async function validateOpenApiExamples({ specPath, logger }) {
   try {
-    const specContent = await (0, import_promises83.readFile)(specPath, "utf-8");
+    const specContent = await (0, import_promises84.readFile)(specPath, "utf-8");
     let spec;
     try {
       spec = JSON.parse(specContent);
@@ -1626492,7 +1626966,7 @@ Found ${previewDeployments.length} preview deployment(s):
 }
 
 // src/commands/downgrade/downgrade.ts
-var import_promises84 = require("fs/promises");
+var import_promises85 = require("fs/promises");
 
 // ../../../node_modules/.pnpm/immer@10.1.3/node_modules/immer/dist/immer.mjs
 var NOTHING = Symbol.for("immer-nothing");
@@ -1627181,12 +1627655,12 @@ async function downgrade({
   const newProjectConfig = produce(projectConfig.rawConfig, (draft) => {
     draft.version = targetVersion;
   });
-  await (0, import_promises84.writeFile)(projectConfig._absolutePath, ensureFinalNewline(JSON.stringify(newProjectConfig, void 0, 2)));
+  await (0, import_promises85.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
-var import_promises85 = require("fs/promises");
+var import_promises86 = require("fs/promises");
 
 // src/commands/export/converters/servicesConverter.ts
 var import_openapi_types3 = __toESM(require_dist20(), 1);
@@ -1628439,8 +1628913,8 @@ async function generateOpenAPIForWorkspaces({
           ir: ir14,
           mode: "openapi"
         });
-        await (0, import_promises85.mkdir)(dirname4(outputPath), { recursive: true });
-        await (0, import_promises85.writeFile)(
+        await (0, import_promises86.mkdir)(dirname4(outputPath), { recursive: true });
+        await (0, import_promises86.writeFile)(
           outputPath,
           outputPath.endsWith(".json") ? JSON.stringify(openapi, void 0, indent3) : jsYaml.dump(openapi, { indent: indent3 })
         );
@@ -1628479,10 +1628953,10 @@ var APPROVED_DIRECTORIES_FILENAME = "approved-output-directories";
 var LOCAL_STORAGE_FOLDER6 = ".fern-dev";
 
 // src/commands/generate/checkOutputDirectory.ts
-var import_promises88 = require("fs/promises");
+var import_promises89 = require("fs/promises");
 
 // src/persistence/output-directories/getOutputDirectories.ts
-var import_promises86 = require("fs/promises");
+var import_promises87 = require("fs/promises");
 
 // src/persistence/output-directories/getPathToOutputDirectoriesFile.ts
 var import_os7 = require("os");
@@ -1628501,17 +1628975,17 @@ async function getOutputDirectories() {
   if (!doesOutputDirectoriesFileExist) {
     return [];
   }
-  const outputDirectoriesFileContents = await (0, import_promises86.readFile)(pathToOutputDirectoriesFile, { encoding: "utf-8" });
+  const outputDirectoriesFileContents = await (0, import_promises87.readFile)(pathToOutputDirectoriesFile, { encoding: "utf-8" });
   const outputDirectories = JSON.parse(outputDirectoriesFileContents);
   return outputDirectories;
 }
 
 // src/persistence/output-directories/storeOutputDirectories.ts
-var import_promises87 = require("fs/promises");
+var import_promises88 = require("fs/promises");
 var import_path46 = __toESM(require("path"), 1);
 async function storeOutputDirectories(outputDirectories) {
-  await (0, import_promises87.mkdir)(import_path46.default.dirname(getPathToOutputDirectoriesFile()), { recursive: true });
-  await (0, import_promises87.writeFile)(getPathToOutputDirectoriesFile(), JSON.stringify(outputDirectories, null, 2));
+  await (0, import_promises88.mkdir)(import_path46.default.dirname(getPathToOutputDirectoriesFile()), { recursive: true });
+  await (0, import_promises88.writeFile)(getPathToOutputDirectoriesFile(), JSON.stringify(outputDirectories, null, 2));
 }
 
 // src/commands/generate/checkOutputDirectory.ts
@@ -1628533,7 +1629007,7 @@ async function checkOutputDirectory(outputPath, cliContext, force) {
       shouldProceed: true
     };
   }
-  const files = await (0, import_promises88.readdir)(outputPath);
+  const files = await (0, import_promises89.readdir)(outputPath);
   if (files.length === 0) {
     return {
       shouldProceed: true
@@ -1628895,7 +1629369,7 @@ var AutoVersioningService = class {
 };
 
 // ../generation/local-generation/docker-utils/lib/runDocker.js
-var import_promises89 = require("fs/promises");
+var import_promises90 = require("fs/promises");
 var import_tmp_promise10 = __toESM(require_tmp_promise(), 1);
 async function runContainer({ logger, imageName, args = [], binds = [], envVars = {}, ports = {}, writeLogsToFile = true, removeAfterCompletion = false, runner }) {
   const tryRun = () => tryRunContainer({
@@ -1628944,7 +1629418,7 @@ async function tryRunContainer({ logger, imageName, args, binds, envVars = {}, p
   const logs = stdout + stderr;
   if (writeLogsToFile) {
     const tmpFile = await import_tmp_promise10.default.file();
-    await (0, import_promises89.writeFile)(tmpFile.path, logs);
+    await (0, import_promises90.writeFile)(tmpFile.path, logs);
     logger.info(`Generator logs here: ${tmpFile.path}`);
   }
   if (exitCode == null) {
@@ -1629037,7 +1629511,7 @@ var ContainerExecutionEnvironment = class {
 
 // ../generation/local-generation/local-workspace-runner/lib/runGenerator.js
 var import_serialization = __toESM(require_serialization3(), 1);
-var import_promises91 = require("fs/promises");
+var import_promises92 = require("fs/promises");
 var path61 = __toESM(require("path"), 1);
 var import_path49 = require("path");
 var import_tmp_promise12 = __toESM(require_tmp_promise(), 1);
@@ -1642864,7 +1643338,7 @@ function configureBamlClient(config3) {
 
 // ../generation/local-generation/local-workspace-runner/lib/LocalTaskHandler.js
 var import_decompress2 = __toESM(require_decompress(), 1);
-var import_promises90 = require("fs/promises");
+var import_promises91 = require("fs/promises");
 var import_os8 = require("os");
 var import_path48 = require("path");
 var import_semver10 = __toESM(require_semver2(), 1);
@@ -1642947,7 +1643421,7 @@ var LocalTaskHandler = class {
     try {
       this.context.logger.info("Analyzing SDK changes for automatic semantic versioning");
       diffFile = await this.generateDiffFile();
-      const diffContent = await (0, import_promises90.readFile)(diffFile, "utf-8");
+      const diffContent = await (0, import_promises91.readFile)(diffFile, "utf-8");
       if (diffContent.trim().length === 0) {
         this.context.logger.info("No changes detected in generated SDK");
         return null;
@@ -1642994,7 +1643468,7 @@ var LocalTaskHandler = class {
     } finally {
       if (diffFile) {
         try {
-          await (0, import_promises90.rm)(diffFile);
+          await (0, import_promises91.rm)(diffFile);
         } catch (cleanupError) {
           this.context.logger.warn(`Failed to delete temp diff file: ${diffFile}`, String(cleanupError));
         }
@@ -1643073,7 +1643547,7 @@ var LocalTaskHandler = class {
     const tmpOutputResolutionDir = AbsoluteFilePath2.of((await import_tmp_promise11.default.dir({})).path);
     const absolutePathToFernignore = AbsoluteFilePath2.of(join2(this.absolutePathToLocalOutput, RelativeFilePath2.of(FERNIGNORE_FILENAME)));
     const fernIgnorePaths = await getFernIgnorePaths({ absolutePathToFernignore });
-    await (0, import_promises90.cp)(this.absolutePathToLocalOutput, tmpOutputResolutionDir, { recursive: true });
+    await (0, import_promises91.cp)(this.absolutePathToLocalOutput, tmpOutputResolutionDir, { recursive: true });
     await this.runGitCommand(["init"], tmpOutputResolutionDir);
     await this.runGitCommand(["add", "."], tmpOutputResolutionDir);
     const response = await this.runGitCommand(["config", "--list"], tmpOutputResolutionDir);
@@ -1643087,13 +1643561,13 @@ var LocalTaskHandler = class {
     await this.runGitCommand(["add", "."], tmpOutputResolutionDir);
     await this.runGitCommand(["reset", "--", ...fernIgnorePaths], tmpOutputResolutionDir);
     await this.runGitCommand(["restore", "."], tmpOutputResolutionDir);
-    await (0, import_promises90.rm)(join2(tmpOutputResolutionDir, RelativeFilePath2.of(".git")), { recursive: true });
-    await (0, import_promises90.rm)(this.absolutePathToLocalOutput, { recursive: true });
-    await (0, import_promises90.cp)(tmpOutputResolutionDir, this.absolutePathToLocalOutput, { recursive: true });
+    await (0, import_promises91.rm)(join2(tmpOutputResolutionDir, RelativeFilePath2.of(".git")), { recursive: true });
+    await (0, import_promises91.rm)(this.absolutePathToLocalOutput, { recursive: true });
+    await (0, import_promises91.cp)(tmpOutputResolutionDir, this.absolutePathToLocalOutput, { recursive: true });
   }
   async copyGeneratedFilesNoFernIgnorePreservingGit() {
-    const contents = await (0, import_promises90.readdir)(this.absolutePathToLocalOutput);
-    await Promise.all(contents.filter((item) => item !== ".git").map((item) => (0, import_promises90.rm)(join2(this.absolutePathToLocalOutput, RelativeFilePath2.of(item)), {
+    const contents = await (0, import_promises91.readdir)(this.absolutePathToLocalOutput);
+    await Promise.all(contents.filter((item) => item !== ".git").map((item) => (0, import_promises91.rm)(join2(this.absolutePathToLocalOutput, RelativeFilePath2.of(item)), {
       force: true,
       recursive: true
     })));
@@ -1643101,11 +1643575,11 @@ var LocalTaskHandler = class {
   }
   async copyGeneratedFilesNoFernIgnoreDeleteAll() {
     this.context.logger.debug(`rm -rf ${this.absolutePathToLocalOutput}`);
-    await (0, import_promises90.rm)(this.absolutePathToLocalOutput, { force: true, recursive: true });
+    await (0, import_promises91.rm)(this.absolutePathToLocalOutput, { force: true, recursive: true });
     await this.copyGeneratedFilesToDirectory(this.absolutePathToLocalOutput);
   }
   async copyGeneratedFilesToDirectory(outputPath) {
-    const [firstLocalOutputItem, ...remaininglocalOutputItems] = await (0, import_promises90.readdir)(this.absolutePathToTmpOutputDirectory);
+    const [firstLocalOutputItem, ...remaininglocalOutputItems] = await (0, import_promises91.readdir)(this.absolutePathToTmpOutputDirectory);
     if (firstLocalOutputItem == null) {
       return;
     }
@@ -1643113,15 +1643587,15 @@ var LocalTaskHandler = class {
     if (firstLocalOutputItem.endsWith(".zip")) {
       await (0, import_decompress2.default)(join2(this.absolutePathToTmpOutputDirectory, RelativeFilePath2.of(firstLocalOutputItem)), outputPath);
       for (const localOutputItem of remaininglocalOutputItems) {
-        await (0, import_promises90.cp)(join2(this.absolutePathToTmpOutputDirectory, RelativeFilePath2.of(localOutputItem)), join2(outputPath, RelativeFilePath2.of(localOutputItem)), { recursive: true });
+        await (0, import_promises91.cp)(join2(this.absolutePathToTmpOutputDirectory, RelativeFilePath2.of(localOutputItem)), join2(outputPath, RelativeFilePath2.of(localOutputItem)), { recursive: true });
       }
     } else {
-      await (0, import_promises90.cp)(this.absolutePathToTmpOutputDirectory, outputPath, { recursive: true });
+      await (0, import_promises91.cp)(this.absolutePathToTmpOutputDirectory, outputPath, { recursive: true });
     }
   }
   async copySnippetJSON({ absolutePathToTmpSnippetJSON, absolutePathToLocalSnippetJSON }) {
     this.context.logger.debug(`Copying generated snippets to ${absolutePathToLocalSnippetJSON}`);
-    await (0, import_promises90.cp)(absolutePathToTmpSnippetJSON, absolutePathToLocalSnippetJSON);
+    await (0, import_promises91.cp)(absolutePathToTmpSnippetJSON, absolutePathToLocalSnippetJSON);
   }
   async runGitCommand(options2, cwd2) {
     const response = await loggingExeca(this.context.logger, "git", options2, {
@@ -1643176,24 +1643650,24 @@ async function writeFilesToDiskAndRunGenerator({ organization, absolutePathToFer
   context2.logger.debug("Wrote IR to: " + absolutePathToIr);
   const configJsonFile = (0, import_path49.join)(workspaceTempDir.path, GENERATOR_CONFIG_FILENAME);
   const absolutePathToWriteConfigJson = AbsoluteFilePath2.of(configJsonFile);
-  await (0, import_promises91.writeFile)(configJsonFile, "");
+  await (0, import_promises92.writeFile)(configJsonFile, "");
   context2.logger.debug("Will write config.json to: " + absolutePathToWriteConfigJson);
   const tmpOutputDirectory = (0, import_path49.join)(workspaceTempDir.path, CODEGEN_OUTPUT_DIRECTORY_NAME);
   const absolutePathToTmpOutputDirectory = AbsoluteFilePath2.of(tmpOutputDirectory);
-  await (0, import_promises91.mkdir)(tmpOutputDirectory, { recursive: true });
+  await (0, import_promises92.mkdir)(tmpOutputDirectory, { recursive: true });
   context2.logger.debug("Will write output to: " + absolutePathToTmpOutputDirectory);
   let absolutePathToTmpSnippetJSON = void 0;
   if (absolutePathToLocalSnippetJSON != null) {
     const snippetJsonFile = (0, import_path49.join)(workspaceTempDir.path, "snippet.json");
     absolutePathToTmpSnippetJSON = AbsoluteFilePath2.of(snippetJsonFile);
-    await (0, import_promises91.writeFile)(snippetJsonFile, "");
+    await (0, import_promises92.writeFile)(snippetJsonFile, "");
     context2.logger.debug("Will write snippet.json to: " + absolutePathToTmpSnippetJSON);
   }
   let absolutePathToTmpSnippetTemplatesJSON = void 0;
   if (absolutePathToLocalSnippetTemplateJSON != null) {
     const snippetTemplatesJsonFile = (0, import_path49.join)(workspaceTempDir.path, SNIPPET_TEMPLATES_JSON_FILENAME);
     absolutePathToTmpSnippetTemplatesJSON = AbsoluteFilePath2.of(snippetTemplatesJsonFile);
-    await (0, import_promises91.writeFile)(snippetTemplatesJsonFile, "");
+    await (0, import_promises92.writeFile)(snippetTemplatesJsonFile, "");
     context2.logger.debug("Will write snippet-templates.json to: " + absolutePathToTmpSnippetTemplatesJSON);
   }
   const environment2 = executionEnvironment ?? new ContainerExecutionEnvironment({
@@ -1643229,7 +1643703,7 @@ async function writeFilesToDiskAndRunGenerator({ organization, absolutePathToFer
     whiteLabel,
     paths
   });
-  await (0, import_promises91.writeFile)(absolutePathToWriteConfigJson, JSON.stringify(await import_serialization.GeneratorConfig.jsonOrThrow(config3), void 0, 4));
+  await (0, import_promises92.writeFile)(absolutePathToWriteConfigJson, JSON.stringify(await import_serialization.GeneratorConfig.jsonOrThrow(config3), void 0, 4));
   const absolutePathToLicenseFile = extractLicenseFilePath(generatorInvocation, absolutePathToFernConfig);
   await environment2.execute({
     generatorName: generatorInvocation.name,
@@ -1643471,8 +1643945,8 @@ var import_fiddle_sdk5 = __toESM(require_fiddle_sdk(), 1);
 
 // ../generation/remote-generation/remote-workspace-runner/lib/downloadSnippetsForTask.js
 var import_fs21 = require("fs");
-var import_promises92 = require("fs/promises");
-var import_promises93 = require("stream/promises");
+var import_promises93 = require("fs/promises");
+var import_promises94 = require("stream/promises");
 async function downloadSnippetsForTask({ snippetsS3PreSignedReadUrl, absolutePathToLocalSnippetJSON, context: context2 }) {
   try {
     await downloadFileForTask({
@@ -1643489,22 +1643963,22 @@ async function downloadFileForTask({ s3PreSignedReadUrl, absolutePathToLocalOutp
     responseType: "stream"
   });
   if (await doesPathExist(absolutePathToLocalOutput)) {
-    await (0, import_promises92.rm)(absolutePathToLocalOutput, { recursive: true });
+    await (0, import_promises93.rm)(absolutePathToLocalOutput, { recursive: true });
   }
-  await (0, import_promises92.mkdir)(dirname4(absolutePathToLocalOutput), { recursive: true });
-  await (0, import_promises93.pipeline)(request6.data, (0, import_fs21.createWriteStream)(absolutePathToLocalOutput));
+  await (0, import_promises93.mkdir)(dirname4(absolutePathToLocalOutput), { recursive: true });
+  await (0, import_promises94.pipeline)(request6.data, (0, import_fs21.createWriteStream)(absolutePathToLocalOutput));
 }
 
 // ../generation/remote-generation/remote-workspace-runner/lib/createAndStartJob.js
 var import_fiddle_sdk4 = __toESM(require_fiddle_sdk(), 1);
 var import_form_data4 = __toESM(require_form_data(), 1);
-var import_promises94 = require("fs/promises");
+var import_promises95 = require("fs/promises");
 var import_url_join23 = __toESM(require_url_join(), 1);
 async function createAndStartJob({ projectConfig, workspace, organization, intermediateRepresentation, generatorInvocation, version: version7, context: context2, shouldLogS3Url, token, whitelabel, irVersionOverride, absolutePathToPreview, fernignorePath }) {
   let fernignoreContents;
   if (fernignorePath != null) {
     try {
-      fernignoreContents = await (0, import_promises94.readFile)(fernignorePath, "utf-8");
+      fernignoreContents = await (0, import_promises95.readFile)(fernignorePath, "utf-8");
     } catch (error49) {
       context2.failAndThrow(`Failed to read fernignore file at ${fernignorePath}: ${error49}`);
     }
@@ -1643698,9 +1644172,9 @@ function pollJobAndReportStatus({ job, taskId, taskHandler, context: context2 })
 // ../generation/remote-generation/remote-workspace-runner/lib/RemoteTaskHandler.js
 var import_decompress3 = __toESM(require_decompress(), 1);
 var import_fs22 = require("fs");
-var import_promises95 = require("fs/promises");
+var import_promises96 = require("fs/promises");
 var import_path50 = __toESM(require("path"), 1);
-var import_promises96 = require("stream/promises");
+var import_promises97 = require("stream/promises");
 
 // ../../../node_modules/.pnpm/terminal-link@3.0.0/node_modules/terminal-link/index.js
 var import_supports_hyperlinks = __toESM(require_supports_hyperlinks(), 1);
@@ -1643868,9 +1644342,9 @@ async function downloadZipForTask({ s3PreSignedReadUrl, absolutePathToLocalOutpu
   });
   const tmpDir = await import_tmp_promise13.default.dir({ prefix: "fern", unsafeCleanup: true });
   const outputZipPath = import_path50.default.join(tmpDir.path, "output.zip");
-  await (0, import_promises96.pipeline)(request6.data, (0, import_fs22.createWriteStream)(outputZipPath));
+  await (0, import_promises97.pipeline)(request6.data, (0, import_fs22.createWriteStream)(outputZipPath));
   await forceRemoveDirectory(absolutePathToLocalOutput);
-  await (0, import_promises95.mkdir)(absolutePathToLocalOutput, { recursive: true });
+  await (0, import_promises96.mkdir)(absolutePathToLocalOutput, { recursive: true });
   await (0, import_decompress3.default)(outputZipPath, absolutePathToLocalOutput);
 }
 async function forceRemoveDirectory(dirPath) {
@@ -1643878,22 +1644352,22 @@ async function forceRemoveDirectory(dirPath) {
     return;
   }
   await makeWritableRecursive(dirPath);
-  await (0, import_promises95.rm)(dirPath, { recursive: true, force: true });
+  await (0, import_promises96.rm)(dirPath, { recursive: true, force: true });
 }
 async function makeWritableRecursive(dirPath) {
   try {
-    const entries10 = await (0, import_promises95.readdir)(dirPath, { withFileTypes: true });
+    const entries10 = await (0, import_promises96.readdir)(dirPath, { withFileTypes: true });
     for (const entry of entries10) {
       const fullPath = AbsoluteFilePath2.of(import_path50.default.join(dirPath, entry.name));
       if (entry.isDirectory()) {
         await makeWritableRecursive(fullPath);
       }
       try {
-        await (0, import_promises95.chmod)(fullPath, 493);
+        await (0, import_promises96.chmod)(fullPath, 493);
       } catch {
       }
     }
-    await (0, import_promises95.chmod)(dirPath, 493);
+    await (0, import_promises96.chmod)(dirPath, 493);
   } catch {
   }
 }
@@ -1643944,7 +1644418,7 @@ async function downloadFilesWithFernIgnoreInTempRepo({ s3PreSignedReadUrl, absol
   const tmpOutputResolutionDir = AbsoluteFilePath2.of((await import_tmp_promise13.default.dir({})).path);
   const absolutePathToFernignore = join2(absolutePathToLocalOutput, RelativeFilePath2.of(FERNIGNORE_FILENAME));
   const fernIgnorePaths = await getFernIgnorePaths({ absolutePathToFernignore });
-  await (0, import_promises95.cp)(absolutePathToLocalOutput, tmpOutputResolutionDir, { recursive: true });
+  await (0, import_promises96.cp)(absolutePathToLocalOutput, tmpOutputResolutionDir, { recursive: true });
   await runGitCommand(["init"], tmpOutputResolutionDir, context2);
   await runGitCommand(["add", "."], tmpOutputResolutionDir, context2);
   const gitConfigResponse = await runGitCommand(["config", "--list"], tmpOutputResolutionDir, context2);
@@ -1643960,7 +1644434,7 @@ async function downloadFilesWithFernIgnoreInTempRepo({ s3PreSignedReadUrl, absol
   await runGitCommand(["restore", "."], tmpOutputResolutionDir, context2);
   await forceRemoveDirectory(join2(tmpOutputResolutionDir, RelativeFilePath2.of(".git")));
   await forceRemoveDirectory(absolutePathToLocalOutput);
-  await (0, import_promises95.cp)(tmpOutputResolutionDir, absolutePathToLocalOutput, { recursive: true });
+  await (0, import_promises96.cp)(tmpOutputResolutionDir, absolutePathToLocalOutput, { recursive: true });
 }
 async function downloadAndExtractZipToDirectory({ s3PreSignedReadUrl, outputPath }) {
   const request6 = await axios_default.get(s3PreSignedReadUrl, {
@@ -1643968,12 +1644442,12 @@ async function downloadAndExtractZipToDirectory({ s3PreSignedReadUrl, outputPath
   });
   const tmpDir = await import_tmp_promise13.default.dir({ prefix: "fern", unsafeCleanup: true });
   const outputZipPath = import_path50.default.join(tmpDir.path, "output.zip");
-  await (0, import_promises96.pipeline)(request6.data, (0, import_fs22.createWriteStream)(outputZipPath));
+  await (0, import_promises97.pipeline)(request6.data, (0, import_fs22.createWriteStream)(outputZipPath));
   await (0, import_decompress3.default)(outputZipPath, outputPath);
 }
 
 // ../generation/remote-generation/remote-workspace-runner/lib/SourceUploader.js
-var import_promises97 = require("fs/promises");
+var import_promises98 = require("fs/promises");
 var import_tmp_promise14 = __toESM(require_tmp_promise(), 1);
 var PROTOBUF_ZIP_FILENAME = "proto.zip";
 var SourceUploader = class {
@@ -1643994,7 +1644468,7 @@ var SourceUploader = class {
   }
   async uploadSource(source2, uploadURL) {
     const uploadCommand = await this.getUploadCommand(source2);
-    const fileData = await (0, import_promises97.readFile)(uploadCommand.absoluteFilePath);
+    const fileData = await (0, import_promises98.readFile)(uploadCommand.absoluteFilePath);
     const response = await fetch(uploadURL, {
       method: "PUT",
       body: fileData,
@@ -1644014,7 +1644488,7 @@ var SourceUploader = class {
         absoluteFilePath,
         cleanup: async () => {
           this.context.logger.debug(`Removing ${absoluteFilePath}`);
-          await (0, import_promises97.unlink)(absoluteFilePath);
+          await (0, import_promises98.unlink)(absoluteFilePath);
         }
       };
     }
@@ -1644456,7 +1644930,7 @@ async function runRemoteGenerationForAPIWorkspace({ projectConfig, organization,
 
 // ../generation/remote-generation/remote-workspace-runner/lib/publishDocs.js
 var import_crypto9 = require("crypto");
-var import_promises98 = require("fs/promises");
+var import_promises99 = require("fs/promises");
 var mime = __toESM(require_mime_types(), 1);
 
 // ../generation/remote-generation/remote-workspace-runner/lib/measureImageSizes.js
@@ -1644513,7 +1644987,7 @@ var MEASURE_IMAGE_BATCH_SIZE = 10;
 var UPLOAD_FILE_BATCH_SIZE = 10;
 var HASH_CONCURRENCY = parseInt(process.env.FERN_DOCS_ASSET_HASH_CONCURRENCY ?? "32", 10);
 async function calculateFileHash(absoluteFilePath) {
-  const fileBuffer = await (0, import_promises98.readFile)(absoluteFilePath);
+  const fileBuffer = await (0, import_promises99.readFile)(absoluteFilePath);
   return (0, import_crypto9.createHash)("sha256").update(new Uint8Array(fileBuffer)).digest("hex");
 }
 async function publishDocs({ token, organization, docsWorkspace, domain: domain3, customDomains, apiWorkspaces, ossWorkspaces, context: context2, preview, editThisPage, isPrivate = false, disableTemplates = false, skipUpload = false, withAiExamples = true, excludeApis = false, targetAudiences }) {
@@ -1644832,7 +1645306,7 @@ async function uploadFiles(filesToUpload, docsWorkspacePath, context2, batchSize
       const absoluteFilePath = resolve5(docsWorkspacePath, relativeFilePath);
       try {
         const mimeType = mime.lookup(absoluteFilePath);
-        await axios_default.put(uploadUrl, await (0, import_promises98.readFile)(absoluteFilePath), {
+        await axios_default.put(uploadUrl, await (0, import_promises99.readFile)(absoluteFilePath), {
           headers: {
             "Content-Type": mimeType === false ? "application/octet-stream" : mimeType,
             // Set max cache control for S3 uploads
@@ -1654824,14 +1655298,14 @@ async function validateGeneratorsYmlFile({ contents, allRuleVisitors, cliVersion
 }
 
 // ../workspace/oss-validator/lib/rules/no-duplicate-overrides/no-duplicate-overrides.js
-var import_promises99 = require("fs/promises");
+var import_promises100 = require("fs/promises");
 var NoDuplicateOverridesRule = {
   name: "no-duplicate-overrides",
   run: async ({ workspace, specs, context: context2 }) => {
     const violations = [];
     const seenMethodsByAudience = /* @__PURE__ */ new Map();
     for (const spec of specs) {
-      const contents = (await (0, import_promises99.readFile)(spec.absoluteFilepath)).toString();
+      const contents = (await (0, import_promises100.readFile)(spec.absoluteFilepath)).toString();
       if (contents.includes("openapi") || contents.includes("swagger")) {
         const openAPI = await loadOpenAPI({
           absolutePathToOpenAPI: spec.absoluteFilepath,
@@ -1655657,7 +1656131,7 @@ async function generateOpenAPIIrForWorkspaces({
 }
 
 // src/commands/generate-overrides/compareOpenAPISpecs.ts
-var import_promises100 = require("fs/promises");
+var import_promises101 = require("fs/promises");
 async function compareOpenAPISpecs({
   originalPath,
   modifiedPath,
@@ -1655694,12 +1656168,12 @@ async function compareOpenAPISpecs({
       }
       outputPath = join2(dirname4(originalPath), RelativeFilePath2.of(overridesFilename));
     }
-    await (0, import_promises100.writeFile)(outputPath, jsYaml.dump(overrides, { lineWidth: -1, noRefs: true }));
+    await (0, import_promises101.writeFile)(outputPath, jsYaml.dump(overrides, { lineWidth: -1, noRefs: true }));
     context2.logger.info(`Overrides written to ${outputPath}`);
   });
 }
 async function loadSpec(filepath, context2) {
-  const contents = await (0, import_promises100.readFile)(filepath, "utf8");
+  const contents = await (0, import_promises101.readFile)(filepath, "utf8");
   try {
     return JSON.parse(contents);
   } catch {
@@ -1655800,7 +1656274,7 @@ function deepEqual(a10, b18) {
 }
 
 // src/commands/generate-overrides/writeOverridesForWorkspaces.ts
-var import_promises101 = require("fs/promises");
+var import_promises102 = require("fs/promises");
 async function writeOverridesForWorkspaces({
   project,
   includeModels,
@@ -1655825,7 +1656299,7 @@ async function writeOverridesForWorkspaces({
 async function readExistingOverrides(overridesFilepath, context2) {
   let parsedOverrides = null;
   try {
-    const contents = (await (0, import_promises101.readFile)(overridesFilepath, "utf8")).toString();
+    const contents = (await (0, import_promises102.readFile)(overridesFilepath, "utf8")).toString();
     try {
       parsedOverrides = JSON.parse(contents);
     } catch (err) {
@@ -1655889,7 +1656363,7 @@ async function writeDefinitionForOpenAPIWorkspace({
         overridesFilename = `${nameWithoutExt}-overrides${extension2}`;
       }
     }
-    await (0, import_promises101.writeFile)(
+    await (0, import_promises102.writeFile)(
       join2(dirname4(spec.absoluteFilepath), RelativeFilePath2.of(overridesFilename)),
       jsYaml.dump({ paths, components })
     );
@@ -1656254,7 +1656728,7 @@ function convertIRtoJsonSchema(args) {
 }
 
 // src/commands/jsonschema/generateJsonschemaForWorkspace.ts
-var import_promises102 = require("fs/promises");
+var import_promises103 = require("fs/promises");
 async function generateJsonschemaForWorkspaces({
   typeLocator,
   project,
@@ -1656302,9 +1656776,9 @@ async function generateJsonschemaForWorkspaces({
           context: context2
         });
         if (!await doesPathExist(dirname4(jsonschemaFilepath))) {
-          await (0, import_promises102.mkdir)(dirname4(jsonschemaFilepath), { recursive: true });
+          await (0, import_promises103.mkdir)(dirname4(jsonschemaFilepath), { recursive: true });
         }
-        await (0, import_promises102.writeFile)(jsonschemaFilepath, JSON.stringify(jsonSchema, null, 2));
+        await (0, import_promises103.writeFile)(jsonschemaFilepath, JSON.stringify(jsonSchema, null, 2));
         context2.logger.info(source_default.green(`Wrote JSON Schema to ${jsonschemaFilepath}`));
       });
     })
@@ -1656661,7 +1657135,7 @@ async function mockServer({
 
 // src/commands/register/registerWorkspacesV1.ts
 var import_fiddle_sdk7 = __toESM(require_fiddle_sdk(), 1);
-var import_promises103 = require("fs/promises");
+var import_promises104 = require("fs/promises");
 var import_path59 = __toESM(require("path"), 1);
 var import_tmp_promise16 = __toESM(require_tmp_promise(), 1);
 async function registerWorkspacesV1({
@@ -1656710,7 +1657184,7 @@ async function registerWorkspacesV1({
         context2.logger.debug(`Compressing definition at ${tmpDir.path}`);
         await create6({ file: tarPath, cwd: resolvedWorkspace.absoluteFilePath }, ["."]);
         context2.logger.info("Uploading definition...");
-        await axios_default.put(registerApiResponse.body.definitionS3UploadUrl, await (0, import_promises103.readFile)(tarPath));
+        await axios_default.put(registerApiResponse.body.definitionS3UploadUrl, await (0, import_promises104.readFile)(tarPath));
         context2.logger.info(
           `Registered @${project.config.organization}/${resolvedWorkspace.definition.rootApiFile.contents.name}:${registerApiResponse.body.version}`
         );
@@ -1656848,7 +1657322,7 @@ async function generateDiff({
 }
 
 // src/commands/self-update/selfUpdate.ts
-var import_promises104 = require("fs/promises");
+var import_promises105 = require("fs/promises");
 var import_path60 = require("path");
 async function getPackageManagerBinDir(logger, pm) {
   let command3;
@@ -1656894,7 +1657368,7 @@ async function detectInstallationMethod(logger) {
   logger.debug(`Found fern at: ${fernPath}`);
   let resolvedPath;
   try {
-    resolvedPath = await (0, import_promises104.realpath)(fernPath);
+    resolvedPath = await (0, import_promises105.realpath)(fernPath);
     logger.debug(`Resolved to: ${resolvedPath}`);
   } catch (error49) {
     logger.debug(`Failed to resolve symlink: ${error49}`);
@@ -1657175,20 +1657649,20 @@ async function generateToken({
 
 // src/commands/upgrade/updateApiSpec.ts
 var fs31 = __toESM(require("fs"), 1);
-var import_promises105 = require("fs/promises");
+var import_promises106 = require("fs/promises");
 var import_stream9 = require("stream");
-var import_promises106 = require("stream/promises");
+var import_promises107 = require("stream/promises");
 async function fetchAndWriteFile(url3, path76, logger, indent3) {
   const resp = await fetch(url3);
   if (resp.ok && resp.body) {
     logger.debug("Origin successfully fetched, writing to file");
     const fileStream = fs31.createWriteStream(path76);
-    await (0, import_promises106.finished)(import_stream9.Readable.fromWeb(resp.body).pipe(fileStream));
-    const fileContents = await (0, import_promises105.readFile)(path76, "utf8");
+    await (0, import_promises107.finished)(import_stream9.Readable.fromWeb(resp.body).pipe(fileStream));
+    const fileContents = await (0, import_promises106.readFile)(path76, "utf8");
     try {
-      await (0, import_promises105.writeFile)(path76, JSON.stringify(JSON.parse(fileContents), void 0, indent3), "utf8");
+      await (0, import_promises106.writeFile)(path76, JSON.stringify(JSON.parse(fileContents), void 0, indent3), "utf8");
     } catch (e6) {
-      await (0, import_promises105.writeFile)(path76, jsYaml.dump(jsYaml.load(fileContents), { indent: indent3 }), "utf8");
+      await (0, import_promises106.writeFile)(path76, jsYaml.dump(jsYaml.load(fileContents), { indent: indent3 }), "utf8");
     }
     logger.debug("File written successfully");
   }
@@ -1657284,7 +1657758,7 @@ async function processDefinitions({
 }
 
 // ../cli-migrations/lib/migrations/0.0.191/discriminant/migration.js
-var import_promises107 = require("fs/promises");
+var import_promises108 = require("fs/promises");
 
 // ../cli-migrations/lib/migrations/0.0.191/discriminant/getAllYamlFiles.js
 var FERN_DIRECTORY2 = "fern";
@@ -1657318,7 +1657792,7 @@ var migration = {
       try {
         const fileContents = await getFileContents(yamlFilepath);
         const newContents = addDiscriminantToFile(fileContents);
-        await (0, import_promises107.writeFile)(yamlFilepath, newContents);
+        await (0, import_promises108.writeFile)(yamlFilepath, newContents);
       } catch (error49) {
         context2.failAndThrow("Failed to migrate " + yamlFilepath, error49);
       }
@@ -1657326,7 +1657800,7 @@ var migration = {
   }
 };
 async function getFileContents(filepath) {
-  const buffer = await (0, import_promises107.readFile)(filepath);
+  const buffer = await (0, import_promises108.readFile)(filepath);
   return buffer.toString();
 }
 var UNION_REGEX = /^(\s{2,})union:\s*$/gm;
@@ -1657355,8 +1657829,8 @@ var versionMigrations = {
 var __default = versionMigrations;
 
 // ../cli-migrations/lib/migrations/0.0.203/union-single-property-key/migration.js
-var import_promises108 = require("fs/promises");
-var import_yaml5 = __toESM(require_dist(), 1);
+var import_promises109 = require("fs/promises");
+var import_yaml6 = __toESM(require_dist(), 1);
 
 // ../cli-migrations/lib/migrations/0.0.203/union-single-property-key/getAllYamlFiles.js
 var FERN_DIRECTORY3 = "fern";
@@ -1657396,39 +1657870,39 @@ var migration2 = {
   }
 };
 async function migrateFile(filepath, context2) {
-  const contents = await (0, import_promises108.readFile)(filepath);
-  const parsedDocument = import_yaml5.default.parseDocument(contents.toString());
+  const contents = await (0, import_promises109.readFile)(filepath);
+  const parsedDocument = import_yaml6.default.parseDocument(contents.toString());
   const types4 = parsedDocument.get("types");
   if (types4 == null) {
     return;
   }
-  if (!import_yaml5.default.isMap(types4)) {
+  if (!import_yaml6.default.isMap(types4)) {
     context2.failWithoutThrowing(`"types" is not a map in ${filepath}`);
     return;
   }
   for (const typeDeclaration of types4.items) {
-    if (import_yaml5.default.isMap(typeDeclaration.value)) {
+    if (import_yaml6.default.isMap(typeDeclaration.value)) {
       const union9 = typeDeclaration.value.get("union");
       if (union9 == null) {
         continue;
       }
-      if (!import_yaml5.default.isMap(union9)) {
+      if (!import_yaml6.default.isMap(union9)) {
         context2.failWithoutThrowing(`"union" is not a map in ${filepath}`);
         continue;
       }
       for (const singleUnionType of union9.items) {
-        if (import_yaml5.default.isScalar(singleUnionType.value)) {
+        if (import_yaml6.default.isScalar(singleUnionType.value)) {
           singleUnionType.value = {
             type: singleUnionType.value,
             key: singleUnionType.key
           };
-        } else if (import_yaml5.default.isMap(singleUnionType.value)) {
-          singleUnionType.value.add(new import_yaml5.default.Pair("key", singleUnionType.key));
+        } else if (import_yaml6.default.isMap(singleUnionType.value)) {
+          singleUnionType.value.add(new import_yaml6.default.Pair("key", singleUnionType.key));
         }
       }
     }
   }
-  await (0, import_promises108.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises109.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.0.203/index.js
@@ -1657439,8 +1657913,8 @@ var versionMigrations2 = {
 var __default2 = versionMigrations2;
 
 // ../cli-migrations/lib/migrations/0.0.207/add-mode-to-draft-generators/migration.js
-var import_promises109 = require("fs/promises");
-var import_yaml6 = __toESM(require_dist(), 1);
+var import_promises110 = require("fs/promises");
+var import_yaml7 = __toESM(require_dist(), 1);
 
 // ../cli-migrations/lib/migrations/0.0.207/add-mode-to-draft-generators/getAllGeneratorYamlFiles.js
 var FERN_DIRECTORY4 = "fern";
@@ -1657480,18 +1657954,18 @@ var migration3 = {
   }
 };
 async function migrateGeneratorsYml(filepath, context2) {
-  const contents = await (0, import_promises109.readFile)(filepath);
-  const parsedDocument = import_yaml6.default.parseDocument(contents.toString());
+  const contents = await (0, import_promises110.readFile)(filepath);
+  const parsedDocument = import_yaml7.default.parseDocument(contents.toString());
   const draftGenerators = parsedDocument.get("draft");
   if (draftGenerators == null) {
     return;
   }
-  if (!import_yaml6.default.isSeq(draftGenerators)) {
+  if (!import_yaml7.default.isSeq(draftGenerators)) {
     context2.failWithoutThrowing(`draft generators are not a list in ${filepath}`);
     return;
   }
   draftGenerators.items.forEach((draftGenerator) => {
-    if (!import_yaml6.default.isMap(draftGenerator)) {
+    if (!import_yaml7.default.isMap(draftGenerator)) {
       context2.failWithoutThrowing(`draft generator is not an object in ${filepath}`);
       return;
     }
@@ -1657507,7 +1657981,7 @@ async function migrateGeneratorsYml(filepath, context2) {
       draftGenerator.set("output-path", name3.value.includes("openapi") ? "./generated-openapi" : name3.value.includes("postman") ? "./generated-postman" : localOutput);
     }
   });
-  await (0, import_promises109.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises110.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.0.207/index.js
@@ -1657518,8 +1657992,8 @@ var versionMigrations3 = {
 var __default3 = versionMigrations3;
 
 // ../cli-migrations/lib/migrations/0.0.210/remove-inline-error-declarations/migration.js
-var import_promises110 = require("fs/promises");
-var import_yaml7 = __toESM(require_dist(), 1);
+var import_promises111 = require("fs/promises");
+var import_yaml8 = __toESM(require_dist(), 1);
 
 // ../cli-migrations/lib/migrations/0.0.210/remove-inline-error-declarations/getAllYamlFiles.js
 var FERN_DIRECTORY5 = "fern";
@@ -1657559,15 +1658033,15 @@ var migration4 = {
   }
 };
 async function migrateFile2(filepath, context2) {
-  const contents = await (0, import_promises110.readFile)(filepath);
-  const parsedDocument = import_yaml7.default.parseDocument(contents.toString());
+  const contents = await (0, import_promises111.readFile)(filepath);
+  const parsedDocument = import_yaml8.default.parseDocument(contents.toString());
   const addType = (typeName, typeDeclaration) => {
     const types4 = parsedDocument.get("types");
     if (types4 == null) {
       parsedDocument.set("types", {
         [typeName]: typeDeclaration
       });
-    } else if (!import_yaml7.default.isMap(types4)) {
+    } else if (!import_yaml8.default.isMap(types4)) {
       context2.failWithoutThrowing(`"types" is not a map in ${filepath}`);
     } else {
       types4.set(typeName, typeDeclaration);
@@ -1657577,12 +1658051,12 @@ async function migrateFile2(filepath, context2) {
   if (errors4 == null) {
     return;
   }
-  if (!import_yaml7.default.isMap(errors4)) {
+  if (!import_yaml8.default.isMap(errors4)) {
     context2.failWithoutThrowing(`"errors" is not a map in ${filepath}`);
     return;
   }
   for (const errorDeclaration of errors4.items) {
-    if (!import_yaml7.default.isMap(errorDeclaration.value)) {
+    if (!import_yaml8.default.isMap(errorDeclaration.value)) {
       context2.failWithoutThrowing(`Error "${errorDeclaration.key}" is not a map in ${filepath}`);
       continue;
     }
@@ -1657594,7 +1658068,7 @@ async function migrateFile2(filepath, context2) {
     }
     const httpSection = errorDeclaration.value.get("http");
     if (httpSection != null) {
-      if (!import_yaml7.default.isMap(httpSection)) {
+      if (!import_yaml8.default.isMap(httpSection)) {
         context2.failWithoutThrowing(`http in "${errorDeclaration.key}" is not a map in ${filepath}`);
       } else {
         const statusCode = httpSection.get("statusCode", true);
@@ -1657603,7 +1658077,7 @@ async function migrateFile2(filepath, context2) {
       }
     }
   }
-  await (0, import_promises110.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises111.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.0.210/index.js
@@ -1657614,8 +1658088,8 @@ var versionMigrations4 = {
 var __default4 = versionMigrations4;
 
 // ../cli-migrations/lib/migrations/0.0.212/add-publishing-to-release-generators/migration.js
-var import_promises111 = require("fs/promises");
-var import_yaml8 = __toESM(require_dist(), 1);
+var import_promises112 = require("fs/promises");
+var import_yaml9 = __toESM(require_dist(), 1);
 
 // ../cli-migrations/lib/migrations/0.0.212/add-publishing-to-release-generators/getAllGeneratorYamlFiles.js
 var FERN_DIRECTORY6 = "fern";
@@ -1657655,37 +1658129,37 @@ var migration5 = {
   }
 };
 async function migrateGeneratorsYml2(filepath, context2) {
-  const contents = await (0, import_promises111.readFile)(filepath);
-  const parsedDocument = import_yaml8.default.parseDocument(contents.toString());
+  const contents = await (0, import_promises112.readFile)(filepath);
+  const parsedDocument = import_yaml9.default.parseDocument(contents.toString());
   const releaseGenerators = parsedDocument.get("release");
   if (releaseGenerators == null) {
     return;
   }
-  if (!import_yaml8.default.isSeq(releaseGenerators)) {
+  if (!import_yaml9.default.isSeq(releaseGenerators)) {
     context2.failWithoutThrowing(`release generators are not a list in ${filepath}`);
     return;
   }
   releaseGenerators.items.forEach((releaseGenerator) => {
-    if (!import_yaml8.default.isMap(releaseGenerator)) {
+    if (!import_yaml9.default.isMap(releaseGenerator)) {
       context2.failWithoutThrowing(`release generator is not an object in ${filepath}`);
       return;
     }
     const outputs = releaseGenerator.get("outputs");
-    if (!import_yaml8.default.isMap(outputs)) {
+    if (!import_yaml9.default.isMap(outputs)) {
       context2.failWithoutThrowing(`outputs is not an object in ${filepath}`);
       return;
     }
     const githubOutput = outputs.get("github");
-    if (import_yaml8.default.isMap(githubOutput) && githubOutput.has("repository")) {
+    if (import_yaml9.default.isMap(githubOutput) && githubOutput.has("repository")) {
       releaseGenerator.set("github", githubOutput);
     }
     const publishing = {};
     const npmOutput = outputs.get("npm");
-    if (import_yaml8.default.isMap(npmOutput)) {
+    if (import_yaml9.default.isMap(npmOutput)) {
       publishing.npm = npmOutput;
     }
     const mavenOutput = outputs.get("maven");
-    if (import_yaml8.default.isMap(mavenOutput)) {
+    if (import_yaml9.default.isMap(mavenOutput)) {
       publishing.maven = mavenOutput;
     }
     if (Object.keys(publishing).length > 0) {
@@ -1657693,7 +1658167,7 @@ async function migrateGeneratorsYml2(filepath, context2) {
     }
     releaseGenerator.delete("outputs");
   });
-  await (0, import_promises111.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises112.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.0.212/index.js
@@ -1657704,7 +1658178,7 @@ var versionMigrations5 = {
 var __default5 = versionMigrations5;
 
 // ../cli-migrations/lib/migrations/0.0.220/rename-alias-key-to-type/migration.js
-var import_promises112 = require("fs/promises");
+var import_promises113 = require("fs/promises");
 
 // ../cli-migrations/lib/migrations/0.0.220/rename-alias-key-to-type/getAllYamlFiles.js
 var FERN_DIRECTORY7 = "fern";
@@ -1657735,9 +1658209,9 @@ var migration6 = {
   run: async ({ context: context2 }) => {
     const yamlFiles = await getAllYamlFiles4(context2);
     for (const filepath of yamlFiles) {
-      const contents = await (0, import_promises112.readFile)(filepath);
+      const contents = await (0, import_promises113.readFile)(filepath);
       const newContents = contents.toString().replaceAll(" alias:", " type:");
-      await (0, import_promises112.writeFile)(filepath, newContents);
+      await (0, import_promises113.writeFile)(filepath, newContents);
     }
   }
 };
@@ -1657750,7 +1658224,7 @@ var versionMigrations6 = {
 var __default6 = versionMigrations6;
 
 // ../cli-migrations/lib/migrations/0.0.221/add-error-discriminant/migration.js
-var import_promises113 = require("fs/promises");
+var import_promises114 = require("fs/promises");
 
 // ../cli-migrations/lib/migrations/0.0.221/add-error-discriminant/getAllRootApiYamlFiles.js
 var FERN_DIRECTORY8 = "fern";
@@ -1657781,9 +1658255,9 @@ var migration7 = {
   run: async ({ context: context2 }) => {
     const yamlFiles = await getAllRootApiYamlFiles(context2);
     for (const filepath of yamlFiles) {
-      const contents = await (0, import_promises113.readFile)(filepath);
+      const contents = await (0, import_promises114.readFile)(filepath);
       const newContents = contents.toString() + "\nerror-discriminant: error";
-      await (0, import_promises113.writeFile)(filepath, newContents);
+      await (0, import_promises114.writeFile)(filepath, newContents);
     }
   }
 };
@@ -1657796,7 +1658270,7 @@ var versionMigrations7 = {
 var __default7 = versionMigrations7;
 
 // ../cli-migrations/lib/migrations/0.0.241/add-generator-groups/migration.js
-var import_promises114 = require("fs/promises");
+var import_promises115 = require("fs/promises");
 
 // ../cli-migrations/lib/migrations/0.0.241/add-generator-groups/getAllGeneratorYamlFiles.js
 var FERN_DIRECTORY9 = "fern";
@@ -1657903,7 +1658377,7 @@ var migration8 = {
   }
 };
 async function migrateGeneratorsYml3(filepath) {
-  const contentsStr = await (0, import_promises114.readFile)(filepath);
+  const contentsStr = await (0, import_promises115.readFile)(filepath);
   const contents = jsYaml.load(contentsStr.toString());
   const oldGeneratorsConfiguration = GeneratorsConfigurationSchema2.parse(contents);
   let newGeneratorsConfiguration = {};
@@ -1657921,7 +1658395,7 @@ async function migrateGeneratorsYml3(filepath) {
       generators: oldGeneratorsConfiguration.release.map((releaseGeneratorInvocation) => convertReleaseGeneratorInvocation(releaseGeneratorInvocation))
     };
   }
-  await (0, import_promises114.writeFile)(filepath, jsYaml.dump(newGeneratorsConfiguration));
+  await (0, import_promises115.writeFile)(filepath, jsYaml.dump(newGeneratorsConfiguration));
 }
 function convertDraftGeneratorInvocation(draftGeneratorInvocation) {
   const newSchema = {
@@ -1657996,8 +1658470,8 @@ var versionMigrations8 = {
 var __default8 = versionMigrations8;
 
 // ../cli-migrations/lib/migrations/0.0.248/add-error-discrimination-config/migration.js
-var import_promises115 = require("fs/promises");
-var import_yaml9 = __toESM(require_dist(), 1);
+var import_promises116 = require("fs/promises");
+var import_yaml10 = __toESM(require_dist(), 1);
 
 // ../cli-migrations/lib/migrations/0.0.248/add-error-discrimination-config/getAllRootApiYamlFiles.js
 var FERN_DIRECTORY10 = "fern";
@@ -1658037,10 +1658511,10 @@ var migration9 = {
   }
 };
 async function migrateRootApiFile(filepath) {
-  const contents = await (0, import_promises115.readFile)(filepath);
-  const parsedDocument = import_yaml9.default.parseDocument(contents.toString());
+  const contents = await (0, import_promises116.readFile)(filepath);
+  const parsedDocument = import_yaml10.default.parseDocument(contents.toString());
   const errorDiscriminant = parsedDocument.get("error-discriminant", true);
-  if (errorDiscriminant == null || !import_yaml9.default.isScalar(errorDiscriminant) || typeof errorDiscriminant.value !== "string") {
+  if (errorDiscriminant == null || !import_yaml10.default.isScalar(errorDiscriminant) || typeof errorDiscriminant.value !== "string") {
     return;
   }
   parsedDocument.set("error-discrimination", {
@@ -1658048,7 +1658522,7 @@ async function migrateRootApiFile(filepath) {
     "property-name": errorDiscriminant.value
   });
   parsedDocument.delete("error-discriminant");
-  await (0, import_promises115.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises116.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.0.248/index.js
@@ -1658059,8 +1658533,8 @@ var versionMigrations9 = {
 var __default9 = versionMigrations9;
 
 // ../cli-migrations/lib/migrations/0.1.3-rc3/add-inline-requests/migration.js
-var import_promises116 = require("fs/promises");
-var import_yaml10 = __toESM(require_dist(), 1);
+var import_promises117 = require("fs/promises");
+var import_yaml11 = __toESM(require_dist(), 1);
 
 // ../cli-migrations/lib/migrations/0.1.3-rc3/add-inline-requests/getAllYamlFiles.js
 var FERN_DIRECTORY11 = "fern";
@@ -1658100,24 +1658574,24 @@ var migration10 = {
   }
 };
 async function migrateYamlFile(filepath, context2) {
-  const contents = await (0, import_promises116.readFile)(filepath);
-  const parsedDocument = import_yaml10.default.parseDocument(contents.toString());
+  const contents = await (0, import_promises117.readFile)(filepath);
+  const parsedDocument = import_yaml11.default.parseDocument(contents.toString());
   const services = parsedDocument.get("services");
   if (services == null) {
     return;
   }
-  if (!import_yaml10.default.isMap(services)) {
+  if (!import_yaml11.default.isMap(services)) {
     throw new Error("'services' is not a map");
   }
   const httpServices = services.get("http");
   if (httpServices == null) {
     return;
   }
-  if (!import_yaml10.default.isMap(httpServices)) {
+  if (!import_yaml11.default.isMap(httpServices)) {
     throw new Error("'http' is not a map");
   }
   for (const service of httpServices.items) {
-    if (!import_yaml10.default.isMap(service.value)) {
+    if (!import_yaml11.default.isMap(service.value)) {
       context2.failWithoutThrowing(`Service '${service.key}' is not a map`);
       continue;
     }
@@ -1658125,12 +1658599,12 @@ async function migrateYamlFile(filepath, context2) {
     if (endpoints == null) {
       continue;
     }
-    if (!import_yaml10.default.isMap(endpoints)) {
+    if (!import_yaml11.default.isMap(endpoints)) {
       context2.failWithoutThrowing(`Endpoints are not a map in service '${service.key}'`);
       continue;
     }
     for (const endpoint3 of endpoints.items) {
-      if (!import_yaml10.default.isMap(endpoint3.value)) {
+      if (!import_yaml11.default.isMap(endpoint3.value)) {
         context2.failWithoutThrowing(`Endpoint ${endpoint3.key} is not a map in service '${service.key}'`);
         continue;
       }
@@ -1658140,14 +1658614,14 @@ async function migrateYamlFile(filepath, context2) {
         context2.failWithoutThrowing("Failed to convert endpoint", e6);
       }
     }
-    await (0, import_promises116.writeFile)(filepath, parsedDocument.toString());
+    await (0, import_promises117.writeFile)(filepath, parsedDocument.toString());
   }
 }
 function convertEndpoint20({ document: document4, endpoint: endpoint3 }) {
-  const newRequest = new import_yaml10.default.YAMLMap();
+  const newRequest = new import_yaml11.default.YAMLMap();
   const parsedRequestBody = parseRequestBody(endpoint3);
   if (parsedRequestBody != null) {
-    let newBody = new import_yaml10.default.YAMLMap();
+    let newBody = new import_yaml11.default.YAMLMap();
     const { requestBodyType, docs: originalRequestDocs } = parsedRequestBody;
     if (originalRequestDocs != null) {
       newBody.set("docs", originalRequestDocs);
@@ -1658155,11 +1658629,11 @@ function convertEndpoint20({ document: document4, endpoint: endpoint3 }) {
     newBody.set("type", requestBodyType);
     const documentTypes = document4.get("types");
     if (documentTypes != null) {
-      if (!import_yaml10.default.isMap(documentTypes)) {
+      if (!import_yaml11.default.isMap(documentTypes)) {
         throw new Error("types are not a map");
       }
       const maybeTypeDeclarationForRequest = documentTypes.get(requestBodyType);
-      if (maybeTypeDeclarationForRequest != null && import_yaml10.default.isMap(maybeTypeDeclarationForRequest)) {
+      if (maybeTypeDeclarationForRequest != null && import_yaml11.default.isMap(maybeTypeDeclarationForRequest)) {
         const objectExtends = maybeTypeDeclarationForRequest.get("extends");
         const objectProperties = maybeTypeDeclarationForRequest.get("properties");
         if (objectExtends != null || objectProperties != null) {
@@ -1658194,7 +1658668,7 @@ function parseRequestBody(endpoint3) {
   if (typeof requestBody === "string") {
     return { requestBodyType: requestBody, docs: void 0 };
   }
-  if (import_yaml10.default.isMap(requestBody)) {
+  if (import_yaml11.default.isMap(requestBody)) {
     const type8 = requestBody.get("type");
     if (type8 == null) {
       throw new Error("request type does not exist");
@@ -1658219,8 +1658693,8 @@ var versionMigrations10 = {
 var __default10 = versionMigrations10;
 
 // ../cli-migrations/lib/migrations/0.3.0-rc12/add-value-key-to-type-examples/migration.js
-var import_promises117 = require("fs/promises");
-var import_yaml11 = __toESM(require_dist(), 1);
+var import_promises118 = require("fs/promises");
+var import_yaml12 = __toESM(require_dist(), 1);
 
 // ../cli-migrations/lib/migrations/0.3.0-rc12/add-value-key-to-type-examples/getAllYamlFiles.js
 var FERN_DIRECTORY12 = "fern";
@@ -1658260,24 +1658734,24 @@ var migration11 = {
   }
 };
 async function migrateYamlFile2(filepath, context2) {
-  const contents = await (0, import_promises117.readFile)(filepath);
-  const parsedDocument = import_yaml11.default.parseDocument(contents.toString());
+  const contents = await (0, import_promises118.readFile)(filepath);
+  const parsedDocument = import_yaml12.default.parseDocument(contents.toString());
   const types4 = parsedDocument.get("types");
   if (types4 == null) {
     return;
   }
-  if (!import_yaml11.default.isMap(types4)) {
+  if (!import_yaml12.default.isMap(types4)) {
     throw new Error("'types' is not a map");
   }
   for (const type8 of types4.items) {
-    if (!import_yaml11.default.isMap(type8.value)) {
+    if (!import_yaml12.default.isMap(type8.value)) {
       continue;
     }
     const examples = type8.value.get("examples");
     if (examples == null) {
       continue;
     }
-    if (!import_yaml11.default.isSeq(examples)) {
+    if (!import_yaml12.default.isSeq(examples)) {
       context2.failWithoutThrowing("'examples' are not a list");
       continue;
     }
@@ -1658286,7 +1658760,7 @@ async function migrateYamlFile2(filepath, context2) {
       examples.set(i11, { value });
     }
   }
-  await (0, import_promises117.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises118.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.3.0-rc12/index.js
@@ -1658297,8 +1658771,8 @@ var versionMigrations11 = {
 var __default11 = versionMigrations11;
 
 // ../cli-migrations/lib/migrations/0.3.23/change-services-key-to-service/migration.js
-var import_promises118 = require("fs/promises");
-var import_yaml12 = __toESM(require_dist(), 1);
+var import_promises119 = require("fs/promises");
+var import_yaml13 = __toESM(require_dist(), 1);
 
 // ../cli-migrations/lib/migrations/0.3.23/change-services-key-to-service/getAllYamlFiles.js
 var FERN_DIRECTORY13 = "fern";
@@ -1658338,14 +1658812,14 @@ var migration12 = {
   }
 };
 async function migrateYamlFile3(filepath, context2) {
-  const contents = await (0, import_promises118.readFile)(filepath);
-  const parsedDocument = import_yaml12.default.parseDocument(contents.toString());
-  if (!import_yaml12.default.isMap(parsedDocument.contents)) {
+  const contents = await (0, import_promises119.readFile)(filepath);
+  const parsedDocument = import_yaml13.default.parseDocument(contents.toString());
+  if (!import_yaml13.default.isMap(parsedDocument.contents)) {
     return context2.failAndThrow("File is not a map");
   }
   for (const pair of parsedDocument.contents.items) {
-    if (import_yaml12.default.isScalar(pair.key) && pair.key.value === "services") {
-      if (!import_yaml12.default.isMap(pair.value)) {
+    if (import_yaml13.default.isScalar(pair.key) && pair.key.value === "services") {
+      if (!import_yaml13.default.isMap(pair.value)) {
         return context2.failAndThrow("Services are not a map");
       }
       const httpServices = pair.value.get("http");
@@ -1658353,7 +1658827,7 @@ async function migrateYamlFile3(filepath, context2) {
         parsedDocument.contents.delete("services");
         return;
       }
-      if (!import_yaml12.default.isMap(httpServices)) {
+      if (!import_yaml13.default.isMap(httpServices)) {
         return context2.failAndThrow("http is not a map");
       }
       const [firstService, ...remainingServices] = httpServices.items;
@@ -1658368,7 +1658842,7 @@ async function migrateYamlFile3(filepath, context2) {
       pair.value = firstService.value;
     }
   }
-  await (0, import_promises118.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises119.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.3.23/index.js
@@ -1658379,8 +1658853,8 @@ var versionMigrations12 = {
 var __default12 = versionMigrations12;
 
 // ../cli-migrations/lib/migrations/0.5.4/move-service-docs-to-top-level/migration.js
-var import_promises119 = require("fs/promises");
-var import_yaml13 = __toESM(require_dist(), 1);
+var import_promises120 = require("fs/promises");
+var import_yaml14 = __toESM(require_dist(), 1);
 
 // ../cli-migrations/lib/migrations/0.5.4/move-service-docs-to-top-level/getAllYamlFiles.js
 var FERN_DIRECTORY14 = "fern";
@@ -1658420,26 +1658894,26 @@ var migration13 = {
   }
 };
 async function migrateYamlFile4(filepath, context2) {
-  const contents = await (0, import_promises119.readFile)(filepath);
-  const parsedDocument = import_yaml13.default.parseDocument(contents.toString());
-  if (!import_yaml13.default.isMap(parsedDocument.contents)) {
+  const contents = await (0, import_promises120.readFile)(filepath);
+  const parsedDocument = import_yaml14.default.parseDocument(contents.toString());
+  if (!import_yaml14.default.isMap(parsedDocument.contents)) {
     return context2.failAndThrow("File is not a map");
   }
   const service = parsedDocument.contents.get("service");
   if (service == null) {
     return;
   }
-  if (!import_yaml13.default.isMap(service)) {
+  if (!import_yaml14.default.isMap(service)) {
     return context2.failAndThrow("service is not a map");
   }
-  const indexOfServiceDocsPair = service.items.findIndex((item) => import_yaml13.default.isScalar(item.key) && item.key.value === "docs");
+  const indexOfServiceDocsPair = service.items.findIndex((item) => import_yaml14.default.isScalar(item.key) && item.key.value === "docs");
   const docsPair = service.items[indexOfServiceDocsPair];
   if (docsPair == null) {
     return;
   }
   service.items.splice(indexOfServiceDocsPair, 1);
   parsedDocument.contents.items.unshift(docsPair);
-  await (0, import_promises119.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises120.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.5.4/index.js
@@ -1658450,7 +1658924,7 @@ var versionMigrations13 = {
 var __default13 = versionMigrations13;
 
 // ../cli-migrations/lib/migrations/0.9.10/add-suffix-to-docs-domain/migration.js
-var import_promises120 = require("fs/promises");
+var import_promises121 = require("fs/promises");
 
 // ../cli-migrations/lib/migrations/0.9.10/add-suffix-to-docs-domain/getAllGeneratorYamlFiles.js
 var FERN_DIRECTORY15 = "fern";
@@ -1658490,14 +1658964,14 @@ var migration14 = {
   }
 };
 async function migrateYamlFile5(filepath) {
-  const contents = await (0, import_promises120.readFile)(filepath);
+  const contents = await (0, import_promises121.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_promises120.writeFile)(filepath, updatedSnapshot.toString());
+  await (0, import_promises121.writeFile)(filepath, updatedSnapshot.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.9.10/index.js
@@ -1658513,10 +1658987,10 @@ var import_legacy_docs_config = __toESM(require_legacy_docs_config(), 1);
 var LegacyDocsSerializers = __toESM(require_serialization44(), 1);
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/docs-config/loadRawDocsConfiguration.js
-var import_promises121 = require("fs/promises");
+var import_promises122 = require("fs/promises");
 async function loadRawDocsConfiguration2({ absolutePathToWorkspace }) {
   const filepath = getAbsolutePathToDocsYaml({ absolutePathToWorkspace });
-  const contentsStr = await (0, import_promises121.readFile)(filepath);
+  const contentsStr = await (0, import_promises122.readFile)(filepath);
   const contentsParsed = jsYaml.load(contentsStr.toString());
   const result = await LegacyDocsSerializers.DocsConfiguration.parse(contentsParsed);
   if (result.ok) {
@@ -1658534,7 +1659008,7 @@ function getAbsolutePathToDocsFolder({ absolutePathToWorkspace }) {
 }
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/migrateDocsAndMultipleAPIs.js
-var import_promises123 = require("fs/promises");
+var import_promises124 = require("fs/promises");
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/docs-config/convertLegacyDocsConfig.js
 function convertLegacyDocsConfig({ docsConfiguration, docsURLs, apiName }) {
@@ -1658712,10 +1659186,10 @@ __export(legacy_exports, {
 });
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/generators-configuration/loadRawGeneratorsConfiguration.js
-var import_promises122 = require("fs/promises");
+var import_promises123 = require("fs/promises");
 async function loadRawGeneratorsConfiguration2({ absolutePathToWorkspace }) {
   const filepath = getAbsolutePathToGeneratorsConfiguration({ absolutePathToWorkspace });
-  const contentsStr = await (0, import_promises122.readFile)(filepath);
+  const contentsStr = await (0, import_promises123.readFile)(filepath);
   const contentsParsed = jsYaml.load(contentsStr.toString());
   const result = await legacy_exports.GeneratorsConfigurationSchema.safeParseAsync(contentsParsed);
   if (result.success) {
@@ -1658745,7 +1659219,7 @@ function migrateDocsInstances(docsURLs) {
 var APIS_DIRECTORY2 = "apis";
 async function migrateDocsAndMultipleAPIs({ absolutePathToFernDirectory, workspaces, workspaceContainingDocs }) {
   const absolutePathToApisDirectory = join2(absolutePathToFernDirectory, RelativeFilePath2.of(APIS_DIRECTORY2));
-  await (0, import_promises123.mkdir)(absolutePathToApisDirectory);
+  await (0, import_promises124.mkdir)(absolutePathToApisDirectory);
   for (const workspace of workspaces) {
     const absolutePathToWorkspace = join2(absolutePathToFernDirectory, RelativeFilePath2.of(workspace));
     const docsURLs = await migrateAndWriteGeneratorsYml({ absolutePathToWorkspace });
@@ -1658753,11 +1659227,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_promises123.rm)(absolutePathToDocsFolder, { recursive: true });
+      await (0, import_promises124.rm)(absolutePathToDocsFolder, { recursive: true });
     }
     const absolutePathToNestedWorkspace = join2(absolutePathToApisDirectory, RelativeFilePath2.of(workspace));
     await moveFolder({ src: absolutePathToWorkspace, dest: absolutePathToNestedWorkspace });
-    await (0, import_promises123.rm)(absolutePathToWorkspace, { recursive: true });
+    await (0, import_promises124.rm)(absolutePathToWorkspace, { recursive: true });
   }
 }
 async function migrateAndWriteGeneratorsYml({ absolutePathToWorkspace }) {
@@ -1658770,7 +1659244,7 @@ async function migrateAndWriteGeneratorsYml({ absolutePathToWorkspace }) {
     generatorsConfiguration,
     pathModificationStrategy: PathModificationStrategy.Nest
   });
-  await (0, import_promises123.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
+  await (0, import_promises124.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
   return convertedResponse.docsURLs;
 }
 async function migrateAndWriteDocsYml({ absolutePathToWorkspace, docsURLs, apiName }) {
@@ -1658784,19 +1659258,19 @@ async function migrateAndWriteDocsYml({ absolutePathToWorkspace, docsURLs, apiNa
     apiName
   });
   const absolutePathToDocsConfig = getAbsolutePathToDocsYaml({ absolutePathToWorkspace });
-  await (0, import_promises123.writeFile)(absolutePathToDocsConfig, jsYaml.dump(convertedDocsConfig));
+  await (0, import_promises124.writeFile)(absolutePathToDocsConfig, jsYaml.dump(convertedDocsConfig));
 }
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/migrateDocsAndSingleAPI.js
-var import_promises124 = require("fs/promises");
+var import_promises125 = 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_promises124.rm)(absolutePathToDocsFolder, { recursive: true });
-  await (0, import_promises124.rm)(absolutePathToWorkspace, { recursive: true });
+  await (0, import_promises125.rm)(absolutePathToDocsFolder, { recursive: true });
+  await (0, import_promises125.rm)(absolutePathToWorkspace, { recursive: true });
 }
 async function migrateAndWriteDocsYml2({ absolutePathToWorkspace, docsURLs }) {
   const docsConfiguration = await loadRawDocsConfiguration2({ absolutePathToWorkspace });
@@ -1658809,7 +1659283,7 @@ async function migrateAndWriteDocsYml2({ absolutePathToWorkspace, docsURLs }) {
     apiName: void 0
   });
   const absolutePathToDocsConfig = getAbsolutePathToDocsYaml({ absolutePathToWorkspace });
-  await (0, import_promises124.writeFile)(absolutePathToDocsConfig, jsYaml.dump(convertedDocsConfig));
+  await (0, import_promises125.writeFile)(absolutePathToDocsConfig, jsYaml.dump(convertedDocsConfig));
 }
 async function migrateAndWriteGeneratorsYml2({ absolutePathToWorkspace }) {
   const generatorsConfiguration = await loadRawGeneratorsConfiguration2({ absolutePathToWorkspace });
@@ -1658821,22 +1659295,22 @@ async function migrateAndWriteGeneratorsYml2({ absolutePathToWorkspace }) {
     generatorsConfiguration,
     pathModificationStrategy: "MoveUp"
   });
-  await (0, import_promises124.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
+  await (0, import_promises125.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
   return convertedResponse.docsURLs;
 }
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/migrateOnlyMultipleAPIs.js
-var import_promises125 = require("fs/promises");
+var import_promises126 = require("fs/promises");
 var APIS_DIRECTORY3 = "apis";
 async function migrateOnlyMultipleAPIs({ absolutePathToFernDirectory, workspaces }) {
   const absolutePathToApisDirectory = join2(absolutePathToFernDirectory, RelativeFilePath2.of(APIS_DIRECTORY3));
-  await (0, import_promises125.mkdir)(absolutePathToApisDirectory);
+  await (0, import_promises126.mkdir)(absolutePathToApisDirectory);
   for (const workspace of workspaces) {
     const absolutePathToWorkspace = join2(absolutePathToFernDirectory, RelativeFilePath2.of(workspace));
     await migrateAndWriteGeneratorsYml3({ absolutePathToWorkspace });
     const absolutePathToNestedWorkspace = join2(absolutePathToApisDirectory, RelativeFilePath2.of(workspace));
     await moveFolder({ src: absolutePathToWorkspace, dest: absolutePathToNestedWorkspace });
-    await (0, import_promises125.rm)(absolutePathToWorkspace, { recursive: true });
+    await (0, import_promises126.rm)(absolutePathToWorkspace, { recursive: true });
   }
 }
 async function migrateAndWriteGeneratorsYml3({ absolutePathToWorkspace }) {
@@ -1658849,15 +1659323,15 @@ async function migrateAndWriteGeneratorsYml3({ absolutePathToWorkspace }) {
     generatorsConfiguration,
     pathModificationStrategy: PathModificationStrategy.Nest
   });
-  await (0, import_promises125.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
+  await (0, import_promises126.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
 }
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/migrateOnlySingleAPI.js
-var import_promises126 = require("fs/promises");
+var import_promises127 = require("fs/promises");
 async function migrateOnlySingleAPI({ absolutePathToFernDirectory, absolutePathToWorkspace }) {
   await migrateAndWriteGeneratorsYml4({ absolutePathToWorkspace });
   await moveFolder({ src: absolutePathToWorkspace, dest: absolutePathToFernDirectory });
-  await (0, import_promises126.rm)(absolutePathToWorkspace, { recursive: true });
+  await (0, import_promises127.rm)(absolutePathToWorkspace, { recursive: true });
 }
 async function migrateAndWriteGeneratorsYml4({ absolutePathToWorkspace }) {
   const generatorsConfiguration = await loadRawGeneratorsConfiguration2({ absolutePathToWorkspace });
@@ -1658869,7 +1659343,7 @@ async function migrateAndWriteGeneratorsYml4({ absolutePathToWorkspace }) {
     generatorsConfiguration,
     pathModificationStrategy: "MoveUp"
   });
-  await (0, import_promises126.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
+  await (0, import_promises127.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
 }
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/migration.js
@@ -1658946,8 +1659420,8 @@ var versionMigrations15 = {
 var __default15 = versionMigrations15;
 
 // ../cli-migrations/lib/migrations/0.41.0-rc0/require-generators-yml/migration.js
-var import_promises127 = require("fs/promises");
-var import_yaml14 = __toESM(require_dist(), 1);
+var import_promises128 = require("fs/promises");
+var import_yaml15 = __toESM(require_dist(), 1);
 var migration16 = {
   name: "require-generators-yml",
   summary: "A generators.yml file is now required if you are using OpenAPI, AsyncAPI, or gRPC.",
@@ -1658989,7 +1659463,7 @@ async function addApiConfigurationToSingleWorkspace({ absolutePathToFernDirector
   if (existingGeneratorsYml == null) {
     if (openapiDirectory != null && openapiDirectory.contents[0] != null) {
       const absolutePathToGeneratorsYml = join2(absoluteFilepathToWorkspace, RelativeFilePath2.of("generators.yml"));
-      await (0, import_promises127.writeFile)(absolutePathToGeneratorsYml, jsYaml.dump({
+      await (0, import_promises128.writeFile)(absolutePathToGeneratorsYml, jsYaml.dump({
         api: {
           path: join2(relativize(absolutePathToFernDirectory, absoluteFilepathToWorkspace), RelativeFilePath2.of(openapiDirectory.name), RelativeFilePath2.of(openapiDirectory.contents[0]?.name))
         }
@@ -1659000,11 +1659474,11 @@ async function addApiConfigurationToSingleWorkspace({ absolutePathToFernDirector
     const generatorsYmlContents = jsYaml.load(existingGeneratorsYml.contents);
     if (generatorsYmlContents?.api != null) {
     } else if (openapiDirectory != null && openapiDirectory.contents[0] != null) {
-      const parsedDocument = import_yaml14.default.parseDocument(existingGeneratorsYml.contents);
+      const parsedDocument = import_yaml15.default.parseDocument(existingGeneratorsYml.contents);
       parsedDocument.set("api", {
         path: join2(relativize(absolutePathToFernDirectory, absoluteFilepathToWorkspace), RelativeFilePath2.of(openapiDirectory.name), RelativeFilePath2.of(openapiDirectory.contents[0]?.name))
       });
-      await (0, import_promises127.writeFile)(existingGeneratorsYml.absolutePath, parsedDocument.toString());
+      await (0, import_promises128.writeFile)(existingGeneratorsYml.absolutePath, parsedDocument.toString());
       context2.logger.info(source_default.green(`Updated ${existingGeneratorsYml.absolutePath}`));
     }
   }
@@ -1659031,8 +1659505,8 @@ var versionMigrations16 = {
 var __default16 = versionMigrations16;
 
 // ../cli-migrations/lib/migrations/0.54.0-rc0/use-generators-yml-specs/migration.js
-var import_promises128 = require("fs/promises");
-var import_yaml15 = __toESM(require_dist(), 1);
+var import_promises129 = require("fs/promises");
+var import_yaml16 = __toESM(require_dist(), 1);
 var migration17 = {
   name: "generators-yml-use-api-specs",
   summary: "API specification must use the api.specs[] array syntax.",
@@ -1659200,7 +1659674,7 @@ async function addApiConfigurationToSingleWorkspace2({ absoluteFilepathToWorkspa
   if (firstLine?.startsWith("# yaml-language-server:")) {
     schemaComment = firstLine;
   }
-  const parsedDocument = import_yaml15.default.parseDocument(generatorsYmlFile.contents);
+  const parsedDocument = import_yaml16.default.parseDocument(generatorsYmlFile.contents);
   parsedDocument.delete("api-settings");
   parsedDocument.delete("openapi");
   parsedDocument.delete("openapi-overrides");
@@ -1659211,7 +1659685,7 @@ async function addApiConfigurationToSingleWorkspace2({ absoluteFilepathToWorkspa
   if (schemaComment && documentToWrite.indexOf(schemaComment) === -1) {
     documentToWrite = `${schemaComment}${documentToWrite}`;
   }
-  await (0, import_promises128.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
+  await (0, import_promises129.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
   context2.logger.info(source_default.green(`Updated ${generatorsYmlFile.absolutePath}`));
 }
 async function parseApiSpec({ oldSpec, absoluteFilepathToWorkspace, files, directories, context: context2, namespace }) {
@@ -1659258,7 +1659732,7 @@ async function parseApiSpec({ oldSpec, absoluteFilepathToWorkspace, files, direc
   }
   let specContent;
   try {
-    const fileContents = await (0, import_promises128.readFile)(absoluteSpecPath, { encoding: "utf-8" });
+    const fileContents = await (0, import_promises129.readFile)(absoluteSpecPath, { encoding: "utf-8" });
     specContent = jsYaml.load(fileContents);
   } catch (e6) {
     context2.logger.warn(`Failed to read API spec file ${spec.path}. Error: ${e6}. Skipping...`);
@@ -1659361,7 +1659835,7 @@ var versionMigrations17 = {
 var __default17 = versionMigrations17;
 
 // ../cli-migrations/lib/migrations/0.82.1/add-path-parameter-order-setting/migration.js
-var import_promises129 = require("fs/promises");
+var import_promises130 = 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.
@@ -1659449,7 +1659923,7 @@ async function updateGeneratorsYml({ context: context2, files }) {
     documentToWrite = `${schemaComment}
 ${documentToWrite}`;
   }
-  await (0, import_promises129.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
+  await (0, import_promises130.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
   context2.logger.info(source_default.green(`Updated ${generatorsYmlFile.absolutePath}`));
 }
 async function getFilesAndDirectories3(absoluteFilepath) {
@@ -1659485,7 +1659959,7 @@ var versionMigrations18 = {
 var __default18 = versionMigrations18;
 
 // ../cli-migrations/lib/migrations/1.0.0/update-settings-defaults/migration.js
-var import_promises130 = require("fs/promises");
+var import_promises131 = require("fs/promises");
 var migration19 = {
   name: "update-1_0_0-defaults",
   summary: `The defaults of the API spec settings have changed. 
@@ -1659660,7 +1660134,7 @@ async function updateGeneratorsYml2({ context: context2, files }) {
     documentToWrite = `${schemaComment}
 ${documentToWrite}`;
   }
-  await (0, import_promises130.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
+  await (0, import_promises131.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
   context2.logger.info(source_default.green(`Updated ${generatorsYmlFile.absolutePath}`));
 }
 async function getFilesAndDirectories4(absoluteFilepath) {
@@ -1659729,7 +1660203,7 @@ var versionMigrations19 = {
 var __default19 = versionMigrations19;
 
 // ../cli-migrations/lib/migrations/2.0.0-rc0/update-settings-defaults/migration.js
-var import_promises131 = require("fs/promises");
+var import_promises132 = 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. 
@@ -1659904,7 +1660378,7 @@ async function updateGeneratorsYml3({ context: context2, files }) {
     documentToWrite = `${schemaComment}
 ${documentToWrite}`;
   }
-  await (0, import_promises131.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
+  await (0, import_promises132.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
   context2.logger.info(source_default.green(`Updated ${generatorsYmlFile.absolutePath}`));
 }
 async function getFilesAndDirectories5(absoluteFilepath) {
@@ -1659950,7 +1660424,7 @@ var versionMigrations20 = {
 var __default20 = versionMigrations20;
 
 // ../cli-migrations/lib/migrations/2.13.0/migrate-deprecated-generator-api-settings/migration.js
-var import_promises132 = require("fs/promises");
+var import_promises133 = require("fs/promises");
 var migration21 = {
   name: "migrate-deprecated-generator-api-settings",
   summary: `Migrates deprecated generator-level API settings keys to their new equivalents:
@@ -1660041,7 +1660515,7 @@ async function updateGeneratorsYml4({ context: context2, files }) {
     documentToWrite = `${schemaComment}
 ${documentToWrite}`;
   }
-  await (0, import_promises132.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
+  await (0, import_promises133.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
   context2.logger.info(source_default.green(`Updated ${generatorsYmlFile.absolutePath}`));
 }
 function migrateDeprecatedSettings(settings, context2) {
@@ -1660087,7 +1660561,7 @@ var versionMigrations21 = {
 var __default21 = versionMigrations21;
 
 // ../cli-migrations/lib/migrations/3.0.0/enable-smart-casing/migration.js
-var import_promises133 = require("fs/promises");
+var import_promises134 = require("fs/promises");
 var migration22 = {
   name: "enable-smart-casing",
   summary: `Sets 'smart-casing: false' for existing generators to preserve backwards compatibility.
@@ -1660171,7 +1660645,7 @@ async function updateGeneratorsYml5({ context: context2, files }) {
     documentToWrite = `${schemaComment}
 ${documentToWrite}`;
   }
-  await (0, import_promises133.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
+  await (0, import_promises134.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
   context2.logger.info(source_default.green(`Updated ${generatorsYmlFile.absolutePath}`));
 }
 function setSmartCasingFalseIfNotConfigured(generator, context2) {
@@ -1660312,7 +1660786,7 @@ ${source_default.dim(migration23.summary)}`
 }
 
 // src/commands/upgrade/upgrade.ts
-var import_promises134 = require("fs/promises");
+var import_promises135 = require("fs/promises");
 
 // src/cwd.ts
 var FERN_CWD_ENV_VAR = "FERN_CWD";
@@ -1660629,7 +1661103,7 @@ async function upgrade({
     const newProjectConfig = produce(projectConfig2.rawConfig, (draft) => {
       draft.version = resolvedTargetVersion;
     });
-    await (0, import_promises134.writeFile)(
+    await (0, import_promises135.writeFile)(
       projectConfig2._absolutePath,
       ensureFinalNewline2(JSON.stringify(newProjectConfig, void 0, 2))
     );
@@ -1661054,7 +1661528,7 @@ async function validateWorkspaces({
 }
 
 // src/commands/write-definition/writeDefinitionForWorkspaces.ts
-var import_promises135 = require("fs/promises");
+var import_promises136 = require("fs/promises");
 var import_path61 = __toESM(require("path"), 1);
 async function writeDefinitionForWorkspaces({
   project,
@@ -1661135,27 +1661609,27 @@ async function writeFernDefinition({
     return a10.localeCompare(b18);
   };
   if (await doesPathExist(absolutePathToOutputDirectory)) {
-    await (0, import_promises135.rm)(absolutePathToOutputDirectory, { recursive: true });
+    await (0, import_promises136.rm)(absolutePathToOutputDirectory, { recursive: true });
   }
-  await (0, import_promises135.mkdir)(absolutePathToOutputDirectory, { recursive: true });
-  await (0, import_promises135.writeFile)(
+  await (0, import_promises136.mkdir)(absolutePathToOutputDirectory, { recursive: true });
+  await (0, import_promises136.writeFile)(
     join2(absolutePathToOutputDirectory, RelativeFilePath2.of(ROOT_API_FILENAME)),
     jsYaml.dump(definition3.rootApiFile.contents, { sortKeys })
   );
   for (const [relativePath, packageMarker] of Object.entries(definition3.packageMarkers)) {
     const absoluteFilepath = join2(absolutePathToOutputDirectory, RelativeFilePath2.of(relativePath));
-    await (0, import_promises135.mkdir)(dirname4(absoluteFilepath), { recursive: true });
-    await (0, import_promises135.writeFile)(absoluteFilepath, jsYaml.dump(packageMarker.contents, { sortKeys }));
+    await (0, import_promises136.mkdir)(dirname4(absoluteFilepath), { recursive: true });
+    await (0, import_promises136.writeFile)(absoluteFilepath, jsYaml.dump(packageMarker.contents, { sortKeys }));
   }
   for (const [relativePath, definitionFile] of Object.entries(definition3.namedDefinitionFiles)) {
     const absoluteFilepath = join2(absolutePathToOutputDirectory, RelativeFilePath2.of(relativePath));
-    await (0, import_promises135.mkdir)(dirname4(absoluteFilepath), { recursive: true });
-    await (0, import_promises135.writeFile)(absoluteFilepath, jsYaml.dump(definitionFile.contents, { sortKeys }));
+    await (0, import_promises136.mkdir)(dirname4(absoluteFilepath), { recursive: true });
+    await (0, import_promises136.writeFile)(absoluteFilepath, jsYaml.dump(definitionFile.contents, { sortKeys }));
   }
 }
 
 // src/commands/write-docs-definition/writeDocsDefinitionForProject.ts
-var import_promises136 = require("fs/promises");
+var import_promises137 = require("fs/promises");
 async function writeDocsDefinitionForProject({
   project,
   outputPath,
@@ -1661187,7 +1661661,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_promises136.writeFile)(AbsoluteFilePath2.of(outputPath), JSON.stringify(docsDefinition, null, 2));
+    await (0, import_promises137.writeFile)(AbsoluteFilePath2.of(outputPath), JSON.stringify(docsDefinition, null, 2));
     context2.logger.info(source_default.green(`Docs definition written to ${outputPath}`));
   });
 }
@@ -1661195,7 +1661669,7 @@ async function writeDocsDefinitionForProject({
 // src/commands/write-translation/writeTranslationForProject.ts
 var import_cli_progress2 = __toESM(require_cli_progress(), 1);
 var import_fs25 = require("fs");
-var import_promises140 = require("fs/promises");
+var import_promises141 = require("fs/promises");
 var import_is_ci2 = __toESM(require_is_ci(), 1);
 var import_path64 = __toESM(require("path"), 1);
 
@@ -1661680,7 +1662154,7 @@ function shouldProcessFile(filePath, stub) {
 }
 
 // src/commands/write-translation/docs-config-utils.ts
-var import_promises137 = require("fs/promises");
+var import_promises138 = require("fs/promises");
 
 // src/commands/write-translation/url-utils.ts
 function addLanguageSuffixToUrl(url3, language) {
@@ -1661837,7 +1662311,7 @@ async function createLanguageSpecificDocsConfig({
   stub = false
 }) {
   try {
-    const originalConfigContent = await (0, import_promises137.readFile)(originalDocsConfigPath, "utf-8");
+    const originalConfigContent = await (0, import_promises138.readFile)(originalDocsConfigPath, "utf-8");
     const transformation = {
       filePath: DOCS_CONFIGURATION_FILENAME,
       language,
@@ -1661851,7 +1662325,7 @@ async function createLanguageSpecificDocsConfig({
     const modifiedConfigContent = jsYaml.dump(modifiedConfig, {
       sortKeys: false
     });
-    await (0, import_promises137.writeFile)(modifiedConfigPath, modifiedConfigContent, "utf-8");
+    await (0, import_promises138.writeFile)(modifiedConfigPath, modifiedConfigContent, "utf-8");
     context2.logger.debug(`Created language-specific docs config: ${modifiedConfigPath}`);
   } catch (error49) {
     if (error49 instanceof Error && error49.message.includes("403")) {
@@ -1661863,11 +1662337,11 @@ async function createLanguageSpecificDocsConfig({
 
 // src/commands/write-translation/file-collection-utils.ts
 var import_fs23 = require("fs");
-var import_promises138 = require("fs/promises");
+var import_promises139 = require("fs/promises");
 var import_path62 = __toESM(require("path"), 1);
 async function collectFiles(baseDirectory, relativeBase) {
   const discoveredFiles = {};
-  const entries10 = await (0, import_promises138.readdir)(baseDirectory);
+  const entries10 = await (0, import_promises139.readdir)(baseDirectory);
   for (const entry of entries10) {
     if (entry === "translations") {
       continue;
@@ -1661890,7 +1662364,7 @@ async function collectFiles(baseDirectory, relativeBase) {
 // src/commands/write-translation/hash-utils.ts
 var import_crypto10 = require("crypto");
 var import_fs24 = require("fs");
-var import_promises139 = require("fs/promises");
+var import_promises140 = require("fs/promises");
 var import_path63 = __toESM(require("path"), 1);
 function calculateContentHash(content5) {
   return (0, import_crypto10.createHash)("sha256").update(content5, "utf-8").digest("hex");
@@ -1661901,7 +1662375,7 @@ async function loadHashMappings(translationsDirectory) {
     return {};
   }
   try {
-    const hashesContent = await (0, import_promises139.readFile)(hashesFilePath, "utf-8");
+    const hashesContent = await (0, import_promises140.readFile)(hashesFilePath, "utf-8");
     const parsed = JSON.parse(hashesContent);
     const { _comment, ...hashMappings } = parsed;
     return hashMappings;
@@ -1661922,11 +1662396,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_promises139.writeFile)(hashesFilePath, JSON.stringify(fileContent, null, 2), "utf-8");
+  await (0, import_promises140.writeFile)(hashesFilePath, JSON.stringify(fileContent, null, 2), "utf-8");
 }
 async function hasFileChanged(filePath, relativePath, previousHashes) {
   try {
-    const content5 = await (0, import_promises139.readFile)(filePath, "utf-8");
+    const content5 = await (0, import_promises140.readFile)(filePath, "utf-8");
     const currentHash = calculateContentHash(content5);
     const previousHash = previousHashes[relativePath];
     return currentHash !== previousHash;
@@ -1661979,7 +1662453,7 @@ async function writeTranslationForProject({
     }
     if (!(0, import_fs25.existsSync)(translationsDirectory)) {
       context2.logger.debug(`Creating translations directory at: ${translationsDirectory}`);
-      await (0, import_promises140.mkdir)(translationsDirectory, { recursive: true });
+      await (0, import_promises141.mkdir)(translationsDirectory, { recursive: true });
     }
     const languageStats = {};
     const targetLanguages = languages.filter((lang) => lang !== sourceLanguage);
@@ -1661992,7 +1662466,7 @@ async function writeTranslationForProject({
         RelativeFilePath2.of("fern")
       );
       if (!(0, import_fs25.existsSync)(languageDirectory)) {
-        await (0, import_promises140.mkdir)(languageDirectory, { recursive: true });
+        await (0, import_promises141.mkdir)(languageDirectory, { recursive: true });
       }
       languageStats[language] = {
         filesProcessed: 0,
@@ -1662094,7 +1662568,7 @@ async function writeTranslationForProject({
                 `[COMPLETED] ${DOCS_CONFIGURATION_FILENAME} -> ${language}/${DOCS_CONFIGURATION_FILENAME}`
               );
             }
-            const originalConfigContent = await (0, import_promises140.readFile)(originalDocsConfigPath, "utf-8");
+            const originalConfigContent = await (0, import_promises141.readFile)(originalDocsConfigPath, "utf-8");
             await updateAndSaveHashForFile(
               translationsDirectory,
               hashMappings,
@@ -1662139,7 +1662613,7 @@ async function writeTranslationForProject({
             continue;
           }
           cliContext.logger.debug(`[PROCESSING] ${relativePath} (detected changes)`);
-          const originalContent = await (0, import_promises140.readFile)(filePath, "utf-8");
+          const originalContent = await (0, import_promises141.readFile)(filePath, "utf-8");
           await updateAndSaveHashForFile(translationsDirectory, hashMappings, relativePath, originalContent);
           const sourceStats = languageStats[sourceLanguage];
           if (sourceStats) {
@@ -1662164,7 +1662638,7 @@ async function writeTranslationForProject({
             const destPath = join2(languageDirectory, relativePath);
             const destDir = import_path64.default.dirname(destPath);
             if (!(0, import_fs25.existsSync)(destDir)) {
-              await (0, import_promises140.mkdir)(destDir, { recursive: true });
+              await (0, import_promises141.mkdir)(destDir, { recursive: true });
             }
             const transformation = {
               filePath: relativePath,
@@ -1662177,7 +1662651,7 @@ async function writeTranslationForProject({
               cliContext,
               stub
             });
-            await (0, import_promises140.writeFile)(destPath, transformedContent, "utf-8");
+            await (0, import_promises141.writeFile)(destPath, transformedContent, "utf-8");
             const languageStatsForLang = languageStats[language];
             if (languageStatsForLang) {
               languageStatsForLang.filesProcessed++;
@@ -1662208,9 +1662682,9 @@ async function writeTranslationForProject({
             const destPath = join2(languageDirectory, relativePath);
             const destDir = import_path64.default.dirname(destPath);
             if (!(0, import_fs25.existsSync)(destDir)) {
-              await (0, import_promises140.mkdir)(destDir, { recursive: true });
+              await (0, import_promises141.mkdir)(destDir, { recursive: true });
             }
-            await (0, import_promises140.copyFile)(filePath, destPath);
+            await (0, import_promises141.copyFile)(filePath, destPath);
             assetsCopied++;
             cliContext.logger.debug(`[ASSET COPIED] ${relativePath} -> ${language}/${relativePath}`);
           }