@fern-api/generator-cli 0.9.14 → 0.9.16

package/dist/api.js

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -151,7 +154,7 @@ var require_ms = __commonJS({
 var require_common = __commonJS({
   "../../node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/common.js"(exports2, module2) {
     "use strict";
-    function setup(env) {
+    function setup(env2) {
       createDebug.debug = createDebug;
       createDebug.default = createDebug;
       createDebug.coerce = coerce;
@@ -160,8 +163,8 @@ var require_common = __commonJS({
       createDebug.enabled = enabled;
       createDebug.humanize = require_ms();
       createDebug.destroy = destroy;
-      Object.keys(env).forEach((key) => {
-        createDebug[key] = env[key];
+      Object.keys(env2).forEach((key) => {
+        createDebug[key] = env2[key];
       });
       createDebug.names = [];
       createDebug.skips = [];
@@ -516,7 +519,7 @@ var require_supports_color = __commonJS({
     "use strict";
     var os = require("os");
     var hasFlag = require_has_flag();
-    var env = process.env;
+    var env2 = process.env;
     var support = (level) => {
       if (level === 0) {
         return false;
@@ -551,42 +554,42 @@ var require_supports_color = __commonJS({
         }
         return 1;
       }
-      if ("CI" in env) {
-        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+      if ("CI" in env2) {
+        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI"].some((sign) => sign in env2) || env2.CI_NAME === "codeship") {
           return 1;
         }
         return 0;
       }
-      if ("TEAMCITY_VERSION" in env) {
-        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+      if ("TEAMCITY_VERSION" in env2) {
+        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env2.TEAMCITY_VERSION) ? 1 : 0;
       }
-      if ("TERM_PROGRAM" in env) {
-        const version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
-        switch (env.TERM_PROGRAM) {
+      if ("TERM_PROGRAM" in env2) {
+        const version2 = parseInt((env2.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+        switch (env2.TERM_PROGRAM) {
           case "iTerm.app":
-            return version >= 3 ? 3 : 2;
+            return version2 >= 3 ? 3 : 2;
           case "Hyper":
             return 3;
           case "Apple_Terminal":
             return 2;
         }
       }
-      if (/-256(color)?$/i.test(env.TERM)) {
+      if (/-256(color)?$/i.test(env2.TERM)) {
         return 2;
       }
-      if (/^screen|^xterm|^vt100|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+      if (/^screen|^xterm|^vt100|^rxvt|color|ansi|cygwin|linux/i.test(env2.TERM)) {
         return 1;
       }
-      if ("COLORTERM" in env) {
+      if ("COLORTERM" in env2) {
         return 1;
       }
-      if (env.TERM === "dumb") {
+      if (env2.TERM === "dumb") {
         return 0;
       }
       return 0;
     })();
-    if ("FORCE_COLOR" in env) {
-      supportLevel = parseInt(env.FORCE_COLOR, 10) === 0 ? 0 : supportLevel || 1;
+    if ("FORCE_COLOR" in env2) {
+      supportLevel = parseInt(env2.FORCE_COLOR, 10) === 0 ? 0 : supportLevel || 1;
     }
     module2.exports = process && support(supportLevel);
   }
@@ -727,153 +730,2636 @@ var require_node = __commonJS({
       } else {
         args[0] = getDate() + name + " " + args[0];
       }
-    }
-    function getDate() {
-      if (exports2.inspectOpts.hideDate) {
-        return "";
+    }
+    function getDate() {
+      if (exports2.inspectOpts.hideDate) {
+        return "";
+      }
+      return (/* @__PURE__ */ new Date()).toISOString() + " ";
+    }
+    function log(...args) {
+      return process.stderr.write(util.formatWithOptions(exports2.inspectOpts, ...args) + "\n");
+    }
+    function save(namespaces) {
+      if (namespaces) {
+        process.env.DEBUG = namespaces;
+      } else {
+        delete process.env.DEBUG;
+      }
+    }
+    function load() {
+      return process.env.DEBUG;
+    }
+    function init(debug2) {
+      debug2.inspectOpts = {};
+      const keys2 = Object.keys(exports2.inspectOpts);
+      for (let i = 0; i < keys2.length; i++) {
+        debug2.inspectOpts[keys2[i]] = exports2.inspectOpts[keys2[i]];
+      }
+    }
+    module2.exports = require_common()(exports2);
+    var { formatters } = module2.exports;
+    formatters.o = function(v2) {
+      this.inspectOpts.colors = this.useColors;
+      return util.inspect(v2, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
+    };
+    formatters.O = function(v2) {
+      this.inspectOpts.colors = this.useColors;
+      return util.inspect(v2, this.inspectOpts);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/index.js
+var require_src = __commonJS({
+  "../../node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/index.js"(exports2, module2) {
+    "use strict";
+    if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) {
+      module2.exports = require_browser();
+    } else {
+      module2.exports = require_node();
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@kwsites+file-exists@1.1.1/node_modules/@kwsites/file-exists/dist/src/index.js
+var require_src2 = __commonJS({
+  "../../node_modules/.pnpm/@kwsites+file-exists@1.1.1/node_modules/@kwsites/file-exists/dist/src/index.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var fs_1 = require("fs");
+    var debug_1 = __importDefault(require_src());
+    var log = debug_1.default("@kwsites/file-exists");
+    function check(path3, isFile, isDirectory) {
+      log(`checking %s`, path3);
+      try {
+        const stat2 = fs_1.statSync(path3);
+        if (stat2.isFile() && isFile) {
+          log(`[OK] path represents a file`);
+          return true;
+        }
+        if (stat2.isDirectory() && isDirectory) {
+          log(`[OK] path represents a directory`);
+          return true;
+        }
+        log(`[FAIL] path represents something other than a file or directory`);
+        return false;
+      } catch (e) {
+        if (e.code === "ENOENT") {
+          log(`[FAIL] path is not accessible: %o`, e);
+          return false;
+        }
+        log(`[FATAL] %o`, e);
+        throw e;
+      }
+    }
+    function exists2(path3, type = exports2.READABLE) {
+      return check(path3, (type & exports2.FILE) > 0, (type & exports2.FOLDER) > 0);
+    }
+    exports2.exists = exists2;
+    exports2.FILE = 1;
+    exports2.FOLDER = 2;
+    exports2.READABLE = exports2.FILE + exports2.FOLDER;
+  }
+});
+
+// ../../node_modules/.pnpm/@kwsites+file-exists@1.1.1/node_modules/@kwsites/file-exists/dist/index.js
+var require_dist = __commonJS({
+  "../../node_modules/.pnpm/@kwsites+file-exists@1.1.1/node_modules/@kwsites/file-exists/dist/index.js"(exports2) {
+    "use strict";
+    function __export3(m) {
+      for (var p in m) if (!exports2.hasOwnProperty(p)) exports2[p] = m[p];
+    }
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __export3(require_src2());
+  }
+});
+
+// ../../node_modules/.pnpm/@kwsites+promise-deferred@1.1.1/node_modules/@kwsites/promise-deferred/dist/index.js
+var require_dist2 = __commonJS({
+  "../../node_modules/.pnpm/@kwsites+promise-deferred@1.1.1/node_modules/@kwsites/promise-deferred/dist/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.createDeferred = exports2.deferred = void 0;
+    function deferred2() {
+      let done;
+      let fail;
+      let status2 = "pending";
+      const promise = new Promise((_done, _fail) => {
+        done = _done;
+        fail = _fail;
+      });
+      return {
+        promise,
+        done(result) {
+          if (status2 === "pending") {
+            status2 = "resolved";
+            done(result);
+          }
+        },
+        fail(error) {
+          if (status2 === "pending") {
+            status2 = "rejected";
+            fail(error);
+          }
+        },
+        get fulfilled() {
+          return status2 !== "pending";
+        },
+        get status() {
+          return status2;
+        }
+      };
+    }
+    exports2.deferred = deferred2;
+    exports2.createDeferred = deferred2;
+    exports2.default = deferred2;
+  }
+});
+
+// ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js
+var require_windows = __commonJS({
+  "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js"(exports2, module2) {
+    "use strict";
+    module2.exports = isexe;
+    isexe.sync = sync;
+    var fs2 = require("fs");
+    function checkPathExt(path3, options) {
+      var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
+      if (!pathext) {
+        return true;
+      }
+      pathext = pathext.split(";");
+      if (pathext.indexOf("") !== -1) {
+        return true;
+      }
+      for (var i = 0; i < pathext.length; i++) {
+        var p = pathext[i].toLowerCase();
+        if (p && path3.substr(-p.length).toLowerCase() === p) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function checkStat(stat2, path3, options) {
+      if (!stat2.isSymbolicLink() && !stat2.isFile()) {
+        return false;
+      }
+      return checkPathExt(path3, options);
+    }
+    function isexe(path3, options, cb) {
+      fs2.stat(path3, function(er, stat2) {
+        cb(er, er ? false : checkStat(stat2, path3, options));
+      });
+    }
+    function sync(path3, options) {
+      return checkStat(fs2.statSync(path3), path3, options);
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js
+var require_mode = __commonJS({
+  "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js"(exports2, module2) {
+    "use strict";
+    module2.exports = isexe;
+    isexe.sync = sync;
+    var fs2 = require("fs");
+    function isexe(path3, options, cb) {
+      fs2.stat(path3, function(er, stat2) {
+        cb(er, er ? false : checkStat(stat2, options));
+      });
+    }
+    function sync(path3, options) {
+      return checkStat(fs2.statSync(path3), options);
+    }
+    function checkStat(stat2, options) {
+      return stat2.isFile() && checkMode(stat2, options);
+    }
+    function checkMode(stat2, options) {
+      var mod = stat2.mode;
+      var uid = stat2.uid;
+      var gid = stat2.gid;
+      var myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid();
+      var myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid();
+      var u = parseInt("100", 8);
+      var g2 = parseInt("010", 8);
+      var o2 = parseInt("001", 8);
+      var ug = u | g2;
+      var ret = mod & o2 || mod & g2 && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0;
+      return ret;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js
+var require_isexe = __commonJS({
+  "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js"(exports2, module2) {
+    "use strict";
+    var fs2 = require("fs");
+    var core;
+    if (process.platform === "win32" || global.TESTING_WINDOWS) {
+      core = require_windows();
+    } else {
+      core = require_mode();
+    }
+    module2.exports = isexe;
+    isexe.sync = sync;
+    function isexe(path3, options, cb) {
+      if (typeof options === "function") {
+        cb = options;
+        options = {};
+      }
+      if (!cb) {
+        if (typeof Promise !== "function") {
+          throw new TypeError("callback not provided");
+        }
+        return new Promise(function(resolve4, reject) {
+          isexe(path3, options || {}, function(er, is) {
+            if (er) {
+              reject(er);
+            } else {
+              resolve4(is);
+            }
+          });
+        });
+      }
+      core(path3, options || {}, function(er, is) {
+        if (er) {
+          if (er.code === "EACCES" || options && options.ignoreErrors) {
+            er = null;
+            is = false;
+          }
+        }
+        cb(er, is);
+      });
+    }
+    function sync(path3, options) {
+      try {
+        return core.sync(path3, options || {});
+      } catch (er) {
+        if (options && options.ignoreErrors || er.code === "EACCES") {
+          return false;
+        } else {
+          throw er;
+        }
+      }
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/which@2.0.2/node_modules/which/which.js
+var require_which = __commonJS({
+  "../../node_modules/.pnpm/which@2.0.2/node_modules/which/which.js"(exports2, module2) {
+    "use strict";
+    var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+    var path3 = require("path");
+    var COLON = isWindows ? ";" : ":";
+    var isexe = require_isexe();
+    var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
+    var getPathInfo = (cmd, opt) => {
+      const colon = opt.colon || COLON;
+      const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [
+        // windows always checks the cwd first
+        ...isWindows ? [process.cwd()] : [],
+        ...(opt.path || process.env.PATH || /* istanbul ignore next: very unusual */
+        "").split(colon)
+      ];
+      const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+      const pathExt = isWindows ? pathExtExe.split(colon) : [""];
+      if (isWindows) {
+        if (cmd.indexOf(".") !== -1 && pathExt[0] !== "")
+          pathExt.unshift("");
+      }
+      return {
+        pathEnv,
+        pathExt,
+        pathExtExe
+      };
+    };
+    var which = (cmd, opt, cb) => {
+      if (typeof opt === "function") {
+        cb = opt;
+        opt = {};
+      }
+      if (!opt)
+        opt = {};
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      const step = (i) => new Promise((resolve4, reject) => {
+        if (i === pathEnv.length)
+          return opt.all && found.length ? resolve4(found) : reject(getNotFoundError(cmd));
+        const ppRaw = pathEnv[i];
+        const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+        const pCmd = path3.join(pathPart, cmd);
+        const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+        resolve4(subStep(p, i, 0));
+      });
+      const subStep = (p, i, ii) => new Promise((resolve4, reject) => {
+        if (ii === pathExt.length)
+          return resolve4(step(i + 1));
+        const ext = pathExt[ii];
+        isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
+          if (!er && is) {
+            if (opt.all)
+              found.push(p + ext);
+            else
+              return resolve4(p + ext);
+          }
+          return resolve4(subStep(p, i, ii + 1));
+        });
+      });
+      return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
+    };
+    var whichSync = (cmd, opt) => {
+      opt = opt || {};
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      for (let i = 0; i < pathEnv.length; i++) {
+        const ppRaw = pathEnv[i];
+        const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+        const pCmd = path3.join(pathPart, cmd);
+        const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+        for (let j2 = 0; j2 < pathExt.length; j2++) {
+          const cur = p + pathExt[j2];
+          try {
+            const is = isexe.sync(cur, { pathExt: pathExtExe });
+            if (is) {
+              if (opt.all)
+                found.push(cur);
+              else
+                return cur;
+            }
+          } catch (ex) {
+          }
+        }
+      }
+      if (opt.all && found.length)
+        return found;
+      if (opt.nothrow)
+        return null;
+      throw getNotFoundError(cmd);
+    };
+    module2.exports = which;
+    which.sync = whichSync;
+  }
+});
+
+// ../../node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js
+var require_path_key = __commonJS({
+  "../../node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js"(exports2, module2) {
+    "use strict";
+    var pathKey = (options = {}) => {
+      const environment = options.env || process.env;
+      const platform = options.platform || process.platform;
+      if (platform !== "win32") {
+        return "PATH";
+      }
+      return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+    };
+    module2.exports = pathKey;
+    module2.exports.default = pathKey;
+  }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.5/node_modules/cross-spawn/lib/util/resolveCommand.js
+var require_resolveCommand = __commonJS({
+  "../../node_modules/.pnpm/cross-spawn@7.0.5/node_modules/cross-spawn/lib/util/resolveCommand.js"(exports2, module2) {
+    "use strict";
+    var path3 = require("path");
+    var which = require_which();
+    var getPathKey = require_path_key();
+    function resolveCommandAttempt(parsed, withoutPathExt) {
+      const env2 = parsed.options.env || process.env;
+      const cwd2 = process.cwd();
+      const hasCustomCwd = parsed.options.cwd != null;
+      const shouldSwitchCwd = hasCustomCwd && process.chdir !== void 0 && !process.chdir.disabled;
+      if (shouldSwitchCwd) {
+        try {
+          process.chdir(parsed.options.cwd);
+        } catch (err) {
+        }
+      }
+      let resolved;
+      try {
+        resolved = which.sync(parsed.command, {
+          path: env2[getPathKey({ env: env2 })],
+          pathExt: withoutPathExt ? path3.delimiter : void 0
+        });
+      } catch (e) {
+      } finally {
+        if (shouldSwitchCwd) {
+          process.chdir(cwd2);
+        }
+      }
+      if (resolved) {
+        resolved = path3.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+      }
+      return resolved;
+    }
+    function resolveCommand(parsed) {
+      return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+    }
+    module2.exports = resolveCommand;
+  }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.5/node_modules/cross-spawn/lib/util/escape.js
+var require_escape = __commonJS({
+  "../../node_modules/.pnpm/cross-spawn@7.0.5/node_modules/cross-spawn/lib/util/escape.js"(exports2, module2) {
+    "use strict";
+    var metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+    function escapeCommand(arg) {
+      arg = arg.replace(metaCharsRegExp, "^$1");
+      return arg;
+    }
+    function escapeArgument(arg, doubleEscapeMetaChars) {
+      arg = `${arg}`;
+      arg = arg.replace(/(?=(\\+?)?)\1"/g, '$1$1\\"');
+      arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
+      arg = `"${arg}"`;
+      arg = arg.replace(metaCharsRegExp, "^$1");
+      if (doubleEscapeMetaChars) {
+        arg = arg.replace(metaCharsRegExp, "^$1");
+      }
+      return arg;
+    }
+    module2.exports.command = escapeCommand;
+    module2.exports.argument = escapeArgument;
+  }
+});
+
+// ../../node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js
+var require_shebang_regex = __commonJS({
+  "../../node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = /^#!(.*)/;
+  }
+});
+
+// ../../node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js
+var require_shebang_command = __commonJS({
+  "../../node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js"(exports2, module2) {
+    "use strict";
+    var shebangRegex = require_shebang_regex();
+    module2.exports = (string2 = "") => {
+      const match = string2.match(shebangRegex);
+      if (!match) {
+        return null;
+      }
+      const [path3, argument] = match[0].replace(/#! ?/, "").split(" ");
+      const binary = path3.split("/").pop();
+      if (binary === "env") {
+        return argument;
+      }
+      return argument ? `${binary} ${argument}` : binary;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.5/node_modules/cross-spawn/lib/util/readShebang.js
+var require_readShebang = __commonJS({
+  "../../node_modules/.pnpm/cross-spawn@7.0.5/node_modules/cross-spawn/lib/util/readShebang.js"(exports2, module2) {
+    "use strict";
+    var fs2 = require("fs");
+    var shebangCommand = require_shebang_command();
+    function readShebang(command) {
+      const size = 150;
+      const buffer = Buffer.alloc(size);
+      let fd;
+      try {
+        fd = fs2.openSync(command, "r");
+        fs2.readSync(fd, buffer, 0, size, 0);
+        fs2.closeSync(fd);
+      } catch (e) {
+      }
+      return shebangCommand(buffer.toString());
+    }
+    module2.exports = readShebang;
+  }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.5/node_modules/cross-spawn/lib/parse.js
+var require_parse = __commonJS({
+  "../../node_modules/.pnpm/cross-spawn@7.0.5/node_modules/cross-spawn/lib/parse.js"(exports2, module2) {
+    "use strict";
+    var path3 = require("path");
+    var resolveCommand = require_resolveCommand();
+    var escape = require_escape();
+    var readShebang = require_readShebang();
+    var isWin = process.platform === "win32";
+    var isExecutableRegExp = /\.(?:com|exe)$/i;
+    var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+    function detectShebang(parsed) {
+      parsed.file = resolveCommand(parsed);
+      const shebang = parsed.file && readShebang(parsed.file);
+      if (shebang) {
+        parsed.args.unshift(parsed.file);
+        parsed.command = shebang;
+        return resolveCommand(parsed);
+      }
+      return parsed.file;
+    }
+    function parseNonShell(parsed) {
+      if (!isWin) {
+        return parsed;
+      }
+      const commandFile = detectShebang(parsed);
+      const needsShell = !isExecutableRegExp.test(commandFile);
+      if (parsed.options.forceShell || needsShell) {
+        const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+        parsed.command = path3.normalize(parsed.command);
+        parsed.command = escape.command(parsed.command);
+        parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
+        const shellCommand = [parsed.command].concat(parsed.args).join(" ");
+        parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
+        parsed.command = process.env.comspec || "cmd.exe";
+        parsed.options.windowsVerbatimArguments = true;
+      }
+      return parsed;
+    }
+    function parse(command, args, options) {
+      if (args && !Array.isArray(args)) {
+        options = args;
+        args = null;
+      }
+      args = args ? args.slice(0) : [];
+      options = Object.assign({}, options);
+      const parsed = {
+        command,
+        args,
+        options,
+        file: void 0,
+        original: {
+          command,
+          args
+        }
+      };
+      return options.shell ? parsed : parseNonShell(parsed);
+    }
+    module2.exports = parse;
+  }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.5/node_modules/cross-spawn/lib/enoent.js
+var require_enoent = __commonJS({
+  "../../node_modules/.pnpm/cross-spawn@7.0.5/node_modules/cross-spawn/lib/enoent.js"(exports2, module2) {
+    "use strict";
+    var isWin = process.platform === "win32";
+    function notFoundError(original, syscall) {
+      return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
+        code: "ENOENT",
+        errno: "ENOENT",
+        syscall: `${syscall} ${original.command}`,
+        path: original.command,
+        spawnargs: original.args
+      });
+    }
+    function hookChildProcess(cp2, parsed) {
+      if (!isWin) {
+        return;
+      }
+      const originalEmit = cp2.emit;
+      cp2.emit = function(name, arg1) {
+        if (name === "exit") {
+          const err = verifyENOENT(arg1, parsed);
+          if (err) {
+            return originalEmit.call(cp2, "error", err);
+          }
+        }
+        return originalEmit.apply(cp2, arguments);
+      };
+    }
+    function verifyENOENT(status2, parsed) {
+      if (isWin && status2 === 1 && !parsed.file) {
+        return notFoundError(parsed.original, "spawn");
+      }
+      return null;
+    }
+    function verifyENOENTSync(status2, parsed) {
+      if (isWin && status2 === 1 && !parsed.file) {
+        return notFoundError(parsed.original, "spawnSync");
+      }
+      return null;
+    }
+    module2.exports = {
+      hookChildProcess,
+      verifyENOENT,
+      verifyENOENTSync,
+      notFoundError
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.5/node_modules/cross-spawn/index.js
+var require_cross_spawn = __commonJS({
+  "../../node_modules/.pnpm/cross-spawn@7.0.5/node_modules/cross-spawn/index.js"(exports2, module2) {
+    "use strict";
+    var cp2 = require("child_process");
+    var parse = require_parse();
+    var enoent = require_enoent();
+    function spawn2(command, args, options) {
+      const parsed = parse(command, args, options);
+      const spawned = cp2.spawn(parsed.command, parsed.args, parsed.options);
+      enoent.hookChildProcess(spawned, parsed);
+      return spawned;
+    }
+    function spawnSync(command, args, options) {
+      const parsed = parse(command, args, options);
+      const result = cp2.spawnSync(parsed.command, parsed.args, parsed.options);
+      result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+      return result;
+    }
+    module2.exports = spawn2;
+    module2.exports.spawn = spawn2;
+    module2.exports.sync = spawnSync;
+    module2.exports._parse = parse;
+    module2.exports._enoent = enoent;
+  }
+});
+
+// ../../node_modules/.pnpm/strip-final-newline@2.0.0/node_modules/strip-final-newline/index.js
+var require_strip_final_newline = __commonJS({
+  "../../node_modules/.pnpm/strip-final-newline@2.0.0/node_modules/strip-final-newline/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = (input) => {
+      const LF = typeof input === "string" ? "\n" : "\n".charCodeAt();
+      const CR = typeof input === "string" ? "\r" : "\r".charCodeAt();
+      if (input[input.length - 1] === LF) {
+        input = input.slice(0, input.length - 1);
+      }
+      if (input[input.length - 1] === CR) {
+        input = input.slice(0, input.length - 1);
+      }
+      return input;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/npm-run-path@4.0.1/node_modules/npm-run-path/index.js
+var require_npm_run_path = __commonJS({
+  "../../node_modules/.pnpm/npm-run-path@4.0.1/node_modules/npm-run-path/index.js"(exports2, module2) {
+    "use strict";
+    var path3 = require("path");
+    var pathKey = require_path_key();
+    var npmRunPath = (options) => {
+      options = {
+        cwd: process.cwd(),
+        path: process.env[pathKey()],
+        execPath: process.execPath,
+        ...options
+      };
+      let previous;
+      let cwdPath = path3.resolve(options.cwd);
+      const result = [];
+      while (previous !== cwdPath) {
+        result.push(path3.join(cwdPath, "node_modules/.bin"));
+        previous = cwdPath;
+        cwdPath = path3.resolve(cwdPath, "..");
+      }
+      const execPathDir = path3.resolve(options.cwd, options.execPath, "..");
+      result.push(execPathDir);
+      return result.concat(options.path).join(path3.delimiter);
+    };
+    module2.exports = npmRunPath;
+    module2.exports.default = npmRunPath;
+    module2.exports.env = (options) => {
+      options = {
+        env: process.env,
+        ...options
+      };
+      const env2 = { ...options.env };
+      const path4 = pathKey({ env: env2 });
+      options.path = env2[path4];
+      env2[path4] = module2.exports(options);
+      return env2;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/mimic-fn@2.1.0/node_modules/mimic-fn/index.js
+var require_mimic_fn = __commonJS({
+  "../../node_modules/.pnpm/mimic-fn@2.1.0/node_modules/mimic-fn/index.js"(exports2, module2) {
+    "use strict";
+    var mimicFn = (to, from) => {
+      for (const prop of Reflect.ownKeys(from)) {
+        Object.defineProperty(to, prop, Object.getOwnPropertyDescriptor(from, prop));
+      }
+      return to;
+    };
+    module2.exports = mimicFn;
+    module2.exports.default = mimicFn;
+  }
+});
+
+// ../../node_modules/.pnpm/onetime@5.1.2/node_modules/onetime/index.js
+var require_onetime = __commonJS({
+  "../../node_modules/.pnpm/onetime@5.1.2/node_modules/onetime/index.js"(exports2, module2) {
+    "use strict";
+    var mimicFn = require_mimic_fn();
+    var calledFunctions = /* @__PURE__ */ new WeakMap();
+    var onetime = (function_, options = {}) => {
+      if (typeof function_ !== "function") {
+        throw new TypeError("Expected a function");
+      }
+      let returnValue;
+      let callCount = 0;
+      const functionName = function_.displayName || function_.name || "<anonymous>";
+      const onetime2 = function(...arguments_) {
+        calledFunctions.set(onetime2, ++callCount);
+        if (callCount === 1) {
+          returnValue = function_.apply(this, arguments_);
+          function_ = null;
+        } else if (options.throw === true) {
+          throw new Error(`Function \`${functionName}\` can only be called once`);
+        }
+        return returnValue;
+      };
+      mimicFn(onetime2, function_);
+      calledFunctions.set(onetime2, callCount);
+      return onetime2;
+    };
+    module2.exports = onetime;
+    module2.exports.default = onetime;
+    module2.exports.callCount = (function_) => {
+      if (!calledFunctions.has(function_)) {
+        throw new Error(`The given function \`${function_.name}\` is not wrapped by the \`onetime\` package`);
+      }
+      return calledFunctions.get(function_);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/core.js
+var require_core = __commonJS({
+  "../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/core.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.SIGNALS = void 0;
+    var SIGNALS = [
+      {
+        name: "SIGHUP",
+        number: 1,
+        action: "terminate",
+        description: "Terminal closed",
+        standard: "posix"
+      },
+      {
+        name: "SIGINT",
+        number: 2,
+        action: "terminate",
+        description: "User interruption with CTRL-C",
+        standard: "ansi"
+      },
+      {
+        name: "SIGQUIT",
+        number: 3,
+        action: "core",
+        description: "User interruption with CTRL-\\",
+        standard: "posix"
+      },
+      {
+        name: "SIGILL",
+        number: 4,
+        action: "core",
+        description: "Invalid machine instruction",
+        standard: "ansi"
+      },
+      {
+        name: "SIGTRAP",
+        number: 5,
+        action: "core",
+        description: "Debugger breakpoint",
+        standard: "posix"
+      },
+      {
+        name: "SIGABRT",
+        number: 6,
+        action: "core",
+        description: "Aborted",
+        standard: "ansi"
+      },
+      {
+        name: "SIGIOT",
+        number: 6,
+        action: "core",
+        description: "Aborted",
+        standard: "bsd"
+      },
+      {
+        name: "SIGBUS",
+        number: 7,
+        action: "core",
+        description: "Bus error due to misaligned, non-existing address or paging error",
+        standard: "bsd"
+      },
+      {
+        name: "SIGEMT",
+        number: 7,
+        action: "terminate",
+        description: "Command should be emulated but is not implemented",
+        standard: "other"
+      },
+      {
+        name: "SIGFPE",
+        number: 8,
+        action: "core",
+        description: "Floating point arithmetic error",
+        standard: "ansi"
+      },
+      {
+        name: "SIGKILL",
+        number: 9,
+        action: "terminate",
+        description: "Forced termination",
+        standard: "posix",
+        forced: true
+      },
+      {
+        name: "SIGUSR1",
+        number: 10,
+        action: "terminate",
+        description: "Application-specific signal",
+        standard: "posix"
+      },
+      {
+        name: "SIGSEGV",
+        number: 11,
+        action: "core",
+        description: "Segmentation fault",
+        standard: "ansi"
+      },
+      {
+        name: "SIGUSR2",
+        number: 12,
+        action: "terminate",
+        description: "Application-specific signal",
+        standard: "posix"
+      },
+      {
+        name: "SIGPIPE",
+        number: 13,
+        action: "terminate",
+        description: "Broken pipe or socket",
+        standard: "posix"
+      },
+      {
+        name: "SIGALRM",
+        number: 14,
+        action: "terminate",
+        description: "Timeout or timer",
+        standard: "posix"
+      },
+      {
+        name: "SIGTERM",
+        number: 15,
+        action: "terminate",
+        description: "Termination",
+        standard: "ansi"
+      },
+      {
+        name: "SIGSTKFLT",
+        number: 16,
+        action: "terminate",
+        description: "Stack is empty or overflowed",
+        standard: "other"
+      },
+      {
+        name: "SIGCHLD",
+        number: 17,
+        action: "ignore",
+        description: "Child process terminated, paused or unpaused",
+        standard: "posix"
+      },
+      {
+        name: "SIGCLD",
+        number: 17,
+        action: "ignore",
+        description: "Child process terminated, paused or unpaused",
+        standard: "other"
+      },
+      {
+        name: "SIGCONT",
+        number: 18,
+        action: "unpause",
+        description: "Unpaused",
+        standard: "posix",
+        forced: true
+      },
+      {
+        name: "SIGSTOP",
+        number: 19,
+        action: "pause",
+        description: "Paused",
+        standard: "posix",
+        forced: true
+      },
+      {
+        name: "SIGTSTP",
+        number: 20,
+        action: "pause",
+        description: 'Paused using CTRL-Z or "suspend"',
+        standard: "posix"
+      },
+      {
+        name: "SIGTTIN",
+        number: 21,
+        action: "pause",
+        description: "Background process cannot read terminal input",
+        standard: "posix"
+      },
+      {
+        name: "SIGBREAK",
+        number: 21,
+        action: "terminate",
+        description: "User interruption with CTRL-BREAK",
+        standard: "other"
+      },
+      {
+        name: "SIGTTOU",
+        number: 22,
+        action: "pause",
+        description: "Background process cannot write to terminal output",
+        standard: "posix"
+      },
+      {
+        name: "SIGURG",
+        number: 23,
+        action: "ignore",
+        description: "Socket received out-of-band data",
+        standard: "bsd"
+      },
+      {
+        name: "SIGXCPU",
+        number: 24,
+        action: "core",
+        description: "Process timed out",
+        standard: "bsd"
+      },
+      {
+        name: "SIGXFSZ",
+        number: 25,
+        action: "core",
+        description: "File too big",
+        standard: "bsd"
+      },
+      {
+        name: "SIGVTALRM",
+        number: 26,
+        action: "terminate",
+        description: "Timeout or timer",
+        standard: "bsd"
+      },
+      {
+        name: "SIGPROF",
+        number: 27,
+        action: "terminate",
+        description: "Timeout or timer",
+        standard: "bsd"
+      },
+      {
+        name: "SIGWINCH",
+        number: 28,
+        action: "ignore",
+        description: "Terminal window size changed",
+        standard: "bsd"
+      },
+      {
+        name: "SIGIO",
+        number: 29,
+        action: "terminate",
+        description: "I/O is available",
+        standard: "other"
+      },
+      {
+        name: "SIGPOLL",
+        number: 29,
+        action: "terminate",
+        description: "Watched event",
+        standard: "other"
+      },
+      {
+        name: "SIGINFO",
+        number: 29,
+        action: "ignore",
+        description: "Request for process information",
+        standard: "other"
+      },
+      {
+        name: "SIGPWR",
+        number: 30,
+        action: "terminate",
+        description: "Device running out of power",
+        standard: "systemv"
+      },
+      {
+        name: "SIGSYS",
+        number: 31,
+        action: "core",
+        description: "Invalid system call",
+        standard: "other"
+      },
+      {
+        name: "SIGUNUSED",
+        number: 31,
+        action: "terminate",
+        description: "Invalid system call",
+        standard: "other"
+      }
+    ];
+    exports2.SIGNALS = SIGNALS;
+  }
+});
+
+// ../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/realtime.js
+var require_realtime = __commonJS({
+  "../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/realtime.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.SIGRTMAX = exports2.getRealtimeSignals = void 0;
+    var getRealtimeSignals = function() {
+      const length = SIGRTMAX - SIGRTMIN + 1;
+      return Array.from({ length }, getRealtimeSignal);
+    };
+    exports2.getRealtimeSignals = getRealtimeSignals;
+    var getRealtimeSignal = function(value, index) {
+      return {
+        name: `SIGRT${index + 1}`,
+        number: SIGRTMIN + index,
+        action: "terminate",
+        description: "Application-specific signal (realtime)",
+        standard: "posix"
+      };
+    };
+    var SIGRTMIN = 34;
+    var SIGRTMAX = 64;
+    exports2.SIGRTMAX = SIGRTMAX;
+  }
+});
+
+// ../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/signals.js
+var require_signals = __commonJS({
+  "../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/signals.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.getSignals = void 0;
+    var _os = require("os");
+    var _core = require_core();
+    var _realtime = require_realtime();
+    var getSignals = function() {
+      const realtimeSignals = (0, _realtime.getRealtimeSignals)();
+      const signals = [..._core.SIGNALS, ...realtimeSignals].map(normalizeSignal);
+      return signals;
+    };
+    exports2.getSignals = getSignals;
+    var normalizeSignal = function({
+      name,
+      number: defaultNumber,
+      description,
+      action,
+      forced = false,
+      standard
+    }) {
+      const {
+        signals: { [name]: constantSignal }
+      } = _os.constants;
+      const supported = constantSignal !== void 0;
+      const number2 = supported ? constantSignal : defaultNumber;
+      return { name, number: number2, description, supported, action, forced, standard };
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/main.js
+var require_main = __commonJS({
+  "../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/main.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.signalsByNumber = exports2.signalsByName = void 0;
+    var _os = require("os");
+    var _signals = require_signals();
+    var _realtime = require_realtime();
+    var getSignalsByName = function() {
+      const signals = (0, _signals.getSignals)();
+      return signals.reduce(getSignalByName, {});
+    };
+    var getSignalByName = function(signalByNameMemo, { name, number: number2, description, supported, action, forced, standard }) {
+      return {
+        ...signalByNameMemo,
+        [name]: { name, number: number2, description, supported, action, forced, standard }
+      };
+    };
+    var signalsByName = getSignalsByName();
+    exports2.signalsByName = signalsByName;
+    var getSignalsByNumber = function() {
+      const signals = (0, _signals.getSignals)();
+      const length = _realtime.SIGRTMAX + 1;
+      const signalsA = Array.from({ length }, (value, number2) => getSignalByNumber(number2, signals));
+      return Object.assign({}, ...signalsA);
+    };
+    var getSignalByNumber = function(number2, signals) {
+      const signal = findSignalByNumber(number2, signals);
+      if (signal === void 0) {
+        return {};
+      }
+      const { name, description, supported, action, forced, standard } = signal;
+      return {
+        [number2]: {
+          name,
+          number: number2,
+          description,
+          supported,
+          action,
+          forced,
+          standard
+        }
+      };
+    };
+    var findSignalByNumber = function(number2, signals) {
+      const signal = signals.find(({ name }) => _os.constants.signals[name] === number2);
+      if (signal !== void 0) {
+        return signal;
+      }
+      return signals.find((signalA) => signalA.number === number2);
+    };
+    var signalsByNumber = getSignalsByNumber();
+    exports2.signalsByNumber = signalsByNumber;
+  }
+});
+
+// ../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/error.js
+var require_error = __commonJS({
+  "../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/error.js"(exports2, module2) {
+    "use strict";
+    var { signalsByName } = require_main();
+    var getErrorPrefix = ({ timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled }) => {
+      if (timedOut) {
+        return `timed out after ${timeout} milliseconds`;
+      }
+      if (isCanceled) {
+        return "was canceled";
+      }
+      if (errorCode !== void 0) {
+        return `failed with ${errorCode}`;
+      }
+      if (signal !== void 0) {
+        return `was killed with ${signal} (${signalDescription})`;
+      }
+      if (exitCode !== void 0) {
+        return `failed with exit code ${exitCode}`;
+      }
+      return "failed";
+    };
+    var makeError = ({
+      stdout,
+      stderr,
+      all,
+      error,
+      signal,
+      exitCode,
+      command,
+      escapedCommand,
+      timedOut,
+      isCanceled,
+      killed,
+      parsed: { options: { timeout } }
+    }) => {
+      exitCode = exitCode === null ? void 0 : exitCode;
+      signal = signal === null ? void 0 : signal;
+      const signalDescription = signal === void 0 ? void 0 : signalsByName[signal].description;
+      const errorCode = error && error.code;
+      const prefix = getErrorPrefix({ timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled });
+      const execaMessage = `Command ${prefix}: ${command}`;
+      const isError = Object.prototype.toString.call(error) === "[object Error]";
+      const shortMessage = isError ? `${execaMessage}
+${error.message}` : execaMessage;
+      const message = [shortMessage, stderr, stdout].filter(Boolean).join("\n");
+      if (isError) {
+        error.originalMessage = error.message;
+        error.message = message;
+      } else {
+        error = new Error(message);
+      }
+      error.shortMessage = shortMessage;
+      error.command = command;
+      error.escapedCommand = escapedCommand;
+      error.exitCode = exitCode;
+      error.signal = signal;
+      error.signalDescription = signalDescription;
+      error.stdout = stdout;
+      error.stderr = stderr;
+      if (all !== void 0) {
+        error.all = all;
+      }
+      if ("bufferedData" in error) {
+        delete error.bufferedData;
+      }
+      error.failed = true;
+      error.timedOut = Boolean(timedOut);
+      error.isCanceled = isCanceled;
+      error.killed = killed && !timedOut;
+      return error;
+    };
+    module2.exports = makeError;
+  }
+});
+
+// ../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/stdio.js
+var require_stdio = __commonJS({
+  "../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/stdio.js"(exports2, module2) {
+    "use strict";
+    var aliases = ["stdin", "stdout", "stderr"];
+    var hasAlias = (options) => aliases.some((alias) => options[alias] !== void 0);
+    var normalizeStdio = (options) => {
+      if (!options) {
+        return;
+      }
+      const { stdio } = options;
+      if (stdio === void 0) {
+        return aliases.map((alias) => options[alias]);
+      }
+      if (hasAlias(options)) {
+        throw new Error(`It's not possible to provide \`stdio\` in combination with one of ${aliases.map((alias) => `\`${alias}\``).join(", ")}`);
+      }
+      if (typeof stdio === "string") {
+        return stdio;
+      }
+      if (!Array.isArray(stdio)) {
+        throw new TypeError(`Expected \`stdio\` to be of type \`string\` or \`Array\`, got \`${typeof stdio}\``);
+      }
+      const length = Math.max(stdio.length, aliases.length);
+      return Array.from({ length }, (value, index) => stdio[index]);
+    };
+    module2.exports = normalizeStdio;
+    module2.exports.node = (options) => {
+      const stdio = normalizeStdio(options);
+      if (stdio === "ipc") {
+        return "ipc";
+      }
+      if (stdio === void 0 || typeof stdio === "string") {
+        return [stdio, stdio, stdio, "ipc"];
+      }
+      if (stdio.includes("ipc")) {
+        return stdio;
+      }
+      return [...stdio, "ipc"];
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/signals.js
+var require_signals2 = __commonJS({
+  "../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/signals.js"(exports2, module2) {
+    "use strict";
+    module2.exports = [
+      "SIGABRT",
+      "SIGALRM",
+      "SIGHUP",
+      "SIGINT",
+      "SIGTERM"
+    ];
+    if (process.platform !== "win32") {
+      module2.exports.push(
+        "SIGVTALRM",
+        "SIGXCPU",
+        "SIGXFSZ",
+        "SIGUSR2",
+        "SIGTRAP",
+        "SIGSYS",
+        "SIGQUIT",
+        "SIGIOT"
+        // should detect profiler and enable/disable accordingly.
+        // see #21
+        // 'SIGPROF'
+      );
+    }
+    if (process.platform === "linux") {
+      module2.exports.push(
+        "SIGIO",
+        "SIGPOLL",
+        "SIGPWR",
+        "SIGSTKFLT",
+        "SIGUNUSED"
+      );
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js
+var require_signal_exit = __commonJS({
+  "../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js"(exports2, module2) {
+    "use strict";
+    var process2 = global.process;
+    var processOk = function(process3) {
+      return process3 && typeof process3 === "object" && typeof process3.removeListener === "function" && typeof process3.emit === "function" && typeof process3.reallyExit === "function" && typeof process3.listeners === "function" && typeof process3.kill === "function" && typeof process3.pid === "number" && typeof process3.on === "function";
+    };
+    if (!processOk(process2)) {
+      module2.exports = function() {
+        return function() {
+        };
+      };
+    } else {
+      assert = require("assert");
+      signals = require_signals2();
+      isWin = /^win/i.test(process2.platform);
+      EE = require("events");
+      if (typeof EE !== "function") {
+        EE = EE.EventEmitter;
+      }
+      if (process2.__signal_exit_emitter__) {
+        emitter = process2.__signal_exit_emitter__;
+      } else {
+        emitter = process2.__signal_exit_emitter__ = new EE();
+        emitter.count = 0;
+        emitter.emitted = {};
+      }
+      if (!emitter.infinite) {
+        emitter.setMaxListeners(Infinity);
+        emitter.infinite = true;
+      }
+      module2.exports = function(cb, opts) {
+        if (!processOk(global.process)) {
+          return function() {
+          };
+        }
+        assert.equal(typeof cb, "function", "a callback must be provided for exit handler");
+        if (loaded === false) {
+          load();
+        }
+        var ev = "exit";
+        if (opts && opts.alwaysLast) {
+          ev = "afterexit";
+        }
+        var remove2 = function() {
+          emitter.removeListener(ev, cb);
+          if (emitter.listeners("exit").length === 0 && emitter.listeners("afterexit").length === 0) {
+            unload();
+          }
+        };
+        emitter.on(ev, cb);
+        return remove2;
+      };
+      unload = function unload2() {
+        if (!loaded || !processOk(global.process)) {
+          return;
+        }
+        loaded = false;
+        signals.forEach(function(sig) {
+          try {
+            process2.removeListener(sig, sigListeners[sig]);
+          } catch (er) {
+          }
+        });
+        process2.emit = originalProcessEmit;
+        process2.reallyExit = originalProcessReallyExit;
+        emitter.count -= 1;
+      };
+      module2.exports.unload = unload;
+      emit = function emit2(event, code, signal) {
+        if (emitter.emitted[event]) {
+          return;
+        }
+        emitter.emitted[event] = true;
+        emitter.emit(event, code, signal);
+      };
+      sigListeners = {};
+      signals.forEach(function(sig) {
+        sigListeners[sig] = function listener() {
+          if (!processOk(global.process)) {
+            return;
+          }
+          var listeners = process2.listeners(sig);
+          if (listeners.length === emitter.count) {
+            unload();
+            emit("exit", null, sig);
+            emit("afterexit", null, sig);
+            if (isWin && sig === "SIGHUP") {
+              sig = "SIGINT";
+            }
+            process2.kill(process2.pid, sig);
+          }
+        };
+      });
+      module2.exports.signals = function() {
+        return signals;
+      };
+      loaded = false;
+      load = function load2() {
+        if (loaded || !processOk(global.process)) {
+          return;
+        }
+        loaded = true;
+        emitter.count += 1;
+        signals = signals.filter(function(sig) {
+          try {
+            process2.on(sig, sigListeners[sig]);
+            return true;
+          } catch (er) {
+            return false;
+          }
+        });
+        process2.emit = processEmit;
+        process2.reallyExit = processReallyExit;
+      };
+      module2.exports.load = load;
+      originalProcessReallyExit = process2.reallyExit;
+      processReallyExit = function processReallyExit2(code) {
+        if (!processOk(global.process)) {
+          return;
+        }
+        process2.exitCode = code || /* istanbul ignore next */
+        0;
+        emit("exit", process2.exitCode, null);
+        emit("afterexit", process2.exitCode, null);
+        originalProcessReallyExit.call(process2, process2.exitCode);
+      };
+      originalProcessEmit = process2.emit;
+      processEmit = function processEmit2(ev, arg) {
+        if (ev === "exit" && processOk(global.process)) {
+          if (arg !== void 0) {
+            process2.exitCode = arg;
+          }
+          var ret = originalProcessEmit.apply(this, arguments);
+          emit("exit", process2.exitCode, null);
+          emit("afterexit", process2.exitCode, null);
+          return ret;
+        } else {
+          return originalProcessEmit.apply(this, arguments);
+        }
+      };
+    }
+    var assert;
+    var signals;
+    var isWin;
+    var EE;
+    var emitter;
+    var unload;
+    var emit;
+    var sigListeners;
+    var loaded;
+    var load;
+    var originalProcessReallyExit;
+    var processReallyExit;
+    var originalProcessEmit;
+    var processEmit;
+  }
+});
+
+// ../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/kill.js
+var require_kill = __commonJS({
+  "../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/kill.js"(exports2, module2) {
+    "use strict";
+    var os = require("os");
+    var onExit = require_signal_exit();
+    var DEFAULT_FORCE_KILL_TIMEOUT = 1e3 * 5;
+    var spawnedKill = (kill, signal = "SIGTERM", options = {}) => {
+      const killResult = kill(signal);
+      setKillTimeout(kill, signal, options, killResult);
+      return killResult;
+    };
+    var setKillTimeout = (kill, signal, options, killResult) => {
+      if (!shouldForceKill(signal, options, killResult)) {
+        return;
+      }
+      const timeout = getForceKillAfterTimeout(options);
+      const t2 = setTimeout(() => {
+        kill("SIGKILL");
+      }, timeout);
+      if (t2.unref) {
+        t2.unref();
+      }
+    };
+    var shouldForceKill = (signal, { forceKillAfterTimeout }, killResult) => {
+      return isSigterm(signal) && forceKillAfterTimeout !== false && killResult;
+    };
+    var isSigterm = (signal) => {
+      return signal === os.constants.signals.SIGTERM || typeof signal === "string" && signal.toUpperCase() === "SIGTERM";
+    };
+    var getForceKillAfterTimeout = ({ forceKillAfterTimeout = true }) => {
+      if (forceKillAfterTimeout === true) {
+        return DEFAULT_FORCE_KILL_TIMEOUT;
+      }
+      if (!Number.isFinite(forceKillAfterTimeout) || forceKillAfterTimeout < 0) {
+        throw new TypeError(`Expected the \`forceKillAfterTimeout\` option to be a non-negative integer, got \`${forceKillAfterTimeout}\` (${typeof forceKillAfterTimeout})`);
+      }
+      return forceKillAfterTimeout;
+    };
+    var spawnedCancel = (spawned, context) => {
+      const killResult = spawned.kill();
+      if (killResult) {
+        context.isCanceled = true;
+      }
+    };
+    var timeoutKill = (spawned, signal, reject) => {
+      spawned.kill(signal);
+      reject(Object.assign(new Error("Timed out"), { timedOut: true, signal }));
+    };
+    var setupTimeout = (spawned, { timeout, killSignal = "SIGTERM" }, spawnedPromise) => {
+      if (timeout === 0 || timeout === void 0) {
+        return spawnedPromise;
+      }
+      let timeoutId;
+      const timeoutPromise = new Promise((resolve4, reject) => {
+        timeoutId = setTimeout(() => {
+          timeoutKill(spawned, killSignal, reject);
+        }, timeout);
+      });
+      const safeSpawnedPromise = spawnedPromise.finally(() => {
+        clearTimeout(timeoutId);
+      });
+      return Promise.race([timeoutPromise, safeSpawnedPromise]);
+    };
+    var validateTimeout = ({ timeout }) => {
+      if (timeout !== void 0 && (!Number.isFinite(timeout) || timeout < 0)) {
+        throw new TypeError(`Expected the \`timeout\` option to be a non-negative integer, got \`${timeout}\` (${typeof timeout})`);
+      }
+    };
+    var setExitHandler = async (spawned, { cleanup, detached }, timedPromise) => {
+      if (!cleanup || detached) {
+        return timedPromise;
+      }
+      const removeExitHandler = onExit(() => {
+        spawned.kill();
+      });
+      return timedPromise.finally(() => {
+        removeExitHandler();
+      });
+    };
+    module2.exports = {
+      spawnedKill,
+      spawnedCancel,
+      setupTimeout,
+      validateTimeout,
+      setExitHandler
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/is-stream@2.0.1/node_modules/is-stream/index.js
+var require_is_stream = __commonJS({
+  "../../node_modules/.pnpm/is-stream@2.0.1/node_modules/is-stream/index.js"(exports2, module2) {
+    "use strict";
+    var isStream = (stream) => stream !== null && typeof stream === "object" && typeof stream.pipe === "function";
+    isStream.writable = (stream) => isStream(stream) && stream.writable !== false && typeof stream._write === "function" && typeof stream._writableState === "object";
+    isStream.readable = (stream) => isStream(stream) && stream.readable !== false && typeof stream._read === "function" && typeof stream._readableState === "object";
+    isStream.duplex = (stream) => isStream.writable(stream) && isStream.readable(stream);
+    isStream.transform = (stream) => isStream.duplex(stream) && typeof stream._transform === "function";
+    module2.exports = isStream;
+  }
+});
+
+// ../../node_modules/.pnpm/get-stream@6.0.1/node_modules/get-stream/buffer-stream.js
+var require_buffer_stream = __commonJS({
+  "../../node_modules/.pnpm/get-stream@6.0.1/node_modules/get-stream/buffer-stream.js"(exports2, module2) {
+    "use strict";
+    var { PassThrough: PassThroughStream } = require("stream");
+    module2.exports = (options) => {
+      options = { ...options };
+      const { array } = options;
+      let { encoding } = options;
+      const isBuffer = encoding === "buffer";
+      let objectMode = false;
+      if (array) {
+        objectMode = !(encoding || isBuffer);
+      } else {
+        encoding = encoding || "utf8";
+      }
+      if (isBuffer) {
+        encoding = null;
+      }
+      const stream = new PassThroughStream({ objectMode });
+      if (encoding) {
+        stream.setEncoding(encoding);
+      }
+      let length = 0;
+      const chunks = [];
+      stream.on("data", (chunk) => {
+        chunks.push(chunk);
+        if (objectMode) {
+          length = chunks.length;
+        } else {
+          length += chunk.length;
+        }
+      });
+      stream.getBufferedValue = () => {
+        if (array) {
+          return chunks;
+        }
+        return isBuffer ? Buffer.concat(chunks, length) : chunks.join("");
+      };
+      stream.getBufferedLength = () => length;
+      return stream;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/get-stream@6.0.1/node_modules/get-stream/index.js
+var require_get_stream = __commonJS({
+  "../../node_modules/.pnpm/get-stream@6.0.1/node_modules/get-stream/index.js"(exports2, module2) {
+    "use strict";
+    var { constants: BufferConstants } = require("buffer");
+    var stream = require("stream");
+    var { promisify } = require("util");
+    var bufferStream = require_buffer_stream();
+    var streamPipelinePromisified = promisify(stream.pipeline);
+    var MaxBufferError = class extends Error {
+      constructor() {
+        super("maxBuffer exceeded");
+        this.name = "MaxBufferError";
+      }
+    };
+    async function getStream(inputStream, options) {
+      if (!inputStream) {
+        throw new Error("Expected a stream");
+      }
+      options = {
+        maxBuffer: Infinity,
+        ...options
+      };
+      const { maxBuffer } = options;
+      const stream2 = bufferStream(options);
+      await new Promise((resolve4, reject) => {
+        const rejectPromise = (error) => {
+          if (error && stream2.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
+            error.bufferedData = stream2.getBufferedValue();
+          }
+          reject(error);
+        };
+        (async () => {
+          try {
+            await streamPipelinePromisified(inputStream, stream2);
+            resolve4();
+          } catch (error) {
+            rejectPromise(error);
+          }
+        })();
+        stream2.on("data", () => {
+          if (stream2.getBufferedLength() > maxBuffer) {
+            rejectPromise(new MaxBufferError());
+          }
+        });
+      });
+      return stream2.getBufferedValue();
+    }
+    module2.exports = getStream;
+    module2.exports.buffer = (stream2, options) => getStream(stream2, { ...options, encoding: "buffer" });
+    module2.exports.array = (stream2, options) => getStream(stream2, { ...options, array: true });
+    module2.exports.MaxBufferError = MaxBufferError;
+  }
+});
+
+// ../../node_modules/.pnpm/merge-stream@2.0.0/node_modules/merge-stream/index.js
+var require_merge_stream = __commonJS({
+  "../../node_modules/.pnpm/merge-stream@2.0.0/node_modules/merge-stream/index.js"(exports2, module2) {
+    "use strict";
+    var { PassThrough } = require("stream");
+    module2.exports = function() {
+      var sources = [];
+      var output = new PassThrough({ objectMode: true });
+      output.setMaxListeners(0);
+      output.add = add;
+      output.isEmpty = isEmpty;
+      output.on("unpipe", remove2);
+      Array.prototype.slice.call(arguments).forEach(add);
+      return output;
+      function add(source) {
+        if (Array.isArray(source)) {
+          source.forEach(add);
+          return this;
+        }
+        sources.push(source);
+        source.once("end", remove2.bind(null, source));
+        source.once("error", output.emit.bind(output, "error"));
+        source.pipe(output, { end: false });
+        return this;
+      }
+      function isEmpty() {
+        return sources.length == 0;
+      }
+      function remove2(source) {
+        sources = sources.filter(function(it) {
+          return it !== source;
+        });
+        if (!sources.length && output.readable) {
+          output.end();
+        }
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/stream.js
+var require_stream = __commonJS({
+  "../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/stream.js"(exports2, module2) {
+    "use strict";
+    var isStream = require_is_stream();
+    var getStream = require_get_stream();
+    var mergeStream = require_merge_stream();
+    var handleInput = (spawned, input) => {
+      if (input === void 0 || spawned.stdin === void 0) {
+        return;
+      }
+      if (isStream(input)) {
+        input.pipe(spawned.stdin);
+      } else {
+        spawned.stdin.end(input);
+      }
+    };
+    var makeAllStream = (spawned, { all }) => {
+      if (!all || !spawned.stdout && !spawned.stderr) {
+        return;
+      }
+      const mixed = mergeStream();
+      if (spawned.stdout) {
+        mixed.add(spawned.stdout);
+      }
+      if (spawned.stderr) {
+        mixed.add(spawned.stderr);
+      }
+      return mixed;
+    };
+    var getBufferedData = async (stream, streamPromise) => {
+      if (!stream) {
+        return;
+      }
+      stream.destroy();
+      try {
+        return await streamPromise;
+      } catch (error) {
+        return error.bufferedData;
+      }
+    };
+    var getStreamPromise = (stream, { encoding, buffer, maxBuffer }) => {
+      if (!stream || !buffer) {
+        return;
+      }
+      if (encoding) {
+        return getStream(stream, { encoding, maxBuffer });
+      }
+      return getStream.buffer(stream, { maxBuffer });
+    };
+    var getSpawnedResult = async ({ stdout, stderr, all }, { encoding, buffer, maxBuffer }, processDone) => {
+      const stdoutPromise = getStreamPromise(stdout, { encoding, buffer, maxBuffer });
+      const stderrPromise = getStreamPromise(stderr, { encoding, buffer, maxBuffer });
+      const allPromise = getStreamPromise(all, { encoding, buffer, maxBuffer: maxBuffer * 2 });
+      try {
+        return await Promise.all([processDone, stdoutPromise, stderrPromise, allPromise]);
+      } catch (error) {
+        return Promise.all([
+          { error, signal: error.signal, timedOut: error.timedOut },
+          getBufferedData(stdout, stdoutPromise),
+          getBufferedData(stderr, stderrPromise),
+          getBufferedData(all, allPromise)
+        ]);
+      }
+    };
+    var validateInputSync = ({ input }) => {
+      if (isStream(input)) {
+        throw new TypeError("The `input` option cannot be a stream in sync mode");
+      }
+    };
+    module2.exports = {
+      handleInput,
+      makeAllStream,
+      getSpawnedResult,
+      validateInputSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/promise.js
+var require_promise = __commonJS({
+  "../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/promise.js"(exports2, module2) {
+    "use strict";
+    var nativePromisePrototype = (async () => {
+    })().constructor.prototype;
+    var descriptors = ["then", "catch", "finally"].map((property2) => [
+      property2,
+      Reflect.getOwnPropertyDescriptor(nativePromisePrototype, property2)
+    ]);
+    var mergePromise = (spawned, promise) => {
+      for (const [property2, descriptor] of descriptors) {
+        const value = typeof promise === "function" ? (...args) => Reflect.apply(descriptor.value, promise(), args) : descriptor.value.bind(promise);
+        Reflect.defineProperty(spawned, property2, { ...descriptor, value });
+      }
+      return spawned;
+    };
+    var getSpawnedPromise = (spawned) => {
+      return new Promise((resolve4, reject) => {
+        spawned.on("exit", (exitCode, signal) => {
+          resolve4({ exitCode, signal });
+        });
+        spawned.on("error", (error) => {
+          reject(error);
+        });
+        if (spawned.stdin) {
+          spawned.stdin.on("error", (error) => {
+            reject(error);
+          });
+        }
+      });
+    };
+    module2.exports = {
+      mergePromise,
+      getSpawnedPromise
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/command.js
+var require_command = __commonJS({
+  "../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/command.js"(exports2, module2) {
+    "use strict";
+    var normalizeArgs = (file, args = []) => {
+      if (!Array.isArray(args)) {
+        return [file];
+      }
+      return [file, ...args];
+    };
+    var NO_ESCAPE_REGEXP = /^[\w.-]+$/;
+    var DOUBLE_QUOTES_REGEXP = /"/g;
+    var escapeArg = (arg) => {
+      if (typeof arg !== "string" || NO_ESCAPE_REGEXP.test(arg)) {
+        return arg;
+      }
+      return `"${arg.replace(DOUBLE_QUOTES_REGEXP, '\\"')}"`;
+    };
+    var joinCommand = (file, args) => {
+      return normalizeArgs(file, args).join(" ");
+    };
+    var getEscapedCommand = (file, args) => {
+      return normalizeArgs(file, args).map((arg) => escapeArg(arg)).join(" ");
+    };
+    var SPACES_REGEXP = / +/g;
+    var parseCommand = (command) => {
+      const tokens = [];
+      for (const token of command.trim().split(SPACES_REGEXP)) {
+        const previousToken = tokens[tokens.length - 1];
+        if (previousToken && previousToken.endsWith("\\")) {
+          tokens[tokens.length - 1] = `${previousToken.slice(0, -1)} ${token}`;
+        } else {
+          tokens.push(token);
+        }
+      }
+      return tokens;
+    };
+    module2.exports = {
+      joinCommand,
+      getEscapedCommand,
+      parseCommand
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/index.js
+var require_execa = __commonJS({
+  "../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/index.js"(exports2, module2) {
+    "use strict";
+    var path3 = require("path");
+    var childProcess = require("child_process");
+    var crossSpawn = require_cross_spawn();
+    var stripFinalNewline = require_strip_final_newline();
+    var npmRunPath = require_npm_run_path();
+    var onetime = require_onetime();
+    var makeError = require_error();
+    var normalizeStdio = require_stdio();
+    var { spawnedKill, spawnedCancel, setupTimeout, validateTimeout, setExitHandler } = require_kill();
+    var { handleInput, getSpawnedResult, makeAllStream, validateInputSync } = require_stream();
+    var { mergePromise, getSpawnedPromise } = require_promise();
+    var { joinCommand, parseCommand, getEscapedCommand } = require_command();
+    var DEFAULT_MAX_BUFFER = 1e3 * 1e3 * 100;
+    var getEnv = ({ env: envOption, extendEnv, preferLocal, localDir, execPath }) => {
+      const env2 = extendEnv ? { ...process.env, ...envOption } : envOption;
+      if (preferLocal) {
+        return npmRunPath.env({ env: env2, cwd: localDir, execPath });
+      }
+      return env2;
+    };
+    var handleArguments = (file, args, options = {}) => {
+      const parsed = crossSpawn._parse(file, args, options);
+      file = parsed.command;
+      args = parsed.args;
+      options = parsed.options;
+      options = {
+        maxBuffer: DEFAULT_MAX_BUFFER,
+        buffer: true,
+        stripFinalNewline: true,
+        extendEnv: true,
+        preferLocal: false,
+        localDir: options.cwd || process.cwd(),
+        execPath: process.execPath,
+        encoding: "utf8",
+        reject: true,
+        cleanup: true,
+        all: false,
+        windowsHide: true,
+        ...options
+      };
+      options.env = getEnv(options);
+      options.stdio = normalizeStdio(options);
+      if (process.platform === "win32" && path3.basename(file, ".exe") === "cmd") {
+        args.unshift("/q");
+      }
+      return { file, args, options, parsed };
+    };
+    var handleOutput = (options, value, error) => {
+      if (typeof value !== "string" && !Buffer.isBuffer(value)) {
+        return error === void 0 ? void 0 : "";
+      }
+      if (options.stripFinalNewline) {
+        return stripFinalNewline(value);
+      }
+      return value;
+    };
+    var execa2 = (file, args, options) => {
+      const parsed = handleArguments(file, args, options);
+      const command = joinCommand(file, args);
+      const escapedCommand = getEscapedCommand(file, args);
+      validateTimeout(parsed.options);
+      let spawned;
+      try {
+        spawned = childProcess.spawn(parsed.file, parsed.args, parsed.options);
+      } catch (error) {
+        const dummySpawned = new childProcess.ChildProcess();
+        const errorPromise = Promise.reject(makeError({
+          error,
+          stdout: "",
+          stderr: "",
+          all: "",
+          command,
+          escapedCommand,
+          parsed,
+          timedOut: false,
+          isCanceled: false,
+          killed: false
+        }));
+        return mergePromise(dummySpawned, errorPromise);
+      }
+      const spawnedPromise = getSpawnedPromise(spawned);
+      const timedPromise = setupTimeout(spawned, parsed.options, spawnedPromise);
+      const processDone = setExitHandler(spawned, parsed.options, timedPromise);
+      const context = { isCanceled: false };
+      spawned.kill = spawnedKill.bind(null, spawned.kill.bind(spawned));
+      spawned.cancel = spawnedCancel.bind(null, spawned, context);
+      const handlePromise = async () => {
+        const [{ error, exitCode, signal, timedOut }, stdoutResult, stderrResult, allResult] = await getSpawnedResult(spawned, parsed.options, processDone);
+        const stdout = handleOutput(parsed.options, stdoutResult);
+        const stderr = handleOutput(parsed.options, stderrResult);
+        const all = handleOutput(parsed.options, allResult);
+        if (error || exitCode !== 0 || signal !== null) {
+          const returnedError = makeError({
+            error,
+            exitCode,
+            signal,
+            stdout,
+            stderr,
+            all,
+            command,
+            escapedCommand,
+            parsed,
+            timedOut,
+            isCanceled: context.isCanceled,
+            killed: spawned.killed
+          });
+          if (!parsed.options.reject) {
+            return returnedError;
+          }
+          throw returnedError;
+        }
+        return {
+          command,
+          escapedCommand,
+          exitCode: 0,
+          stdout,
+          stderr,
+          all,
+          failed: false,
+          timedOut: false,
+          isCanceled: false,
+          killed: false
+        };
+      };
+      const handlePromiseOnce = onetime(handlePromise);
+      handleInput(spawned, parsed.options.input);
+      spawned.all = makeAllStream(spawned, parsed.options);
+      return mergePromise(spawned, handlePromiseOnce);
+    };
+    module2.exports = execa2;
+    module2.exports.sync = (file, args, options) => {
+      const parsed = handleArguments(file, args, options);
+      const command = joinCommand(file, args);
+      const escapedCommand = getEscapedCommand(file, args);
+      validateInputSync(parsed.options);
+      let result;
+      try {
+        result = childProcess.spawnSync(parsed.file, parsed.args, parsed.options);
+      } catch (error) {
+        throw makeError({
+          error,
+          stdout: "",
+          stderr: "",
+          all: "",
+          command,
+          escapedCommand,
+          parsed,
+          timedOut: false,
+          isCanceled: false,
+          killed: false
+        });
+      }
+      const stdout = handleOutput(parsed.options, result.stdout, result.error);
+      const stderr = handleOutput(parsed.options, result.stderr, result.error);
+      if (result.error || result.status !== 0 || result.signal !== null) {
+        const error = makeError({
+          stdout,
+          stderr,
+          error: result.error,
+          signal: result.signal,
+          exitCode: result.status,
+          command,
+          escapedCommand,
+          parsed,
+          timedOut: result.error && result.error.code === "ETIMEDOUT",
+          isCanceled: false,
+          killed: result.signal !== null
+        });
+        if (!parsed.options.reject) {
+          return error;
+        }
+        throw error;
+      }
+      return {
+        command,
+        escapedCommand,
+        exitCode: 0,
+        stdout,
+        stderr,
+        failed: false,
+        timedOut: false,
+        isCanceled: false,
+        killed: false
+      };
+    };
+    module2.exports.command = (command, options) => {
+      const [file, ...args] = parseCommand(command);
+      return execa2(file, args, options);
+    };
+    module2.exports.commandSync = (command, options) => {
+      const [file, ...args] = parseCommand(command);
+      return execa2.sync(file, args, options);
+    };
+    module2.exports.node = (scriptPath, args, options = {}) => {
+      if (args && !Array.isArray(args) && typeof args === "object") {
+        options = args;
+        args = [];
+      }
+      const stdio = normalizeStdio.node(options);
+      const defaultExecArgv = process.execArgv.filter((arg) => !arg.startsWith("--inspect"));
+      const {
+        nodePath = process.execPath,
+        nodeOptions = defaultExecArgv
+      } = options;
+      return execa2(
+        nodePath,
+        [
+          ...nodeOptions,
+          scriptPath,
+          ...Array.isArray(args) ? args : []
+        ],
+        {
+          ...options,
+          stdin: void 0,
+          stdout: void 0,
+          stderr: void 0,
+          stdio,
+          shell: false
+        }
+      );
+    };
+  }
+});
+
+// ../cli/ai/lib/baml_client/async_request.js
+var import_baml, AsyncHttpRequest, AsyncHttpStreamRequest;
+var init_async_request = __esm({
+  "../cli/ai/lib/baml_client/async_request.js"() {
+    "use strict";
+    import_baml = require("@boundaryml/baml");
+    AsyncHttpRequest = class {
+      runtime;
+      ctxManager;
+      constructor(runtime, ctxManager) {
+        this.runtime = runtime;
+        this.ctxManager = ctxManager;
+      }
+      async AnalyzeSdkDiff(diff, language, previous_version, prior_changelog, spec_commit_message, __baml_options__) {
+        try {
+          const __rawEnv__ = __baml_options__?.env ? { ...process.env, ...__baml_options__.env } : { ...process.env };
+          const __env__ = Object.fromEntries(Object.entries(__rawEnv__).filter(([_2, value]) => value !== void 0));
+          let __clientRegistry__ = __baml_options__?.clientRegistry;
+          if (__baml_options__?.client) {
+            __clientRegistry__ = __clientRegistry__ || new import_baml.ClientRegistry();
+            __clientRegistry__.setPrimary(__baml_options__.client);
+          }
+          return await this.runtime.buildRequest("AnalyzeSdkDiff", {
+            "diff": diff,
+            "language": language,
+            "previous_version": previous_version,
+            "prior_changelog": prior_changelog,
+            "spec_commit_message": spec_commit_message
+          }, this.ctxManager.cloneContext(), __baml_options__?.tb?.__tb(), __clientRegistry__, false, __env__);
+        } catch (error) {
+          throw (0, import_baml.toBamlError)(error);
+        }
+      }
+      async ConsolidateChangelog(raw_entries, version_bump, language, previous_version, new_version, __baml_options__) {
+        try {
+          const __rawEnv__ = __baml_options__?.env ? { ...process.env, ...__baml_options__.env } : { ...process.env };
+          const __env__ = Object.fromEntries(Object.entries(__rawEnv__).filter(([_2, value]) => value !== void 0));
+          let __clientRegistry__ = __baml_options__?.clientRegistry;
+          if (__baml_options__?.client) {
+            __clientRegistry__ = __clientRegistry__ || new import_baml.ClientRegistry();
+            __clientRegistry__.setPrimary(__baml_options__.client);
+          }
+          return await this.runtime.buildRequest("ConsolidateChangelog", {
+            "raw_entries": raw_entries,
+            "version_bump": version_bump,
+            "language": language,
+            "previous_version": previous_version,
+            "new_version": new_version
+          }, this.ctxManager.cloneContext(), __baml_options__?.tb?.__tb(), __clientRegistry__, false, __env__);
+        } catch (error) {
+          throw (0, import_baml.toBamlError)(error);
+        }
+      }
+    };
+    AsyncHttpStreamRequest = class {
+      runtime;
+      ctxManager;
+      constructor(runtime, ctxManager) {
+        this.runtime = runtime;
+        this.ctxManager = ctxManager;
+      }
+      async AnalyzeSdkDiff(diff, language, previous_version, prior_changelog, spec_commit_message, __baml_options__) {
+        try {
+          const __rawEnv__ = __baml_options__?.env ? { ...process.env, ...__baml_options__.env } : { ...process.env };
+          const __env__ = Object.fromEntries(Object.entries(__rawEnv__).filter(([_2, value]) => value !== void 0));
+          let __clientRegistry__ = __baml_options__?.clientRegistry;
+          if (__baml_options__?.client) {
+            __clientRegistry__ = __clientRegistry__ || new import_baml.ClientRegistry();
+            __clientRegistry__.setPrimary(__baml_options__.client);
+          }
+          return await this.runtime.buildRequest("AnalyzeSdkDiff", {
+            "diff": diff,
+            "language": language,
+            "previous_version": previous_version,
+            "prior_changelog": prior_changelog,
+            "spec_commit_message": spec_commit_message
+          }, this.ctxManager.cloneContext(), __baml_options__?.tb?.__tb(), __clientRegistry__, true, __env__);
+        } catch (error) {
+          throw (0, import_baml.toBamlError)(error);
+        }
+      }
+      async ConsolidateChangelog(raw_entries, version_bump, language, previous_version, new_version, __baml_options__) {
+        try {
+          const __rawEnv__ = __baml_options__?.env ? { ...process.env, ...__baml_options__.env } : { ...process.env };
+          const __env__ = Object.fromEntries(Object.entries(__rawEnv__).filter(([_2, value]) => value !== void 0));
+          let __clientRegistry__ = __baml_options__?.clientRegistry;
+          if (__baml_options__?.client) {
+            __clientRegistry__ = __clientRegistry__ || new import_baml.ClientRegistry();
+            __clientRegistry__.setPrimary(__baml_options__.client);
+          }
+          return await this.runtime.buildRequest("ConsolidateChangelog", {
+            "raw_entries": raw_entries,
+            "version_bump": version_bump,
+            "language": language,
+            "previous_version": previous_version,
+            "new_version": new_version
+          }, this.ctxManager.cloneContext(), __baml_options__?.tb?.__tb(), __clientRegistry__, true, __env__);
+        } catch (error) {
+          throw (0, import_baml.toBamlError)(error);
+        }
+      }
+    };
+  }
+});
+
+// ../cli/ai/lib/baml_client/parser.js
+var import_baml2, LlmResponseParser, LlmStreamParser;
+var init_parser = __esm({
+  "../cli/ai/lib/baml_client/parser.js"() {
+    "use strict";
+    import_baml2 = require("@boundaryml/baml");
+    LlmResponseParser = class {
+      runtime;
+      ctxManager;
+      constructor(runtime, ctxManager) {
+        this.runtime = runtime;
+        this.ctxManager = ctxManager;
+      }
+      AnalyzeSdkDiff(llmResponse, __baml_options__) {
+        try {
+          const __rawEnv__ = __baml_options__?.env ? { ...process.env, ...__baml_options__.env } : { ...process.env };
+          const __env__ = Object.fromEntries(Object.entries(__rawEnv__).filter(([_2, value]) => value !== void 0));
+          return this.runtime.parseLlmResponse("AnalyzeSdkDiff", llmResponse, false, this.ctxManager.cloneContext(), __baml_options__?.tb?.__tb(), __baml_options__?.clientRegistry, __env__);
+        } catch (error) {
+          throw (0, import_baml2.toBamlError)(error);
+        }
+      }
+      ConsolidateChangelog(llmResponse, __baml_options__) {
+        try {
+          const __rawEnv__ = __baml_options__?.env ? { ...process.env, ...__baml_options__.env } : { ...process.env };
+          const __env__ = Object.fromEntries(Object.entries(__rawEnv__).filter(([_2, value]) => value !== void 0));
+          return this.runtime.parseLlmResponse("ConsolidateChangelog", llmResponse, false, this.ctxManager.cloneContext(), __baml_options__?.tb?.__tb(), __baml_options__?.clientRegistry, __env__);
+        } catch (error) {
+          throw (0, import_baml2.toBamlError)(error);
+        }
       }
-      return (/* @__PURE__ */ new Date()).toISOString() + " ";
-    }
-    function log(...args) {
-      return process.stderr.write(util.formatWithOptions(exports2.inspectOpts, ...args) + "\n");
-    }
-    function save(namespaces) {
-      if (namespaces) {
-        process.env.DEBUG = namespaces;
-      } else {
-        delete process.env.DEBUG;
+    };
+    LlmStreamParser = class {
+      runtime;
+      ctxManager;
+      constructor(runtime, ctxManager) {
+        this.runtime = runtime;
+        this.ctxManager = ctxManager;
       }
-    }
-    function load() {
-      return process.env.DEBUG;
-    }
-    function init(debug2) {
-      debug2.inspectOpts = {};
-      const keys2 = Object.keys(exports2.inspectOpts);
-      for (let i = 0; i < keys2.length; i++) {
-        debug2.inspectOpts[keys2[i]] = exports2.inspectOpts[keys2[i]];
+      AnalyzeSdkDiff(llmResponse, __baml_options__) {
+        try {
+          const __rawEnv__ = __baml_options__?.env ? { ...process.env, ...__baml_options__.env } : { ...process.env };
+          const __env__ = Object.fromEntries(Object.entries(__rawEnv__).filter(([_2, value]) => value !== void 0));
+          return this.runtime.parseLlmResponse("AnalyzeSdkDiff", llmResponse, true, this.ctxManager.cloneContext(), __baml_options__?.tb?.__tb(), __baml_options__?.clientRegistry, __env__);
+        } catch (error) {
+          throw (0, import_baml2.toBamlError)(error);
+        }
+      }
+      ConsolidateChangelog(llmResponse, __baml_options__) {
+        try {
+          const __rawEnv__ = __baml_options__?.env ? { ...process.env, ...__baml_options__.env } : { ...process.env };
+          const __env__ = Object.fromEntries(Object.entries(__rawEnv__).filter(([_2, value]) => value !== void 0));
+          return this.runtime.parseLlmResponse("ConsolidateChangelog", llmResponse, true, this.ctxManager.cloneContext(), __baml_options__?.tb?.__tb(), __baml_options__?.clientRegistry, __env__);
+        } catch (error) {
+          throw (0, import_baml2.toBamlError)(error);
+        }
       }
-    }
-    module2.exports = require_common()(exports2);
-    var { formatters } = module2.exports;
-    formatters.o = function(v2) {
-      this.inspectOpts.colors = this.useColors;
-      return util.inspect(v2, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
     };
-    formatters.O = function(v2) {
-      this.inspectOpts.colors = this.useColors;
-      return util.inspect(v2, this.inspectOpts);
+  }
+});
+
+// ../cli/ai/lib/baml_client/inlinedbaml.js
+var fileMap, getBamlFiles;
+var init_inlinedbaml = __esm({
+  "../cli/ai/lib/baml_client/inlinedbaml.js"() {
+    "use strict";
+    fileMap = {
+      "diff_analyzer.baml": '// SDK Diff Analyzer\n// Analyzes git diffs of SDK code and produces semantic commit messages and version bumps\n\nenum VersionBump {\n    MAJOR\n    MINOR\n    PATCH\n    NO_CHANGE\n}\n\nclass AnalyzeCommitDiffRequest {\n    diff string @description("The git diff to analyze for generating a commit message")\n}\n\nclass AnalyzeCommitDiffResponse {\n    message string\n        @description("Developer-facing git commit message. Use conventional commit format. Reference specific code symbols (function names, class names). Keep summary under 72 chars.")\n\n    changelog_entry string\n        @description("User-facing release note in Keep a Changelog format. Group under ### Breaking Changes, ### Added, ### Changed, ### Fixed section headers. Bold symbol names, one tight sentence per bullet. Prose only, no code fences. Append migration action inline for breaking changes. Empty string for PATCH.")\n\n    version_bump VersionBump\n        @description("The recommended semantic version bump: MAJOR for breaking changes, MINOR for new features, PATCH for bug fixes and other changes, NO_CHANGE for empty diffs")\n\n    version_bump_reason string\n        @description("One sentence explaining WHY this version bump was chosen. For MAJOR: name the specific breaking symbol(s). For MINOR: name the new capability. For PATCH: describe the fix. For NO_CHANGE: \'No functional changes detected.\' Example: \'MAJOR because `parserCreateJob` InputStream overloads were removed from `RawLabReportClient`.\'")\n}\n\n// Main function that analyzes SDK diffs\nfunction AnalyzeSdkDiff(\n    diff: string @description("The git diff to analyze"),\n    language: string @description("The SDK programming language, e.g. \'typescript\', \'python\', \'java\'"),\n    previous_version: string @description("The current published version before this change, e.g. \'1.2.3\'"),\n    prior_changelog: string @description("The last 3 changelog entries for this SDK, empty string if none. Use this to match the existing commit message style and understand the versioning pattern."),\n    spec_commit_message: string @description("The commit message from the API spec repository that triggered this SDK generation. Use as a hint for the intent of the change, but verify against the actual diff. Empty string if unavailable.")\n) -> AnalyzeCommitDiffResponse {\n  client DefaultClient\n\n  prompt #"\n    You are an expert software engineer analyzing changes to generate semantic commit messages.\n\n    Analyze the provided git diff and return a structured response with these fields:\n    - message: A git commit message formatted like the example below\n    - version_bump: One of: MAJOR, MINOR, PATCH, or NO_CHANGE\n\n    Version Bump Guidelines:\n    - MAJOR: Breaking changes (removed/renamed functions, changed signatures, removed parameters)\n    - MINOR: New features that are backward compatible (new functions, new optional parameters).\n      Also MINOR: behavioral changes invisible to the public API surface that still affect consumers:\n      - Changed HTTP status code handling (e.g. 404 now throws instead of returning null)\n      - Changed default parameter values (timeout, retry count, page size, base URL)\n      - Changed serialization behavior (date formats, null handling, field ordering)\n      - Changed error message text that consumers may depend on\n      - Changed HTTP header names or values sent to the server\n      - Changed retry or backoff behavior (different retry counts, delay strategies)\n    - PATCH: Bug fixes, documentation, internal refactoring with no observable behavioral change\n    - NO_CHANGE: The diff is empty\n\n    --- Examples ---\n\n    Examples of correct classifications:\n\n    --- MAJOR: removed exported TypeScript function ---\n    diff --git a/src/api/client.ts b/src/api/client.ts\n    -export async function getUser(id: string): Promise<User> {\n    -    return this.request("GET", `/users/${id}`);\n    -}\n    version_bump: MAJOR\n    reason: Existing callers of getUser() will get a compile error.\n\n    --- MAJOR: removed Python public method ---\n    diff --git a/vital/client.py b/vital/client.py\n    -    def get_user(self, user_id: str) -> User:\n    -        return self._request("GET", f"/users/{user_id}")\n    version_bump: MAJOR\n    reason: Existing callers crash with AttributeError.\n\n    --- MINOR: new optional TypeScript parameter ---\n    diff --git a/src/api/client.ts b/src/api/client.ts\n    -async createUser(name: string): Promise<User>\n    +async createUser(name: string, role?: UserRole): Promise<User>\n    version_bump: MINOR\n    reason: Existing callers unaffected \u2014 new parameter is optional.\n\n    --- MINOR: new Java public method ---\n    diff --git a/src/.../UsersClient.java b/src/.../UsersClient.java\n    +    public CompletableFuture<User> getUserAsync(String userId) {\n    +        return this.httpClient.sendAsync(...);\n    +    }\n    version_bump: MINOR\n    reason: New capability added, nothing removed or changed.\n\n    --- MINOR: changed default retry count ---\n    diff --git a/src/core/http_client.py b/src/core/http_client.py\n    -MAX_RETRIES = 3\n    +MAX_RETRIES = 5\n    version_bump: MINOR\n    reason: Changed default retry count \u2014 existing consumers will experience different retry behavior.\n\n    --- PATCH: Go import reorganization ---\n    diff --git a/client.go b/client.go\n    -import "fmt"\n    -import "net/http"\n    +import (\n    +    "fmt"\n    +    "net/http"\n    +)\n    version_bump: PATCH\n    reason: Formatting change only, no functional difference.\n\n    --- End Examples ---\n\n    {% if language == "typescript" %}\n    Language-specific breaking change rules for TypeScript:\n\n    MAJOR (breaking):\n    - Removing a required response field is always MAJOR\n    - Removing or renaming a public class, method, function, or exported symbol is MAJOR\n    - Making a response field optional is MAJOR (type changes from T to T | undefined, breaking existing property access without null checks)\n    - Changing a method return type (e.g. Promise<T> to Promise<T | undefined>, or T to T | null) is MAJOR\n    - New enum values are MAJOR if the SDK generates exhaustive switch/if-else chains (callers get compile errors on unhandled cases)\n    - Changing a union type (adding/removing variants) is MAJOR if callers use exhaustive type narrowing or discriminated unions\n    - Adding a new required property to a request/input type is MAJOR (existing callers won\'t compile)\n    - Removing or renaming an exported type, interface, or type alias is MAJOR\n    - Changing the type of an existing property (e.g. string to number, or string to string[]) is MAJOR\n    - Changing a generic type parameter constraint (e.g. <T extends Foo> to <T extends Bar>) is MAJOR\n    - Converting a synchronous method to async (or vice versa) is MAJOR (changes return type to Promise<T>)\n    - Removing a default export or switching between default and named exports is MAJOR\n    - Changing the structure of a discriminated union (e.g. changing the discriminant field name) is MAJOR\n    - Removing or renaming environment/server URL constants is MAJOR\n    - Changing the constructor signature of a client class (adding required params) is MAJOR\n    - Narrowing a parameter type (e.g. string | number to string) is MAJOR (callers passing number break)\n\n    MINOR (backward-compatible additions):\n    - Adding a new optional parameter to a function is MINOR\n    - Adding new exported types, interfaces, or classes is MINOR\n    - Adding new methods to an existing client class is MINOR\n    - Adding new optional properties to request types is MINOR\n    - Adding new enum values when NOT used in exhaustive checks is MINOR\n    - Adding new environment/server URL constants is MINOR\n    - Widening a parameter type (e.g. string to string | number) is MINOR\n    - Adding new re-exports from index files is MINOR\n    - Adding new error types or exception classes is MINOR\n    - Adding new RequestOptions fields (e.g. timeout, retries) is MINOR\n    - Deprecating (but not removing) a public API is MINOR\n\n    PATCH (no API surface change):\n    - Changes to internal/private modules (core/, _internal/, utils/) are PATCH\n    - Reordering imports, formatting, or comment changes are PATCH\n    - Updating SDK version headers (X-Fern-SDK-Version, User-Agent) is PATCH\n    - Refactoring HTTP client internals without changing observable defaults or behavior is PATCH\n    - Updating dependency versions in package.json is PATCH\n    - Adding or modifying JSDoc/TSDoc comments is PATCH\n    - Refactoring internal implementation without changing public signatures is PATCH\n    - Changes to .npmignore, tsconfig.json, or build configuration are PATCH\n    - Updating serialization/deserialization logic that preserves the same public types is PATCH\n\n    {% elif language == "python" %}\n    Language-specific breaking change rules for Python:\n\n    MAJOR (breaking):\n    - Removing a required response field is always MAJOR\n    - Removing or renaming a public class, method, or function is always MAJOR\n    - Adding a new required parameter to a public method is MAJOR (callers get TypeError)\n    - Renaming a parameter in a public method is MAJOR if callers use keyword arguments\n    - Removing a parameter from a public method signature is MAJOR\n    - Changing the type of a parameter from one concrete type to an incompatible one is MAJOR\n    - Changing exception types raised by a method (callers catching specific exceptions break) is MAJOR\n    - Removing or renaming a public module or subpackage is MAJOR (import statements break)\n    - Moving a public class/function to a different module without re-exporting from the original is MAJOR\n    - Changing a class from inheriting one base to another when callers use isinstance() checks is MAJOR\n    - Removing a public class attribute or property is MAJOR\n\n    MINOR (backward-compatible additions):\n    - Making a response field optional is usually MINOR (Python uses None propagation; callers rarely type-check strictly)\n    - New enum values are MINOR (unknown values are handled gracefully with string fallbacks)\n    - Changing a return type from a concrete type to Optional is MINOR (duck typing absorbs this)\n    - Adding new public methods, classes, or modules is MINOR\n    - Adding new optional parameters (with defaults) is MINOR\n    - Adding new optional fields to Pydantic models is MINOR\n    - Adding new exception/error classes is MINOR\n    - Adding new class attributes or properties is MINOR\n    - Adding new type overloads (@overload decorator) is MINOR\n    - Adding new environment/server URL constants is MINOR\n    - Adding new RequestOptions fields (e.g. timeout, max_retries) is MINOR\n    - Deprecating (but not removing) a public API is MINOR\n    - Widening a type annotation (e.g. str to Union[str, int]) is MINOR\n\n    PATCH (no API surface change):\n    - Changes to private methods (prefixed with _) are PATCH\n    - Changes to type hints only (no runtime effect) are PATCH\n    - Reformatting, docstring updates, or comment changes are PATCH\n    - Updating SDK version headers (X-Fern-SDK-Version, User-Agent) are PATCH\n    - Refactoring httpx/requests client internals without changing observable defaults or behavior is PATCH\n    - Updating dependency versions in pyproject.toml/setup.py is PATCH\n    - Updating serialization/deserialization logic that preserves the same public types is PATCH\n    - Refactoring internal implementation without changing public signatures is PATCH\n    - Changes to __init__.py that don\'t alter public re-exports are PATCH\n    - Changes to conftest.py, test files, or CI configuration are PATCH\n\n    {% elif language == "java" %}\n    Language-specific breaking change rules for Java:\n\n    MAJOR (breaking):\n    - Removing a required response field is always MAJOR\n    - Removing or renaming a public class, method, or interface is always MAJOR\n    - Making a response field optional (e.g. T to Optional<T>) is MAJOR (callers must handle Optional unwrapping)\n    - New enum values are MAJOR if the SDK generates exhaustive switch statements\n    - Adding a new required parameter to a public method is MAJOR\n    - Changing a method\'s return type is MAJOR (even if compatible at runtime, recompilation fails)\n    - Removing or changing a public static final constant is MAJOR\n    - Changing a class from concrete to abstract (or vice versa) is MAJOR\n    - Changing the checked exceptions declared in a throws clause is MAJOR\n    - Removing a public constructor or changing its parameter list is MAJOR\n    - Removing an interface that a public class implements is MAJOR\n    - Changing generic type parameters on a public class (e.g. Foo<T> to Foo<T, U>) is MAJOR\n    - Moving a public class to a different package without re-exporting is MAJOR\n    - Narrowing a parameter type (e.g. Object to String) is MAJOR\n    - Making a non-final class final is MAJOR (breaks subclassing)\n    - Changing the type of a builder method parameter is MAJOR\n\n    MINOR (backward-compatible additions):\n    - Adding new overloaded methods is MINOR\n    - Adding new public classes or interfaces is MINOR\n    - Adding new optional builder methods is MINOR\n    - Adding new enum values when NOT used in exhaustive switch statements is MINOR\n    - Adding new optional fields to request objects is MINOR\n    - Adding new exception/error classes is MINOR\n    - Adding new static utility methods is MINOR\n    - Adding new environment/server URL constants is MINOR\n    - Adding new RequestOptions fields (e.g. timeout, retries) is MINOR\n    - Widening a parameter type (e.g. String to Object) is MINOR\n    - Adding default methods to interfaces (Java 8+) is MINOR\n    - Deprecating (but not removing) public APIs with @Deprecated is MINOR\n\n    PATCH (no API surface change):\n    - Changes to package-private or private methods are PATCH\n    - Changes to annotations (other than public API annotations), Javadoc, or formatting are PATCH\n    - Updating SDK version headers (X-Fern-SDK-Version, User-Agent) is PATCH\n    - Refactoring OkHttp/HttpClient internals without changing observable defaults or behavior is PATCH\n    - Updating dependency versions in build.gradle/pom.xml is PATCH\n    - Refactoring internal implementation without changing public signatures is PATCH\n    - Updating serialization/deserialization logic (Jackson/Gson config) that preserves public types is PATCH\n    - Changes to test files, CI configuration, or build scripts are PATCH\n\n    {% elif language == "go" %}\n    Language-specific breaking change rules for Go:\n\n    MAJOR (breaking):\n    - Removing a required response field is always MAJOR\n    - Removing or renaming an exported function, method, or type is always MAJOR\n    - Making a response field a pointer type (e.g. string to *string) is MAJOR (callers must dereference)\n    - Changing a function signature (adding/removing parameters or return values) is MAJOR (Go has no overloading)\n    - Removing or renaming an exported struct field is MAJOR\n    - Changing the type of an exported struct field is MAJOR\n    - Removing or renaming an exported constant or variable is MAJOR\n    - Changing an interface by adding methods is MAJOR (all implementations must add the method)\n    - Removing a method from an interface is MAJOR (callers using that method break)\n    - Changing a function\'s return type(s) is MAJOR (Go is strict about return types)\n    - Changing a variadic parameter to non-variadic (or vice versa) is MAJOR\n    - Moving a type/function to a different package without aliasing in the original is MAJOR\n    - Changing the receiver type of a method (value receiver to pointer receiver changes method set) is MAJOR\n    - Changing an exported error variable\'s type or value is MAJOR (callers using errors.Is break)\n\n    MINOR (backward-compatible additions):\n    - Adding new exported functions, methods, or types is MINOR\n    - New enum-like constants are MINOR (Go enums are not exhaustive by default)\n    - Adding new fields to a struct is MINOR (existing code still compiles, zero-value initialization)\n    - Making a response field optional (pointer) is usually MINOR if the field was already a struct field\n    - Adding new optional function parameters via functional options pattern is MINOR\n    - Adding new interface types is MINOR\n    - Adding new error types/variables is MINOR\n    - Adding new environment/server URL constants is MINOR\n    - Adding new RequestOption functions is MINOR\n    - Widening a return type from a concrete type to an interface is MINOR (if interface is satisfied)\n    - Adding new methods to a concrete type (does not break interface implementations) is MINOR\n\n    PATCH (no API surface change):\n    - Changes to unexported (lowercase) functions or types are PATCH\n    - Changes to go.mod dependencies, import reordering, or formatting are PATCH\n    - Updating SDK version headers (X-Fern-SDK-Version, User-Agent) is PATCH\n    - Refactoring http.Client internals without changing observable defaults or behavior is PATCH\n    - Updating serialization/deserialization logic (JSON tags, encoding) that preserves identical output is PATCH\n    - Refactoring internal implementation without changing exported signatures is PATCH\n    - Changes to *_test.go files, Makefile, or CI configuration are PATCH\n    - Updating comments, godoc, or code formatting (gofmt) is PATCH\n\n    {% elif language == "ruby" %}\n    Language-specific breaking change rules for Ruby:\n\n    MAJOR (breaking):\n    - Removing a required response field is always MAJOR\n    - Removing or renaming a public method is MAJOR (callers get NoMethodError)\n    - Adding a new required positional parameter is MAJOR\n    - Removing a method parameter is MAJOR (callers passing that argument get ArgumentError)\n    - Changing the order of positional parameters is MAJOR\n    - Removing or renaming a public class or module is MAJOR (callers get NameError)\n    - Changing a method from instance to class method (or vice versa) is MAJOR\n    - Changing the return type in a breaking way (e.g. returning nil where an object was expected and callers chain methods) is MAJOR\n    - Removing a public constant is MAJOR\n    - Changing exception types raised by a method is MAJOR (callers rescuing specific exceptions break)\n\n    MINOR (backward-compatible additions):\n    - Making a response field optional is usually MINOR (Ruby uses nil propagation; callers rarely type-check)\n    - New enum values are MINOR (unknown values are handled gracefully)\n    - Adding new optional keyword parameters (with defaults) is MINOR\n    - Adding new public methods or classes is MINOR\n    - Adding new optional fields to response/request objects is MINOR\n    - Adding new exception/error classes is MINOR\n    - Adding new environment/server URL constants is MINOR\n    - Adding new RequestOptions fields (e.g. timeout, max_retries) is MINOR\n    - Deprecating (but not removing) a public API is MINOR\n    - Adding new modules or mixins is MINOR\n\n    PATCH (no API surface change):\n    - Changes to private methods are PATCH\n    - Gemspec metadata, comment, or formatting changes are PATCH\n    - Updating SDK version headers is PATCH\n    - Refactoring Faraday/Net::HTTP internals without changing observable defaults or behavior is PATCH\n    - Updating dependency versions in Gemfile/gemspec is PATCH\n    - Refactoring internal implementation without changing public signatures is PATCH\n    - Changes to test files, Rakefile, or CI configuration are PATCH\n\n    {% elif language == "csharp" %}\n    Language-specific breaking change rules for C#:\n\n    MAJOR (breaking):\n    - Removing a required response field is always MAJOR\n    - Removing or renaming a public class, method, property, or interface is always MAJOR\n    - Making a response field nullable (e.g. T to T?) is MAJOR (callers must handle null checks)\n    - New enum values are MAJOR if the SDK generates exhaustive switch expressions\n    - Adding a new required parameter to a public method is MAJOR\n    - Changing a method\'s return type is MAJOR\n    - Removing or changing a public constant or static readonly field is MAJOR\n    - Changing a class from non-sealed to sealed (or abstract to concrete) is MAJOR\n    - Changing the base class of a public class is MAJOR\n    - Removing an interface implementation from a public class is MAJOR\n    - Changing generic type constraints on a public class or method is MAJOR\n    - Moving a public type to a different namespace without type forwarding is MAJOR\n    - Changing property from read-write to read-only (removing setter) is MAJOR\n    - Changing async method to sync (Task<T> to T) or vice versa is MAJOR\n\n    MINOR (backward-compatible additions):\n    - Adding new public classes, interfaces, or methods is MINOR\n    - Adding new optional parameters (with default values) is MINOR\n    - Adding new overloaded methods is MINOR\n    - Adding new enum values when NOT used in exhaustive switch expressions is MINOR\n    - Adding new optional properties to request objects is MINOR\n    - Adding new exception types is MINOR\n    - Adding new environment/server URL constants is MINOR\n    - Adding new RequestOptions fields (e.g. Timeout, MaxRetries) is MINOR\n    - Adding new extension methods is MINOR\n    - Deprecating (but not removing) public APIs with [Obsolete] is MINOR\n\n    PATCH (no API surface change):\n    - Changes to internal or private members are PATCH\n    - XML doc comments, formatting, or namespace reorganization are PATCH\n    - Updating SDK version headers is PATCH\n    - Refactoring HttpClient internals without changing observable defaults or behavior is PATCH\n    - Updating dependency versions in .csproj is PATCH\n    - Refactoring internal implementation without changing public signatures is PATCH\n    - Updating serialization/deserialization (System.Text.Json/Newtonsoft) config that preserves public types is PATCH\n    - Changes to test files, .sln, or CI configuration are PATCH\n\n    {% elif language == "php" %}\n    Language-specific breaking change rules for PHP:\n\n    MAJOR (breaking):\n    - Removing a required response field is always MAJOR\n    - Removing or renaming a public method or class is always MAJOR\n    - Changing a method signature (adding required parameters) is MAJOR\n    - Removing a method parameter is MAJOR\n    - Changing the type declaration of a parameter to an incompatible type is MAJOR\n    - Removing or renaming a public constant is MAJOR\n    - Changing a class from non-final to final is MAJOR (breaks extension)\n    - Removing an interface implementation from a public class is MAJOR\n    - Changing the return type declaration to an incompatible type is MAJOR\n    - Moving a class to a different namespace without aliasing is MAJOR\n    - Changing exception types thrown by a method is MAJOR\n\n    MINOR (backward-compatible additions):\n    - Making a response field nullable is MINOR in most cases (PHP is dynamically typed)\n    - Adding new optional parameters (with defaults) is MINOR\n    - Adding new public classes or methods is MINOR\n    - New enum cases are usually MINOR (PHP enums are not typically used in exhaustive matches)\n    - Adding new optional fields to request/response objects is MINOR\n    - Adding new exception classes is MINOR\n    - Adding new environment/server URL constants is MINOR\n    - Adding new traits or interfaces is MINOR\n    - Adding new RequestOptions fields is MINOR\n    - Deprecating (but not removing) public APIs is MINOR\n\n    PATCH (no API surface change):\n    - Changes to private/protected methods are PATCH\n    - PHPDoc, formatting, or composer.json metadata changes are PATCH\n    - Updating SDK version headers is PATCH\n    - Refactoring Guzzle/cURL internals without changing observable defaults or behavior is PATCH\n    - Updating dependency versions in composer.json is PATCH\n    - Refactoring internal implementation without changing public signatures is PATCH\n    - Changes to test files, phpunit.xml, or CI configuration are PATCH\n\n    {% elif language == "swift" %}\n    Language-specific breaking change rules for Swift:\n\n    MAJOR (breaking):\n    - Removing a required response field is always MAJOR\n    - Removing or renaming a public method, property, or type is always MAJOR\n    - Making a response field optional (T to T?) is MAJOR (callers must unwrap with if-let/guard)\n    - New enum cases are MAJOR (Swift switch statements must be exhaustive unless using default)\n    - Adding a new required parameter to a public method is MAJOR\n    - Changing the type of a public property is MAJOR\n    - Removing or changing a public protocol requirement is MAJOR\n    - Removing protocol conformance from a public type is MAJOR\n    - Changing a struct to a class (or vice versa) is MAJOR (value vs reference semantics)\n    - Making a public initializer failable (init to init?) or vice versa is MAJOR\n    - Changing the associated values of an enum case is MAJOR\n    - Removing a public typealias is MAJOR\n    - Changing access level from public to internal/private is MAJOR\n\n    MINOR (backward-compatible additions):\n    - Adding new public types, methods, or properties is MINOR\n    - Adding new optional parameters (with default values) is MINOR\n    - Adding new enum cases when callers use default in switch is MINOR\n    - Adding new protocol extensions with default implementations is MINOR\n    - Adding new optional fields to request/response structs is MINOR\n    - Adding new error types is MINOR\n    - Adding new environment/server URL constants is MINOR\n    - Adding new RequestOptions fields is MINOR\n    - Adding new convenience initializers is MINOR\n    - Deprecating (but not removing) public APIs with @available(*, deprecated) is MINOR\n\n    PATCH (no API surface change):\n    - Changes to internal or private members are PATCH\n    - Formatting, comments, or documentation changes are PATCH\n    - Updating SDK version headers is PATCH\n    - Refactoring URLSession internals without changing observable defaults or behavior is PATCH\n    - Updating dependency versions in Package.swift is PATCH\n    - Refactoring internal implementation without changing public signatures is PATCH\n    - Changes to test files, xcconfig, or CI configuration are PATCH\n\n    {% elif language == "rust" %}\n    Language-specific breaking change rules for Rust:\n\n    MAJOR (breaking):\n    - Removing a required response field is always MAJOR\n    - Removing or renaming a public function, struct, enum, or trait is always MAJOR\n    - Making a response field optional (T to Option<T>) is MAJOR (callers must handle the Option)\n    - New enum variants are MAJOR (Rust match statements must be exhaustive unless using _ wildcard)\n    - Adding a new required field to a public struct is MAJOR (unless #[non_exhaustive])\n    - Removing a public trait implementation is MAJOR\n    - Changing a function\'s return type is MAJOR\n    - Adding a required method to a public trait is MAJOR (all implementations must add it)\n    - Changing the type of a public struct field is MAJOR\n    - Removing or renaming a public module is MAJOR\n    - Making a public type private (pub to pub(crate) or removing pub) is MAJOR\n    - Changing a struct from non-exhaustive to exhaustive construction (removing .. Default::default()) is MAJOR\n    - Changing generic type parameters or their bounds on public types is MAJOR\n    - Changing from Result<T, E1> to Result<T, E2> where E2 is a different error type is MAJOR\n    - Removing a public constant or static is MAJOR\n\n    MINOR (backward-compatible additions):\n    - Adding new public functions, structs, or enums is MINOR\n    - Adding new optional fields to #[non_exhaustive] structs is MINOR\n    - Adding new enum variants to #[non_exhaustive] enums is MINOR\n    - Adding new trait implementations for existing types is MINOR\n    - Adding new public constants or statics is MINOR\n    - Adding new methods to existing impl blocks is MINOR\n    - Adding new error types is MINOR\n    - Adding new environment/server URL constants is MINOR\n    - Adding new RequestOptions fields is MINOR\n    - Adding new optional builder methods is MINOR\n    - Deprecating (but not removing) public APIs with #[deprecated] is MINOR\n\n    PATCH (no API surface change):\n    - Changes to pub(crate) or private items are PATCH\n    - Cargo.toml metadata, formatting, or comment changes are PATCH\n    - Updating SDK version headers is PATCH\n    - Refactoring reqwest/hyper internals without changing observable defaults or behavior is PATCH\n    - Updating dependency versions in Cargo.toml is PATCH\n    - Refactoring internal implementation without changing public signatures is PATCH\n    - Updating serialization/deserialization (serde) config that preserves public types is PATCH\n    - Changes to test files, build.rs, or CI configuration are PATCH\n\n    {% elif language == "kotlin" %}\n    Language-specific breaking change rules for Kotlin:\n\n    MAJOR (breaking):\n    - Removing a required response field is always MAJOR\n    - Removing or renaming a public function, class, or property is always MAJOR\n    - Making a response field nullable (T to T?) is MAJOR (callers must handle null safety operators)\n    - New enum values are MAJOR if used in when() expressions without else branch\n    - Adding a new required parameter to a public function is MAJOR\n    - Changing a method\'s return type is MAJOR\n    - Removing or changing a public constant (const val / companion object val) is MAJOR\n    - Changing a class from open to final (or data class to regular class) is MAJOR\n    - Removing an interface implementation from a public class is MAJOR\n    - Changing generic type parameters or their variance (in/out) on public types is MAJOR\n    - Moving a public class to a different package without type aliasing is MAJOR\n    - Changing a property from var to val (or removing a setter) is MAJOR\n    - Changing a suspend function to non-suspend (or vice versa) is MAJOR\n    - Changing sealed class/interface hierarchy (removing subclasses) is MAJOR\n\n    MINOR (backward-compatible additions):\n    - Adding new public classes, functions, or extension functions is MINOR\n    - Adding new optional parameters (with default values) is MINOR\n    - Adding new enum values when callers use else in when() is MINOR\n    - Adding new optional properties to data classes is MINOR\n    - Adding new exception types is MINOR\n    - Adding new environment/server URL constants is MINOR\n    - Adding new RequestOptions fields is MINOR\n    - Adding new sealed class/interface subtypes is MINOR (if callers have else branch)\n    - Deprecating (but not removing) public APIs with @Deprecated is MINOR\n    - Adding new companion object functions is MINOR\n\n    PATCH (no API surface change):\n    - Changes to internal or private members are PATCH\n    - KDoc, formatting, or build.gradle changes are PATCH\n    - Updating SDK version headers is PATCH\n    - Refactoring OkHttp internals without changing observable defaults or behavior is PATCH\n    - Updating dependency versions in build.gradle.kts is PATCH\n    - Refactoring internal implementation without changing public signatures is PATCH\n    - Updating serialization/deserialization (kotlinx.serialization/Moshi) config that preserves public types is PATCH\n    - Changes to test files or CI configuration are PATCH\n\n    {% else %}\n    Language-specific breaking change rules (language: {{ language }}):\n\n    MAJOR (breaking):\n    - Removing a required response field is always MAJOR\n    - Removing or renaming a public class, method, or function is always MAJOR\n    - Making a response field optional is MAJOR in statically-typed languages (TypeScript, Java, C#, Swift, Rust, Kotlin, Go), usually MINOR in dynamically-typed ones (Python, Ruby, PHP)\n    - New enum values are MAJOR if the language enforces exhaustive matching (TypeScript, Java, C#, Swift, Rust), MINOR otherwise\n    - Adding a new required parameter to a public method is MAJOR\n    - Changing a method\'s return type is MAJOR\n    - Changing the type of an existing field/property is MAJOR\n    - Removing or changing public constants is MAJOR\n\n    MINOR (backward-compatible additions):\n    - Adding new public APIs (classes, methods, functions) is MINOR\n    - Adding new optional parameters is MINOR\n    - Adding new optional fields to request/response objects is MINOR\n    - Adding new error/exception types is MINOR\n    - Deprecating (but not removing) public APIs is MINOR\n\n    PATCH (no API surface change):\n    - Internal/private changes are PATCH\n    - Formatting, documentation, or comment changes are PATCH\n    - Dependency version updates are PATCH\n    - SDK version header updates are PATCH\n    - Refactoring retry/timeout internals without changing observable defaults or behavior is PATCH\n    - Refactoring internals without changing public signatures is PATCH\n    {% endif %}\n\n    Apply these patterns to the diff below. When in doubt between MINOR and PATCH,\n    prefer MINOR. When in doubt between MAJOR and MINOR, examine whether existing\n    callers would break without any code changes on their side.\n\n    Message Format (use this exact structure):\n    ```\n    <type>: <short summary>\n\n    <detailed description of what changed and why it matters>\n\n    Key changes:\n    - <change 1>\n    - <change 2>\n    - <change 3>\n    ```\n\n    Message Guidelines:\n    - The commit type MUST match the version bump:\n      - MAJOR \u2192 use "feat!:" prefix (the "!" signals a breaking change per Conventional Commits)\n      - MINOR \u2192 use "feat:" prefix\n      - PATCH \u2192 use "fix:" or "chore:" prefix (whichever fits the change)\n      - NO_CHANGE \u2192 use "chore:" prefix\n    - Keep the summary line under 72 characters\n    - Write in present tense imperative mood ("add" not "added" or "adds")\n    - For MAJOR: the summary MUST name the breaking change (e.g., "feat!: remove parserCreateJob InputStream overloads")\n    - For MINOR: the summary should name the new capability\n    - For PATCH: describe the fix or improvement\n    - Be specific \u2014 do not use generic summaries like "update SDK" or "regenerate SDK"\n    - Do not use "Fern regeneration" in commit messages \u2014 use "SDK regeneration" instead\n    - NEVER include the literal version "0.0.0-fern-placeholder" in the commit message \u2014 if you see this placeholder\n      in the diff, describe changes generically (e.g., "added X-Fern-SDK-Version header")\n    - The previous version is provided for context only. Do not include it literally in the summary line.\n\n    {% if prior_changelog %}\n    Prior changelog entries (for style reference):\n    ---\n    {{prior_changelog}}\n    ---\n    Match the tone and format of these entries in your commit message.\n    {% endif %}\n\n    {% if spec_commit_message %}\n    The API spec change that triggered this SDK generation had the following commit message:\n    "{{spec_commit_message}}"\n    Use this as a hint for understanding the intent of the change, but always verify\n    against the actual diff below. The commit message may be vague or inaccurate.\n    {% endif %}\n\n    Previous version: {{previous_version}}\n    SDK language: {{language}}\n\n    Git Diff:\n    ---\n    {{diff}}\n    ---\n\n    Changelog Entry Guidelines:\n    - Write for SDK consumers, not engineers reading the source code\n    - Structure the changelog entry using Keep a Changelog section headers, omitting empty sections:\n\n      ### Breaking Changes\n      - **`symbolName`** \u2014 what broke and how to migrate.\n\n      ### Added\n      - **`symbolName`** \u2014 what was added, one sentence.\n\n      ### Changed\n      - **`symbolName`** \u2014 what changed, one sentence.\n\n      ### Fixed\n      - **`symbolName`** \u2014 what was fixed, one sentence.\n\n    - Section mapping to version bumps:\n      - MAJOR changes go under ### Breaking Changes\n      - MINOR additions go under ### Added\n      - MINOR behavioral changes go under ### Changed\n      - PATCH fixes go under ### Fixed (or empty string if trivial)\n    - **Breaking Changes** section MUST come first when present\n    - Bold the symbol name, then a dash, then one tight sentence\n    - No code fences in the changelog \u2014 prose and backtick-wrapped symbols only\n    - One line per change, no multi-line bullets\n    - For Breaking Changes: name the exact symbol, explain what broke, and give a one-line migration\n      Example: "- **`parserCreateJob`** now accepts `File[]` instead of `File`. Wrap single files in an array: `parserCreateJob([file], request)`."\n    - For Added: name the new capability in one sentence\n      Example: "- **`LabAccountClient`** for managing team lab accounts."\n    - Describe patterns once, not per-file. If the same method was added to 50 classes,\n      write ONE entry: "- **`additionalProperty()`** and **`additionalProperties()`** builder methods on all request types."\n      Do NOT write 50 separate entries.\n    - NEVER silently drop a category of change. If new enum values were added, new clients were introduced,\n      or fields were removed, each *category* must appear \u2014 but you don\'t need to list every individual value.\n      GOOD: "- **New enum values** added across several types including `ProviderType` and `OrderStatus`."\n      BAD:  listing every enum value\n    - PATCH: leave empty string \u2014 patch changes don\'t warrant changelog entries\n    - Do not use conventional commit prefixes (no "feat:", "fix:", etc.)\n    - Write in third person present tense\n    - Prefer fewer, richer entries over many thin ones. Aim for 3-5 entries per chunk by grouping related changes.\n    - IMPORTANT: Wrap type references containing angle brackets in backticks (e.g., `Optional<String>`)\n    - **5-line limit per section**: Each section (### Breaking Changes, ### Added, ### Changed, ### Fixed)\n      MUST have at most 5 bullet points. If a section would have more than 5 bullets, keep the 5 most\n      important ones and add a final line: "- See full changelog for all changes"\n\n    Remember again that YOU MUST return a structured JSON response with these four fields:\n    - message: A git commit message formatted like the example previously provided\n    - changelog_entry: A user-facing release note (empty string for PATCH)\n    - version_bump: One of: MAJOR, MINOR, PATCH, or NO_CHANGE\n    - version_bump_reason: One sentence explaining WHY this bump level was chosen.\n      For MAJOR, name the specific breaking symbol(s) and explain why existing callers break.\n      For MINOR, name the new capability added.\n      For PATCH, describe what was fixed or improved.\n      For NO_CHANGE, say "No functional changes detected."\n      Example: "MAJOR because `parserCreateJob` InputStream overloads were removed from `RawLabReportClient`, breaking existing callers."\n  "#\n}\n\nclass ConsolidateChangelogResponse {\n    consolidated_changelog string\n        @description("CHANGELOG.md entry in Keep a Changelog format. Group under ### Breaking Changes, ### Added, ### Changed, ### Fixed. Bold symbol names, one tight sentence per bullet. Prose only, no code fences. Append migration action inline for breaking changes.")\n\n    pr_description string\n        @description("PR description with ## Breaking Changes section (if any) containing ### per breaking change with Before/After code fences and Migration line, then ## What\'s New section summarizing features in prose paragraphs grouped by theme. Do NOT list every class individually \u2014 summarize repetitive changes as a single entry.")\n\n    version_bump_reason string\n        @description("One sentence explaining WHY the overall version bump was chosen. For MAJOR: name the specific breaking symbol(s). For MINOR: name the new capability. For PATCH: describe the fix. Example: \'MAJOR because `parserCreateJob` InputStream overloads were removed from `RawLabReportClient`.\'")\n}\n\nfunction ConsolidateChangelog(\n    raw_entries: string @description("Newline-separated raw changelog entries from chunked diff analysis"),\n    version_bump: string @description("The overall version bump: MAJOR, MINOR, or PATCH"),\n    language: string @description("The SDK programming language, e.g. \'typescript\', \'python\', \'java\'"),\n    previous_version: string @description("The previous SDK version before this change, e.g. \'1.2.3\'. Empty string if unknown."),\n    new_version: string @description("The new SDK version after this change, e.g. \'1.3.0\'. Empty string if unknown.")\n) -> ConsolidateChangelogResponse {\n  client DefaultClient\n\n  prompt #"\n    You are a technical writer producing release notes for a {{language}} SDK.\n\n    ## Input\n\n    Raw changelog entries from chunked diff analysis (noisy, repetitive):\n    ---\n    {{raw_entries}}\n    ---\n\n    Overall version bump: {{version_bump}}\n    {% if previous_version %}Previous version: {{previous_version}}{% endif %}\n    {% if new_version %}New version: {{new_version}}{% endif %}\n\n    ## Deduplication Rules (CRITICAL)\n\n    Before writing anything, apply these deduplication rules:\n\n    1. **Pattern collapse**: If the same method/field/type was added/changed/removed across\n       multiple classes or files, write ONE bullet summarizing the pattern.\n       BAD:  "- `additionalProperty()` added to UserRequest" + "- `additionalProperty()` added to OrderRequest" + ... (x15)\n       GOOD: "- **`additionalProperty()`** and **`additionalProperties()`** builder methods added to all request and response types"\n\n    2. **Semantic merge**: If multiple entries describe aspects of the same feature, merge them.\n       BAD:  "- New LabAccountClient" + "- New getTeamLabAccounts method" + "- Lab account management support"\n       GOOD: "- **`LabAccountClient`** \u2014 new client for managing team lab accounts with `getTeamLabAccounts()` support"\n\n    3. **No silent drops**: Every *category* of change (new clients, new methods, removed methods,\n       new enum values, field type changes, etc.) must be represented in at least one bullet.\n       You don\'t need to list every individual value or class \u2014 just acknowledge the category.\n       GOOD: "- **New enum values** added across several types including `ProviderType` and `OrderStatus`"\n       BAD:  Silently omitting that enum values changed at all\n       ALSO BAD: Listing every value: `SamsungHealth`, `SonoraQuest`, `Cancelled`, `Processing`, ...\n\n    4. **Prefer concise output**: Aim for 5-15 bullets total. Prioritize breaking changes and new\n       capabilities. Bulk additions (builder methods, enum values) get one summary bullet each.\n\n    ## Output 1: consolidated_changelog (CHANGELOG.md entry)\n\n    Structure it EXACTLY like this, omitting empty sections:\n\n    ### Breaking Changes\n    - **`symbolName`** \u2014 what broke and how to migrate. Example: replace `foo(file)` with `foo([file])`.\n\n    ### Added\n    - **`symbolName`** \u2014 what was added, one sentence.\n\n    ### Changed\n    - **`symbolName`** \u2014 what changed, one sentence.\n\n    ### Fixed\n    - **`symbolName`** \u2014 what was fixed, one sentence.\n\n    Rules:\n    - **Breaking Changes** section MUST come first when present\n    - Bold the symbol name, then a dash, then one tight sentence\n    - No code fences in the changelog \u2014 prose and backtick-wrapped symbols only\n    - Aim for 5-15 total bullets. Every *category* of change must be represented, but individual\n      values/classes within a category can be summarized (e.g., "new enum values across several types").\n    - One line per change, no multi-line bullets\n    - **5-line limit per section**: Each section (### Breaking Changes, ### Added, ### Changed, ### Fixed)\n      MUST have at most 5 bullet points. If a section would have more than 5 bullets, keep the 5 most\n      important ones and add a final line: "- See full changelog for all changes"\n\n    ## Output 2: pr_description (PR body)\n\n    Do NOT include a version header \u2014 the version header is added separately by the build system.\n\n    If version_bump is MAJOR, start with:\n\n    ## Breaking Changes\n\n    ### `symbolName` \u2014 short description\n    **Before:**\n    ```{{language}}\n    // old usage\n    ```\n    **After:**\n    ```{{language}}\n    // new usage\n    ```\n    **Migration:** One sentence on how to update.\n\n    (repeat for each breaking change)\n\n    Then:\n\n    ## What\'s New\n    Brief prose paragraphs grouped by theme. Do NOT list every class \u2014 summarize patterns.\n\n    If version_bump is MINOR or PATCH, just use:\n\n    ## What\'s New\n    Brief prose paragraphs grouped by theme. Do NOT list every class \u2014 summarize patterns.\n\n    Rules:\n    - Breaking changes section at top with Before/After code examples\n    - What\'s New in prose paragraphs, not bullet lists \u2014 group by theme (e.g., "Lab account management", "Builder improvements")\n    - Do NOT list every class that got the same method \u2014 summarize as one theme\n    - Every *category* of change from the changelog must be mentioned somewhere in the PR description.\n      Don\'t enumerate every value \u2014 summarize bulk changes in a sentence.\n\n    ## Output 3: version_bump_reason\n\n    One sentence explaining WHY the overall version bump ({{version_bump}}) was chosen.\n    - For MAJOR: name the specific breaking symbol(s) and explain why existing callers break\n    - For MINOR: name the new capability added\n    - For PATCH: describe what was fixed or improved\n    - Example: "MAJOR because `parserCreateJob` InputStream overloads were removed from `RawLabReportClient`, breaking existing callers that pass InputStream arguments."\n\n    {{ ctx.output_format }}\n  "#\n}\n',
+      "generators.baml": 'generator target {\n    output_type "typescript"\n\n    output_dir "../src/"\n\n    version "0.219.0"\n\n    default_client_mode async\n}\n',
+      "main.baml": "// BAML client configuration for LLM providers\n\n// OpenAI client configuration\nclient<llm> OpenAI {\n  provider openai\n  options {\n    model gpt-4o\n    api_key env.OPENAI_API_KEY\n  }\n}\n\n// Anthropic client configuration\nclient<llm> Anthropic {\n  provider anthropic\n  options {\n    model claude-sonnet-4-5-20250929\n    api_key env.ANTHROPIC_API_KEY\n  }\n}\n\n// Bedrock client configuration\nclient<llm> Bedrock {\n    provider aws-bedrock\n    options {\n        model anthropic.claude-3-5-sonnet-20240620-v1:0\n    }\n}\n\n// Fallback client that tries multiple providers\n// TODO(tjb9dc): I wish we didn't have to specify this, we're only going to use one at runtime\nclient<llm> DefaultClient {\n  provider fallback\n  options {\n    strategy [\n      Anthropic\n      OpenAI\n      Bedrock\n    ]\n  }\n}\n"
+    };
+    getBamlFiles = () => {
+      return fileMap;
     };
   }
 });
 
-// ../../node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/index.js
-var require_src = __commonJS({
-  "../../node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/index.js"(exports2, module2) {
+// ../cli/ai/lib/baml_client/globals.js
+function resetBamlEnvVars(envVars) {
+  if (DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_CTX.allowResets()) {
+    const envVarsToReset = Object.fromEntries(Object.entries(envVars).filter((kv) => kv[1] !== void 0));
+    DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_RUNTIME.reset("baml_src", getBamlFiles(), envVarsToReset);
+    DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_CTX.reset();
+  } else {
+    throw new Error("BamlError: Cannot reset BAML environment variables while there are active BAML contexts.");
+  }
+}
+var import_baml3, env, DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_RUNTIME, DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_CTX;
+var init_globals = __esm({
+  "../cli/ai/lib/baml_client/globals.js"() {
     "use strict";
-    if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) {
-      module2.exports = require_browser();
-    } else {
-      module2.exports = require_node();
-    }
+    import_baml3 = require("@boundaryml/baml");
+    init_inlinedbaml();
+    env = { ...process.env };
+    DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_RUNTIME = import_baml3.BamlRuntime.fromFiles("baml_src", getBamlFiles(), env);
+    DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_CTX = new import_baml3.BamlCtxManager(DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_RUNTIME);
   }
 });
 
-// ../../node_modules/.pnpm/@kwsites+file-exists@1.1.1/node_modules/@kwsites/file-exists/dist/src/index.js
-var require_src2 = __commonJS({
-  "../../node_modules/.pnpm/@kwsites+file-exists@1.1.1/node_modules/@kwsites/file-exists/dist/src/index.js"(exports2) {
+// ../cli/ai/lib/baml_client/async_client.js
+var import_baml4, BamlAsyncClient, BamlStreamClient, b2;
+var init_async_client = __esm({
+  "../cli/ai/lib/baml_client/async_client.js"() {
     "use strict";
-    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
-      return mod && mod.__esModule ? mod : { "default": mod };
-    };
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    var fs_1 = require("fs");
-    var debug_1 = __importDefault(require_src());
-    var log = debug_1.default("@kwsites/file-exists");
-    function check(path3, isFile, isDirectory) {
-      log(`checking %s`, path3);
-      try {
-        const stat2 = fs_1.statSync(path3);
-        if (stat2.isFile() && isFile) {
-          log(`[OK] path represents a file`);
-          return true;
+    import_baml4 = require("@boundaryml/baml");
+    init_async_request();
+    init_parser();
+    init_globals();
+    BamlAsyncClient = class _BamlAsyncClient {
+      runtime;
+      ctxManager;
+      streamClient;
+      httpRequest;
+      httpStreamRequest;
+      llmResponseParser;
+      llmStreamParser;
+      bamlOptions;
+      constructor(runtime, ctxManager, bamlOptions) {
+        this.runtime = runtime;
+        this.ctxManager = ctxManager;
+        this.streamClient = new BamlStreamClient(runtime, ctxManager, bamlOptions);
+        this.httpRequest = new AsyncHttpRequest(runtime, ctxManager);
+        this.httpStreamRequest = new AsyncHttpStreamRequest(runtime, ctxManager);
+        this.llmResponseParser = new LlmResponseParser(runtime, ctxManager);
+        this.llmStreamParser = new LlmStreamParser(runtime, ctxManager);
+        this.bamlOptions = bamlOptions || {};
+      }
+      withOptions(bamlOptions) {
+        return new _BamlAsyncClient(this.runtime, this.ctxManager, bamlOptions);
+      }
+      get stream() {
+        return this.streamClient;
+      }
+      get request() {
+        return this.httpRequest;
+      }
+      get streamRequest() {
+        return this.httpStreamRequest;
+      }
+      get parse() {
+        return this.llmResponseParser;
+      }
+      get parseStream() {
+        return this.llmStreamParser;
+      }
+      async AnalyzeSdkDiff(diff, language, previous_version, prior_changelog, spec_commit_message, __baml_options__) {
+        try {
+          const __options__ = { ...this.bamlOptions, ...__baml_options__ || {} };
+          const __signal__ = __options__.signal;
+          if (__signal__?.aborted) {
+            throw new import_baml4.BamlAbortError("Operation was aborted", __signal__.reason);
+          }
+          if (__options__.onTick) {
+            const __stream__ = this.stream.AnalyzeSdkDiff(diff, language, previous_version, prior_changelog, spec_commit_message, __baml_options__);
+            return await __stream__.getFinalResponse();
+          }
+          const __collector__ = __options__.collector ? Array.isArray(__options__.collector) ? __options__.collector : [__options__.collector] : [];
+          const __rawEnv__ = __baml_options__?.env ? { ...process.env, ...__baml_options__.env } : { ...process.env };
+          const __env__ = Object.fromEntries(Object.entries(__rawEnv__).filter(([_2, value]) => value !== void 0));
+          let __clientRegistry__ = __options__.clientRegistry;
+          if (__options__.client) {
+            __clientRegistry__ = __clientRegistry__ || new import_baml4.ClientRegistry();
+            __clientRegistry__.setPrimary(__options__.client);
+          }
+          const __raw__ = await this.runtime.callFunction("AnalyzeSdkDiff", {
+            "diff": diff,
+            "language": language,
+            "previous_version": previous_version,
+            "prior_changelog": prior_changelog,
+            "spec_commit_message": spec_commit_message
+          }, this.ctxManager.cloneContext(), __options__.tb?.__tb(), __clientRegistry__, __collector__, __options__.tags || {}, __env__, __signal__, __options__.watchers);
+          return __raw__.parsed(false);
+        } catch (error) {
+          throw (0, import_baml4.toBamlError)(error);
         }
-        if (stat2.isDirectory() && isDirectory) {
-          log(`[OK] path represents a directory`);
-          return true;
+      }
+      async ConsolidateChangelog(raw_entries, version_bump, language, previous_version, new_version, __baml_options__) {
+        try {
+          const __options__ = { ...this.bamlOptions, ...__baml_options__ || {} };
+          const __signal__ = __options__.signal;
+          if (__signal__?.aborted) {
+            throw new import_baml4.BamlAbortError("Operation was aborted", __signal__.reason);
+          }
+          if (__options__.onTick) {
+            const __stream__ = this.stream.ConsolidateChangelog(raw_entries, version_bump, language, previous_version, new_version, __baml_options__);
+            return await __stream__.getFinalResponse();
+          }
+          const __collector__ = __options__.collector ? Array.isArray(__options__.collector) ? __options__.collector : [__options__.collector] : [];
+          const __rawEnv__ = __baml_options__?.env ? { ...process.env, ...__baml_options__.env } : { ...process.env };
+          const __env__ = Object.fromEntries(Object.entries(__rawEnv__).filter(([_2, value]) => value !== void 0));
+          let __clientRegistry__ = __options__.clientRegistry;
+          if (__options__.client) {
+            __clientRegistry__ = __clientRegistry__ || new import_baml4.ClientRegistry();
+            __clientRegistry__.setPrimary(__options__.client);
+          }
+          const __raw__ = await this.runtime.callFunction("ConsolidateChangelog", {
+            "raw_entries": raw_entries,
+            "version_bump": version_bump,
+            "language": language,
+            "previous_version": previous_version,
+            "new_version": new_version
+          }, this.ctxManager.cloneContext(), __options__.tb?.__tb(), __clientRegistry__, __collector__, __options__.tags || {}, __env__, __signal__, __options__.watchers);
+          return __raw__.parsed(false);
+        } catch (error) {
+          throw (0, import_baml4.toBamlError)(error);
         }
-        log(`[FAIL] path represents something other than a file or directory`);
-        return false;
-      } catch (e) {
-        if (e.code === "ENOENT") {
-          log(`[FAIL] path is not accessible: %o`, e);
-          return false;
+      }
+    };
+    BamlStreamClient = class {
+      runtime;
+      ctxManager;
+      bamlOptions;
+      constructor(runtime, ctxManager, bamlOptions) {
+        this.runtime = runtime;
+        this.ctxManager = ctxManager;
+        this.bamlOptions = bamlOptions || {};
+      }
+      AnalyzeSdkDiff(diff, language, previous_version, prior_changelog, spec_commit_message, __baml_options__) {
+        try {
+          const __options__ = { ...this.bamlOptions, ...__baml_options__ || {} };
+          const __signal__ = __options__.signal;
+          if (__signal__?.aborted) {
+            throw new import_baml4.BamlAbortError("Operation was aborted", __signal__.reason);
+          }
+          let __collector__ = __options__.collector ? Array.isArray(__options__.collector) ? __options__.collector : [__options__.collector] : [];
+          let __onTickWrapper__;
+          if (__options__.onTick) {
+            const __tickCollector__ = new import_baml4.Collector("on-tick-collector");
+            __collector__ = [...__collector__, __tickCollector__];
+            __onTickWrapper__ = () => {
+              const __log__ = __tickCollector__.last;
+              if (__log__) {
+                try {
+                  __options__.onTick("Unknown", __log__);
+                } catch (error) {
+                  console.error("Error in onTick callback for AnalyzeSdkDiff", error);
+                }
+              }
+            };
+          }
+          const __rawEnv__ = __baml_options__?.env ? { ...process.env, ...__baml_options__.env } : { ...process.env };
+          const __env__ = Object.fromEntries(Object.entries(__rawEnv__).filter(([_2, value]) => value !== void 0));
+          let __clientRegistry__ = __options__.clientRegistry;
+          if (__options__.client) {
+            __clientRegistry__ = __clientRegistry__ || new import_baml4.ClientRegistry();
+            __clientRegistry__.setPrimary(__options__.client);
+          }
+          const __raw__ = this.runtime.streamFunction("AnalyzeSdkDiff", {
+            "diff": diff,
+            "language": language,
+            "previous_version": previous_version,
+            "prior_changelog": prior_changelog,
+            "spec_commit_message": spec_commit_message
+          }, void 0, this.ctxManager.cloneContext(), __options__.tb?.__tb(), __clientRegistry__, __collector__, __options__.tags || {}, __env__, __signal__, __onTickWrapper__);
+          return new import_baml4.BamlStream(__raw__, (a) => a, (a) => a, this.ctxManager.cloneContext(), __options__.signal);
+        } catch (error) {
+          throw (0, import_baml4.toBamlError)(error);
         }
-        log(`[FATAL] %o`, e);
-        throw e;
       }
-    }
-    function exists2(path3, type = exports2.READABLE) {
-      return check(path3, (type & exports2.FILE) > 0, (type & exports2.FOLDER) > 0);
-    }
-    exports2.exists = exists2;
-    exports2.FILE = 1;
-    exports2.FOLDER = 2;
-    exports2.READABLE = exports2.FILE + exports2.FOLDER;
+      ConsolidateChangelog(raw_entries, version_bump, language, previous_version, new_version, __baml_options__) {
+        try {
+          const __options__ = { ...this.bamlOptions, ...__baml_options__ || {} };
+          const __signal__ = __options__.signal;
+          if (__signal__?.aborted) {
+            throw new import_baml4.BamlAbortError("Operation was aborted", __signal__.reason);
+          }
+          let __collector__ = __options__.collector ? Array.isArray(__options__.collector) ? __options__.collector : [__options__.collector] : [];
+          let __onTickWrapper__;
+          if (__options__.onTick) {
+            const __tickCollector__ = new import_baml4.Collector("on-tick-collector");
+            __collector__ = [...__collector__, __tickCollector__];
+            __onTickWrapper__ = () => {
+              const __log__ = __tickCollector__.last;
+              if (__log__) {
+                try {
+                  __options__.onTick("Unknown", __log__);
+                } catch (error) {
+                  console.error("Error in onTick callback for ConsolidateChangelog", error);
+                }
+              }
+            };
+          }
+          const __rawEnv__ = __baml_options__?.env ? { ...process.env, ...__baml_options__.env } : { ...process.env };
+          const __env__ = Object.fromEntries(Object.entries(__rawEnv__).filter(([_2, value]) => value !== void 0));
+          let __clientRegistry__ = __options__.clientRegistry;
+          if (__options__.client) {
+            __clientRegistry__ = __clientRegistry__ || new import_baml4.ClientRegistry();
+            __clientRegistry__.setPrimary(__options__.client);
+          }
+          const __raw__ = this.runtime.streamFunction("ConsolidateChangelog", {
+            "raw_entries": raw_entries,
+            "version_bump": version_bump,
+            "language": language,
+            "previous_version": previous_version,
+            "new_version": new_version
+          }, void 0, this.ctxManager.cloneContext(), __options__.tb?.__tb(), __clientRegistry__, __collector__, __options__.tags || {}, __env__, __signal__, __onTickWrapper__);
+          return new import_baml4.BamlStream(__raw__, (a) => a, (a) => a, this.ctxManager.cloneContext(), __options__.signal);
+        } catch (error) {
+          throw (0, import_baml4.toBamlError)(error);
+        }
+      }
+    };
+    b2 = new BamlAsyncClient(DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_RUNTIME, DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_CTX);
   }
 });
 
-// ../../node_modules/.pnpm/@kwsites+file-exists@1.1.1/node_modules/@kwsites/file-exists/dist/index.js
-var require_dist = __commonJS({
-  "../../node_modules/.pnpm/@kwsites+file-exists@1.1.1/node_modules/@kwsites/file-exists/dist/index.js"(exports2) {
+// ../cli/ai/lib/baml_client/types.js
+function all_succeeded(checks) {
+  return get_checks(checks).every((check) => check.status === "succeeded");
+}
+function get_checks(checks) {
+  return Object.values(checks);
+}
+var VersionBump2;
+var init_types = __esm({
+  "../cli/ai/lib/baml_client/types.js"() {
     "use strict";
-    function __export3(m) {
-      for (var p in m) if (!exports2.hasOwnProperty(p)) exports2[p] = m[p];
-    }
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    __export3(require_src2());
+    (function(VersionBump3) {
+      VersionBump3["MAJOR"] = "MAJOR";
+      VersionBump3["MINOR"] = "MINOR";
+      VersionBump3["PATCH"] = "PATCH";
+      VersionBump3["NO_CHANGE"] = "NO_CHANGE";
+    })(VersionBump2 || (VersionBump2 = {}));
   }
 });
 
-// ../../node_modules/.pnpm/@kwsites+promise-deferred@1.1.1/node_modules/@kwsites/promise-deferred/dist/index.js
-var require_dist2 = __commonJS({
-  "../../node_modules/.pnpm/@kwsites+promise-deferred@1.1.1/node_modules/@kwsites/promise-deferred/dist/index.js"(exports2) {
+// ../cli/ai/lib/baml_client/tracing.js
+var traceAsync, traceSync, setTags, flush, onLogEvent;
+var init_tracing = __esm({
+  "../cli/ai/lib/baml_client/tracing.js"() {
     "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.createDeferred = exports2.deferred = void 0;
-    function deferred2() {
-      let done;
-      let fail;
-      let status2 = "pending";
-      const promise = new Promise((_done, _fail) => {
-        done = _done;
-        fail = _fail;
-      });
-      return {
-        promise,
-        done(result) {
-          if (status2 === "pending") {
-            status2 = "resolved";
-            done(result);
-          }
-        },
-        fail(error) {
-          if (status2 === "pending") {
-            status2 = "rejected";
-            fail(error);
-          }
-        },
-        get fulfilled() {
-          return status2 !== "pending";
-        },
-        get status() {
-          return status2;
-        }
-      };
-    }
-    exports2.deferred = deferred2;
-    exports2.createDeferred = deferred2;
-    exports2.default = deferred2;
+    init_globals();
+    traceAsync = DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_CTX.traceFnAsync.bind(DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_CTX);
+    traceSync = DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_CTX.traceFnSync.bind(DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_CTX);
+    setTags = DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_CTX.upsertTags.bind(DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_CTX);
+    flush = () => {
+      DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_CTX.flush.bind(DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_CTX)();
+    };
+    onLogEvent = (callback) => DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_CTX.onLogEvent(callback);
+  }
+});
+
+// ../cli/ai/lib/baml_client/watchers.js
+var watchers_exports = {};
+var init_watchers = __esm({
+  "../cli/ai/lib/baml_client/watchers.js"() {
+    "use strict";
+  }
+});
+
+// ../cli/ai/lib/baml_client/index.js
+var import_baml5, import_baml6, version;
+var init_baml_client = __esm({
+  "../cli/ai/lib/baml_client/index.js"() {
+    "use strict";
+    import_baml5 = require("@boundaryml/baml");
+    init_async_client();
+    init_types();
+    init_tracing();
+    init_watchers();
+    init_globals();
+    import_baml6 = require("@boundaryml/baml");
+    version = "0.219.0";
+    (0, import_baml5.ThrowIfVersionMismatch)(version);
+  }
+});
+
+// ../cli/ai/lib/configureBamlClient.js
+function configureBamlClient(config) {
+  const registry = new import_baml7.ClientRegistry();
+  const clientOptions = {
+    model: config.model
+  };
+  registry.addLlmClient("ConfiguredClient", config.provider, clientOptions);
+  registry.setPrimary("ConfiguredClient");
+  if ((0, import_baml7.getLogLevel)() !== "ERROR") {
+    (0, import_baml7.setLogLevel)("ERROR");
+  }
+  return registry;
+}
+var import_baml7;
+var init_configureBamlClient = __esm({
+  "../cli/ai/lib/configureBamlClient.js"() {
+    "use strict";
+    import_baml7 = require("@boundaryml/baml");
+  }
+});
+
+// ../cli/ai/lib/index.js
+var lib_exports = {};
+__export(lib_exports, {
+  BamlClientFinishReasonError: () => import_baml6.BamlClientFinishReasonError,
+  BamlClientHttpError: () => import_baml6.BamlClientHttpError,
+  BamlValidationError: () => import_baml6.BamlValidationError,
+  VersionBump: () => VersionBump2,
+  all_succeeded: () => all_succeeded,
+  b: () => b2,
+  configureBamlClient: () => configureBamlClient,
+  flush: () => flush,
+  get_checks: () => get_checks,
+  onLogEvent: () => onLogEvent,
+  resetBamlEnvVars: () => resetBamlEnvVars,
+  setTags: () => setTags,
+  traceAsync: () => traceAsync,
+  traceSync: () => traceSync,
+  version: () => version,
+  watchers: () => watchers_exports
+});
+var init_lib = __esm({
+  "../cli/ai/lib/index.js"() {
+    "use strict";
+    init_baml_client();
+    init_configureBamlClient();
   }
 });
 
@@ -1300,7 +3786,7 @@ var __defProp2 = Object.defineProperty;
 var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames2 = Object.getOwnPropertyNames;
 var __hasOwnProp2 = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
+var __esm2 = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames2(fn)[0]])(fn = 0)), res;
 };
 var __commonJS2 = (cb, mod) => function __require() {
@@ -1320,7 +3806,7 @@ var __copyProps2 = (to, from, except, desc) => {
 };
 var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
 var GitError;
-var init_git_error = __esm({
+var init_git_error = __esm2({
   "src/lib/errors/git-error.ts"() {
     "use strict";
     GitError = class extends Error {
@@ -1333,7 +3819,7 @@ var init_git_error = __esm({
   }
 });
 var GitResponseError;
-var init_git_response_error = __esm({
+var init_git_response_error = __esm2({
   "src/lib/errors/git-response-error.ts"() {
     "use strict";
     init_git_error();
@@ -1346,7 +3832,7 @@ var init_git_response_error = __esm({
   }
 });
 var TaskConfigurationError;
-var init_task_configuration_error = __esm({
+var init_task_configuration_error = __esm2({
   "src/lib/errors/task-configuration-error.ts"() {
     "use strict";
     init_git_error();
@@ -1477,7 +3963,7 @@ function orVoid(input) {
 var NULL;
 var NOOP;
 var objectToString;
-var init_util = __esm({
+var init_util = __esm2({
   "src/lib/utils/util.ts"() {
     "use strict";
     init_argument_filters();
@@ -1508,7 +3994,7 @@ var filterNumber;
 var filterString;
 var filterStringOrStringArray;
 var filterHasLength;
-var init_argument_filters = __esm({
+var init_argument_filters = __esm2({
   "src/lib/utils/argument-filters.ts"() {
     "use strict";
     init_util();
@@ -1533,7 +4019,7 @@ var init_argument_filters = __esm({
   }
 });
 var ExitCodes;
-var init_exit_codes = __esm({
+var init_exit_codes = __esm2({
   "src/lib/utils/exit-codes.ts"() {
     "use strict";
     ExitCodes = /* @__PURE__ */ ((ExitCodes2) => {
@@ -1546,7 +4032,7 @@ var init_exit_codes = __esm({
   }
 });
 var GitOutputStreams;
-var init_git_output_streams = __esm({
+var init_git_output_streams = __esm2({
   "src/lib/utils/git-output-streams.ts"() {
     "use strict";
     GitOutputStreams = class _GitOutputStreams {
@@ -1565,7 +4051,7 @@ function useMatchesDefault() {
 }
 var LineParser;
 var RemoteLineParser;
-var init_line_parser = __esm({
+var init_line_parser = __esm2({
   "src/lib/utils/line-parser.ts"() {
     "use strict";
     LineParser = class {
@@ -1624,7 +4110,7 @@ function createInstanceConfig(...options) {
   return config;
 }
 var defaultOptions;
-var init_simple_git_options = __esm({
+var init_simple_git_options = __esm2({
   "src/lib/utils/simple-git-options.ts"() {
     "use strict";
     defaultOptions = {
@@ -1682,7 +4168,7 @@ function trailingFunctionArgument(args, includeNoop = true) {
   const callback = asFunction(last(args));
   return includeNoop || isUserFunction(callback) ? callback : void 0;
 }
-var init_task_options = __esm({
+var init_task_options = __esm2({
   "src/lib/utils/task-options.ts"() {
     "use strict";
     init_argument_filters();
@@ -1706,7 +4192,7 @@ function parseStringResponse(result, parsers12, texts, trim = true) {
   });
   return result;
 }
-var init_task_parser = __esm({
+var init_task_parser = __esm2({
   "src/lib/utils/task-parser.ts"() {
     "use strict";
     init_util();
@@ -1758,7 +4244,7 @@ __export2(utils_exports, {
   trailingFunctionArgument: () => trailingFunctionArgument,
   trailingOptionsArgument: () => trailingOptionsArgument
 });
-var init_utils = __esm({
+var init_utils = __esm2({
   "src/lib/utils/index.ts"() {
     "use strict";
     init_argument_filters();
@@ -1819,7 +4305,7 @@ function isNotRepoMessage(error) {
 var CheckRepoActions;
 var onError;
 var parser;
-var init_check_is_repo = __esm({
+var init_check_is_repo = __esm2({
   "src/lib/tasks/check-is-repo.ts"() {
     "use strict";
     init_utils();
@@ -1854,7 +4340,7 @@ var CleanResponse;
 var removalRegexp;
 var dryRunRemovalRegexp;
 var isFolderRegexp;
-var init_CleanSummary = __esm({
+var init_CleanSummary = __esm2({
   "src/lib/responses/CleanSummary.ts"() {
     "use strict";
     init_utils();
@@ -1922,7 +4408,7 @@ function isEmptyTask(task) {
   return task.format === "empty" || !task.commands.length;
 }
 var EMPTY_COMMANDS;
-var init_task = __esm({
+var init_task = __esm2({
   "src/lib/tasks/task.ts"() {
     "use strict";
     init_task_configuration_error();
@@ -2001,7 +4487,7 @@ var CONFIG_ERROR_MODE_REQUIRED;
 var CONFIG_ERROR_UNKNOWN_OPTION;
 var CleanOptions;
 var CleanOptionValues;
-var init_clean = __esm({
+var init_clean = __esm2({
   "src/lib/tasks/clean.ts"() {
     "use strict";
     init_CleanSummary();
@@ -2073,7 +4559,7 @@ function* configParser(text, requestedKey = null) {
   }
 }
 var ConfigList;
-var init_ConfigList = __esm({
+var init_ConfigList = __esm2({
   "src/lib/responses/ConfigList.ts"() {
     "use strict";
     init_utils();
@@ -2190,7 +4676,7 @@ function config_default() {
   };
 }
 var GitConfigScope;
-var init_config = __esm({
+var init_config = __esm2({
   "src/lib/tasks/config.ts"() {
     "use strict";
     init_ConfigList();
@@ -2209,7 +4695,7 @@ function isDiffNameStatus(input) {
 }
 var DiffNameStatus;
 var diffNameStatus;
-var init_diff_name_status = __esm({
+var init_diff_name_status = __esm2({
   "src/lib/tasks/diff-name-status.ts"() {
     "use strict";
     DiffNameStatus = /* @__PURE__ */ ((DiffNameStatus2) => {
@@ -2281,7 +4767,7 @@ var disallowedOptions;
 var Query;
 var _a;
 var GrepQuery;
-var init_grep = __esm({
+var init_grep = __esm2({
   "src/lib/tasks/grep.ts"() {
     "use strict";
     init_utils();
@@ -2338,7 +4824,7 @@ function isValidResetMode(mode) {
 }
 var ResetMode;
 var validResetModes;
-var init_reset = __esm({
+var init_reset = __esm2({
   "src/lib/tasks/reset.ts"() {
     "use strict";
     init_utils();
@@ -2405,7 +4891,7 @@ function createLogger(label, verbose, initialStep, infoDebugger = createLog()) {
     });
   }
 }
-var init_git_logger = __esm({
+var init_git_logger = __esm2({
   "src/lib/git-logger.ts"() {
     "use strict";
     init_utils();
@@ -2419,7 +4905,7 @@ var init_git_logger = __esm({
   }
 });
 var TasksPendingQueue;
-var init_tasks_pending_queue = __esm({
+var init_tasks_pending_queue = __esm2({
   "src/lib/runners/tasks-pending-queue.ts"() {
     "use strict";
     init_git_error();
@@ -2509,7 +4995,7 @@ function onDataReceived(target, name, logger, output) {
   };
 }
 var GitExecutorChain;
-var init_git_executor_chain = __esm({
+var init_git_executor_chain = __esm2({
   "src/lib/runners/git-executor-chain.ts"() {
     "use strict";
     init_git_error();
@@ -2714,7 +5200,7 @@ __export2(git_executor_exports, {
   GitExecutor: () => GitExecutor
 });
 var GitExecutor;
-var init_git_executor = __esm({
+var init_git_executor = __esm2({
   "src/lib/runners/git-executor.ts"() {
     "use strict";
     init_git_executor_chain();
@@ -2771,7 +5257,7 @@ function addDeprecationNoticeToError(err) {
     return all;
   }
 }
-var init_task_callback = __esm({
+var init_task_callback = __esm2({
   "src/lib/task-callback.ts"() {
     "use strict";
     init_git_response_error();
@@ -2786,7 +5272,7 @@ function changeWorkingDirectoryTask(directory, root) {
     return (root || instance).cwd = directory;
   });
 }
-var init_change_working_directory = __esm({
+var init_change_working_directory = __esm2({
   "src/lib/tasks/change-working-directory.ts"() {
     "use strict";
     init_utils();
@@ -2822,7 +5308,7 @@ function checkout_default() {
     }
   };
 }
-var init_checkout = __esm({
+var init_checkout = __esm2({
   "src/lib/tasks/checkout.ts"() {
     "use strict";
     init_utils();
@@ -2855,7 +5341,7 @@ function count_objects_default() {
   };
 }
 var parser2;
-var init_count_objects = __esm({
+var init_count_objects = __esm2({
   "src/lib/tasks/count-objects.ts"() {
     "use strict";
     init_utils();
@@ -2885,7 +5371,7 @@ function parseCommitResult(stdOut) {
   return parseStringResponse(result, parsers, stdOut);
 }
 var parsers;
-var init_parse_commit = __esm({
+var init_parse_commit = __esm2({
   "src/lib/parsers/parse-commit.ts"() {
     "use strict";
     init_utils();
@@ -2965,7 +5451,7 @@ function commit_default() {
     );
   }
 }
-var init_commit = __esm({
+var init_commit = __esm2({
   "src/lib/tasks/commit.ts"() {
     "use strict";
     init_parse_commit();
@@ -2983,7 +5469,7 @@ function first_commit_default() {
     }
   };
 }
-var init_first_commit = __esm({
+var init_first_commit = __esm2({
   "src/lib/tasks/first-commit.ts"() {
     "use strict";
     init_utils();
@@ -2997,7 +5483,7 @@ function hashObjectTask(filePath, write) {
   }
   return straightThroughStringTask(commands, true);
 }
-var init_hash_object = __esm({
+var init_hash_object = __esm2({
   "src/lib/tasks/hash-object.ts"() {
     "use strict";
     init_task();
@@ -3026,7 +5512,7 @@ function parseInit(bare, path3, text) {
 var InitSummary;
 var initResponseRegex;
 var reInitResponseRegex;
-var init_InitSummary = __esm({
+var init_InitSummary = __esm2({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
@@ -3058,7 +5544,7 @@ function initTask(bare = false, path3, customArgs) {
   };
 }
 var bareCommand;
-var init_init = __esm({
+var init_init = __esm2({
   "src/lib/tasks/init.ts"() {
     "use strict";
     init_InitSummary();
@@ -3078,14 +5564,14 @@ function isLogFormat(customArg) {
   return logFormatRegex.test(customArg);
 }
 var logFormatRegex;
-var init_log_format = __esm({
+var init_log_format = __esm2({
   "src/lib/args/log-format.ts"() {
     "use strict";
     logFormatRegex = /^--(stat|numstat|name-only|name-status)(=|$)/;
   }
 });
 var DiffSummary;
-var init_DiffSummary = __esm({
+var init_DiffSummary = __esm2({
   "src/lib/responses/DiffSummary.ts"() {
     "use strict";
     DiffSummary = class {
@@ -3107,7 +5593,7 @@ var numStatParser;
 var nameOnlyParser;
 var nameStatusParser;
 var diffSummaryParsers;
-var init_parse_diff_summary = __esm({
+var init_parse_diff_summary = __esm2({
   "src/lib/parsers/parse-diff-summary.ts"() {
     "use strict";
     init_log_format();
@@ -3266,7 +5752,7 @@ var START_BOUNDARY;
 var COMMIT_BOUNDARY;
 var SPLITTER;
 var defaultFieldNames;
-var init_parse_list_log_summary = __esm({
+var init_parse_list_log_summary = __esm2({
   "src/lib/parsers/parse-list-log-summary.ts"() {
     "use strict";
     init_utils();
@@ -3310,7 +5796,7 @@ function validateLogFormatConfig(customArgs) {
     );
   }
 }
-var init_diff = __esm({
+var init_diff = __esm2({
   "src/lib/tasks/diff.ts"() {
     "use strict";
     init_log_format();
@@ -3400,7 +5886,7 @@ function log_default() {
   }
 }
 var excludeOptions;
-var init_log = __esm({
+var init_log = __esm2({
   "src/lib/tasks/log.ts"() {
     "use strict";
     init_log_format();
@@ -3428,7 +5914,7 @@ var init_log = __esm({
 });
 var MergeSummaryConflict;
 var MergeSummaryDetail;
-var init_MergeSummary = __esm({
+var init_MergeSummary = __esm2({
   "src/lib/responses/MergeSummary.ts"() {
     "use strict";
     MergeSummaryConflict = class {
@@ -3464,7 +5950,7 @@ var init_MergeSummary = __esm({
 });
 var PullSummary;
 var PullFailedSummary;
-var init_PullSummary = __esm({
+var init_PullSummary = __esm2({
   "src/lib/responses/PullSummary.ts"() {
     "use strict";
     PullSummary = class {
@@ -3522,7 +6008,7 @@ function asObjectCount(source) {
   };
 }
 var remoteMessagesObjectParsers;
-var init_parse_remote_objects = __esm({
+var init_parse_remote_objects = __esm2({
   "src/lib/parsers/parse-remote-objects.ts"() {
     "use strict";
     init_utils();
@@ -3560,7 +6046,7 @@ function parseRemoteMessages(_stdOut, stdErr) {
 }
 var parsers2;
 var RemoteMessageSummary;
-var init_parse_remote_messages = __esm({
+var init_parse_remote_messages = __esm2({
   "src/lib/parsers/parse-remote-messages.ts"() {
     "use strict";
     init_utils();
@@ -3606,7 +6092,7 @@ var parsers3;
 var errorParsers;
 var parsePullDetail;
 var parsePullResult;
-var init_parse_pull = __esm({
+var init_parse_pull = __esm2({
   "src/lib/parsers/parse-pull.ts"() {
     "use strict";
     init_PullSummary();
@@ -3667,7 +6153,7 @@ var init_parse_pull = __esm({
 var parsers4;
 var parseMergeResult;
 var parseMergeDetail;
-var init_parse_merge = __esm({
+var init_parse_merge = __esm2({
   "src/lib/parsers/parse-merge.ts"() {
     "use strict";
     init_MergeSummary();
@@ -3717,7 +6203,7 @@ function mergeTask(customArgs) {
     }
   };
 }
-var init_merge = __esm({
+var init_merge = __esm2({
   "src/lib/tasks/merge.ts"() {
     "use strict";
     init_git_response_error();
@@ -3742,7 +6228,7 @@ function pushResultPushedItem(local, remote, status2) {
 var parsers5;
 var parsePushResult;
 var parsePushDetail;
-var init_parse_push = __esm({
+var init_parse_push = __esm2({
   "src/lib/parsers/parse-push.ts"() {
     "use strict";
     init_utils();
@@ -3826,7 +6312,7 @@ function pushTask(ref = {}, customArgs) {
     parser: parsePushResult
   };
 }
-var init_push = __esm({
+var init_push = __esm2({
   "src/lib/tasks/push.ts"() {
     "use strict";
     init_parse_push();
@@ -3854,7 +6340,7 @@ function show_default() {
     }
   };
 }
-var init_show = __esm({
+var init_show = __esm2({
   "src/lib/tasks/show.ts"() {
     "use strict";
     init_utils();
@@ -3863,7 +6349,7 @@ var init_show = __esm({
 });
 var fromPathRegex;
 var FileStatusSummary;
-var init_FileStatusSummary = __esm({
+var init_FileStatusSummary = __esm2({
   "src/lib/responses/FileStatusSummary.ts"() {
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
@@ -3918,7 +6404,7 @@ function splitLine(result, lineStr) {
 var StatusSummary;
 var parsers6;
 var parseStatusSummary;
-var init_StatusSummary = __esm({
+var init_StatusSummary = __esm2({
   "src/lib/responses/StatusSummary.ts"() {
     "use strict";
     init_utils();
@@ -4075,7 +6561,7 @@ function statusTask(customArgs) {
   };
 }
 var ignoredOptions;
-var init_status = __esm({
+var init_status = __esm2({
   "src/lib/tasks/status.ts"() {
     "use strict";
     init_StatusSummary();
@@ -4129,7 +6615,7 @@ function versionParser(stdOut) {
 }
 var NOT_INSTALLED;
 var parsers7;
-var init_version = __esm({
+var init_version = __esm2({
   "src/lib/tasks/version.ts"() {
     "use strict";
     init_utils();
@@ -4177,7 +6663,7 @@ function clone_default() {
 }
 var cloneTask;
 var cloneMirrorTask;
-var init_clone = __esm({
+var init_clone = __esm2({
   "src/lib/tasks/clone.ts"() {
     "use strict";
     init_task();
@@ -4199,7 +6685,7 @@ __export2(simple_git_api_exports, {
   SimpleGitApi: () => SimpleGitApi
 });
 var SimpleGitApi;
-var init_simple_git_api = __esm({
+var init_simple_git_api = __esm2({
   "src/lib/simple-git-api.ts"() {
     "use strict";
     init_task_callback();
@@ -4341,7 +6827,7 @@ __export2(scheduler_exports, {
 });
 var createScheduledTask;
 var Scheduler;
-var init_scheduler = __esm({
+var init_scheduler = __esm2({
   "src/lib/runners/scheduler.ts"() {
     "use strict";
     init_utils();
@@ -4400,7 +6886,7 @@ __export2(apply_patch_exports, {
 function applyPatchTask(patches, customArgs) {
   return straightThroughStringTask(["apply", ...customArgs, ...patches]);
 }
-var init_apply_patch = __esm({
+var init_apply_patch = __esm2({
   "src/lib/tasks/apply-patch.ts"() {
     "use strict";
     init_task();
@@ -4421,7 +6907,7 @@ function branchDeletionFailure(branch) {
   };
 }
 var BranchDeletionBatch;
-var init_BranchDeleteSummary = __esm({
+var init_BranchDeleteSummary = __esm2({
   "src/lib/responses/BranchDeleteSummary.ts"() {
     "use strict";
     BranchDeletionBatch = class {
@@ -4443,7 +6929,7 @@ var deleteSuccessRegex;
 var deleteErrorRegex;
 var parsers8;
 var parseBranchDeletions;
-var init_parse_branch_delete = __esm({
+var init_parse_branch_delete = __esm2({
   "src/lib/parsers/parse-branch-delete.ts"() {
     "use strict";
     init_BranchDeleteSummary();
@@ -4469,7 +6955,7 @@ var init_parse_branch_delete = __esm({
   }
 });
 var BranchSummaryResult;
-var init_BranchSummary = __esm({
+var init_BranchSummary = __esm2({
   "src/lib/responses/BranchSummary.ts"() {
     "use strict";
     BranchSummaryResult = class {
@@ -4508,7 +6994,7 @@ function parseBranchSummary(stdOut, currentOnly = false) {
 }
 var parsers9;
 var currentBranchParser;
-var init_parse_branch = __esm({
+var init_parse_branch = __esm2({
   "src/lib/parsers/parse-branch.ts"() {
     "use strict";
     init_BranchSummary();
@@ -4608,7 +7094,7 @@ function deleteBranchTask(branch, forceDelete = false) {
   };
   return task;
 }
-var init_branch = __esm({
+var init_branch = __esm2({
   "src/lib/tasks/branch.ts"() {
     "use strict";
     init_git_response_error();
@@ -4622,7 +7108,7 @@ function toPath(input) {
   return path3 && (0, import_node_path.normalize)(path3);
 }
 var parseCheckIgnore;
-var init_CheckIgnore = __esm({
+var init_CheckIgnore = __esm2({
   "src/lib/responses/CheckIgnore.ts"() {
     "use strict";
     parseCheckIgnore = (text) => {
@@ -4641,7 +7127,7 @@ function checkIgnoreTask(paths) {
     parser: parseCheckIgnore
   };
 }
-var init_check_ignore = __esm({
+var init_check_ignore = __esm2({
   "src/lib/tasks/check-ignore.ts"() {
     "use strict";
     init_CheckIgnore();
@@ -4659,7 +7145,7 @@ function parseFetchResult(stdOut, stdErr) {
   return parseStringResponse(result, parsers10, [stdOut, stdErr]);
 }
 var parsers10;
-var init_parse_fetch = __esm({
+var init_parse_fetch = __esm2({
   "src/lib/parsers/parse-fetch.ts"() {
     "use strict";
     init_utils();
@@ -4720,7 +7206,7 @@ function fetchTask(remote, branch, customArgs) {
     parser: parseFetchResult
   };
 }
-var init_fetch = __esm({
+var init_fetch = __esm2({
   "src/lib/tasks/fetch.ts"() {
     "use strict";
     init_parse_fetch();
@@ -4731,7 +7217,7 @@ function parseMoveResult(stdOut) {
   return parseStringResponse({ moves: [] }, parsers11, stdOut);
 }
 var parsers11;
-var init_parse_move = __esm({
+var init_parse_move = __esm2({
   "src/lib/parsers/parse-move.ts"() {
     "use strict";
     init_utils();
@@ -4753,7 +7239,7 @@ function moveTask(from, to) {
     parser: parseMoveResult
   };
 }
-var init_move = __esm({
+var init_move = __esm2({
   "src/lib/tasks/move.ts"() {
     "use strict";
     init_parse_move();
@@ -4787,7 +7273,7 @@ function pullTask(remote, branch, customArgs) {
     }
   };
 }
-var init_pull = __esm({
+var init_pull = __esm2({
   "src/lib/tasks/pull.ts"() {
     "use strict";
     init_git_response_error();
@@ -4818,7 +7304,7 @@ function parseGetRemotesVerbose(text) {
 function forEach(text, handler) {
   forEachLineWithContent(text, (line) => handler(line.split(/\s+/)));
 }
-var init_GetRemoteSummary = __esm({
+var init_GetRemoteSummary = __esm2({
   "src/lib/responses/GetRemoteSummary.ts"() {
     "use strict";
     init_utils();
@@ -4863,7 +7349,7 @@ function remoteTask(customArgs) {
 function removeRemoteTask(remoteName) {
   return straightThroughStringTask(["remote", "remove", remoteName]);
 }
-var init_remote = __esm({
+var init_remote = __esm2({
   "src/lib/tasks/remote.ts"() {
     "use strict";
     init_GetRemoteSummary();
@@ -4888,7 +7374,7 @@ function stashListTask(opt = {}, customArgs) {
     parser: parser4
   };
 }
-var init_stash_list = __esm({
+var init_stash_list = __esm2({
   "src/lib/tasks/stash-list.ts"() {
     "use strict";
     init_log_format();
@@ -4920,22 +7406,22 @@ function subModuleTask(customArgs) {
 function updateSubModuleTask(customArgs) {
   return subModuleTask(["update", ...customArgs]);
 }
-var init_sub_module = __esm({
+var init_sub_module = __esm2({
   "src/lib/tasks/sub-module.ts"() {
     "use strict";
     init_task();
   }
 });
-function singleSorted(a, b2) {
+function singleSorted(a, b3) {
   const aIsNum = Number.isNaN(a);
-  const bIsNum = Number.isNaN(b2);
+  const bIsNum = Number.isNaN(b3);
   if (aIsNum !== bIsNum) {
     return aIsNum ? 1 : -1;
   }
-  return aIsNum ? sorted(a, b2) : 0;
+  return aIsNum ? sorted(a, b3) : 0;
 }
-function sorted(a, b2) {
-  return a === b2 ? 0 : a > b2 ? 1 : -1;
+function sorted(a, b3) {
+  return a === b3 ? 0 : a > b3 ? 1 : -1;
 }
 function trimmed(input) {
   return input.trim();
@@ -4948,7 +7434,7 @@ function toNumber(input) {
 }
 var TagList;
 var parseTagList;
-var init_TagList = __esm({
+var init_TagList = __esm2({
   "src/lib/responses/TagList.ts"() {
     "use strict";
     TagList = class {
@@ -5014,7 +7500,7 @@ function addAnnotatedTagTask(name, tagMessage) {
     }
   };
 }
-var init_tag = __esm({
+var init_tag = __esm2({
   "src/lib/tasks/tag.ts"() {
     "use strict";
     init_TagList();
@@ -6953,21 +9439,23 @@ function stringifyValidationError(error) {
 }
 
 // src/configuration/sdk/core/schemas/builders/schema-utils/JsonError.ts
-var JsonError = class _JsonError extends Error {
+var JsonError = class extends Error {
   constructor(errors) {
     super(errors.map(stringifyValidationError).join("; "));
     this.errors = errors;
-    Object.setPrototypeOf(this, _JsonError.prototype);
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.name = this.constructor.name;
   }
   errors;
 };
 
 // src/configuration/sdk/core/schemas/builders/schema-utils/ParseError.ts
-var ParseError = class _ParseError extends Error {
+var ParseError = class extends Error {
   constructor(errors) {
     super(errors.map(stringifyValidationError).join("; "));
     this.errors = errors;
-    Object.setPrototypeOf(this, _ParseError.prototype);
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.name = this.constructor.name;
   }
   errors;
 };
@@ -8784,7 +11272,7 @@ var BlockList = class {
   addBlock(block) {
     if (this.hasBlock(block.id)) {
       console.warn(`[readme] Duplicate block with id "${block.id}" detected; overriding with latest content`);
-      this.blocks = this.blocks.filter((b2) => b2.id !== block.id);
+      this.blocks = this.blocks.filter((b3) => b3.id !== block.id);
     }
     this.ids.add(block.id);
     this.blocks.push(block);
@@ -8799,7 +11287,7 @@ var BlockList = class {
   insertBlock(block, precedingBlockId) {
     if (this.hasBlock(block.id)) {
       console.warn(`[readme] Duplicate block with id "${block.id}" detected; overriding with latest content`);
-      this.blocks = this.blocks.filter((b2) => b2.id !== block.id);
+      this.blocks = this.blocks.filter((b3) => b3.id !== block.id);
       this.ids.delete(block.id);
     }
     if (precedingBlockId === void 0) {
@@ -8811,7 +11299,7 @@ var BlockList = class {
     }
     this.ids.add(block.id);
     this.blocks.splice(
-      this.blocks.findIndex((b2) => b2.id === precedingBlockId),
+      this.blocks.findIndex((b3) => b3.id === precedingBlockId),
       0,
       block
     );
@@ -9668,8 +12156,8 @@ function featureIDToTitle(featureID) {
 function pascalCase(s) {
   return (0, import_string2.upperFirst)((0, import_string2.camelCase)(s));
 }
-function getMajorVersion(version) {
-  return version.split(".")[0] ?? "0";
+function getMajorVersion(version2) {
+  return version2.split(".")[0] ?? "0";
 }
 function assertNever(x2) {
   throw new Error(`unexpected value: ${JSON.stringify(x2)}`);
@@ -10073,8 +12561,62 @@ var import_fs3 = require("fs");
 var import_promises3 = require("fs/promises");
 var import_path4 = require("path");
 
+// ../commons/logging-execa/lib/loggingExeca.js
+var import_execa = __toESM(require_execa(), 1);
+function wireSignal(childProcess, signal) {
+  if (!signal) {
+    return;
+  }
+  childProcess.catch(() => {
+  });
+  if (signal.aborted) {
+    childProcess.kill();
+    return;
+  }
+  const onAbort = () => {
+    childProcess.kill();
+  };
+  signal.addEventListener("abort", onAbort, { once: true });
+  void childProcess.finally(() => signal.removeEventListener("abort", onAbort)).catch(() => {
+  });
+}
+function runExeca(logger, executable, args = [], { doNotPipeOutput = false, secrets = [], substitutions = {}, signal, ...execaOptions } = {}) {
+  const allSubstitutions = secrets.reduce((acc, secret) => ({
+    ...acc,
+    [secret]: "<redacted>"
+  }), substitutions);
+  let logLine = [executable, ...args].join(" ");
+  for (const [substitutionKey, substitutionValue] of Object.entries(allSubstitutions)) {
+    logLine = logLine.replaceAll(substitutionKey, substitutionValue);
+  }
+  logger?.debug(`+ ${logLine}`);
+  const childProcess = (0, import_execa.default)(executable, args, execaOptions);
+  wireSignal(childProcess, signal);
+  return childProcess;
+}
+async function loggingExeca(logger, executable, args = [], { doNotPipeOutput = false, secrets = [], substitutions = {}, signal, ...execaOptions } = {}) {
+  const command = runExeca(logger, executable, args, {
+    doNotPipeOutput,
+    secrets,
+    substitutions,
+    signal,
+    ...execaOptions
+  });
+  if (!doNotPipeOutput) {
+    command.stdout?.pipe(process.stdout);
+    command.stderr?.pipe(process.stderr);
+  }
+  const result = await command;
+  if (result.stdout == null) {
+    result.stdout = "";
+  }
+  if (result.stderr == null) {
+    result.stderr = "";
+  }
+  return result;
+}
+
 // src/autoversion/AutoVersioningService.ts
-var import_logging_execa = require("@fern-api/logging-execa");
 var import_fs2 = require("fs");
 var import_promises2 = require("fs/promises");
 var import_path3 = require("path");
@@ -10402,7 +12944,7 @@ var AutoVersioningService = class _AutoVersioningService {
     const ranked = fileSections.map((section) => ({
       text: section.lines.join("\n"),
       priority: this.classifySection(section)
-    })).sort((a, b2) => a.priority - b2.priority);
+    })).sort((a, b3) => a.priority - b3.priority);
     const chunks = [];
     let currentChunkTexts = [];
     let currentChunkBytes = 0;
@@ -10681,7 +13223,7 @@ var AutoVersioningService = class _AutoVersioningService {
    */
   async getLatestVersionFromGitTags(workingDirectory) {
     try {
-      const result = await (0, import_logging_execa.loggingExeca)(this.logger, "git", ["ls-remote", "--tags", "origin"], {
+      const result = await loggingExeca(this.logger, "git", ["ls-remote", "--tags", "origin"], {
         cwd: workingDirectory,
         doNotPipeOutput: true
       });
@@ -10701,7 +13243,7 @@ var AutoVersioningService = class _AutoVersioningService {
           tags.push(match[1]);
         }
       }
-      const validTags = tags.filter((tag) => import_semver.default.valid(tag) != null).sort((a, b2) => import_semver.default.rcompare(a, b2));
+      const validTags = tags.filter((tag) => import_semver.default.valid(tag) != null).sort((a, b3) => import_semver.default.rcompare(a, b3));
       if (validTags.length > 0) {
         const latest = validTags[0];
         this.logger.info(`Found latest version from git tags: ${latest}`);
@@ -10727,7 +13269,7 @@ var AutoVersioningService = class _AutoVersioningService {
     const sedCommand = `s/${this.escapeForSed(mappedMagicVersion)}/${this.escapeForSed(finalVersion)}/g`;
     let isGNUSed = false;
     try {
-      await (0, import_logging_execa.loggingExeca)(this.logger, "sed", ["--version"], {
+      await loggingExeca(this.logger, "sed", ["--version"], {
         doNotPipeOutput: true
       });
       isGNUSed = true;
@@ -10740,7 +13282,7 @@ var AutoVersioningService = class _AutoVersioningService {
     } else {
       command = `find "${workingDirectory}" -type f -not -path "*/.git/*" -exec sed -i '' '${sedCommand}' {} +`;
     }
-    await (0, import_logging_execa.loggingExeca)(this.logger, "bash", ["-c", command], {
+    await loggingExeca(this.logger, "bash", ["-c", command], {
       cwd: workingDirectory,
       doNotPipeOutput: true
     });
@@ -10787,8 +13329,8 @@ var AutoVersioningService = class _AutoVersioningService {
    * Extracts the major version number from a version string.
    * Handles versions with or without 'v' prefix.
    */
-  extractMajorVersion(version) {
-    const match = version.match(/^v?(\d+)\./);
+  extractMajorVersion(version2) {
+    const match = version2.match(/^v?(\d+)\./);
     if (match?.[1] != null) {
       return parseInt(match[1], 10);
     }
@@ -10934,9 +13476,9 @@ var AutoVersioningService = class _AutoVersioningService {
     const prevVersionPattern = /[-].*?([v]?\d+\.\d+\.\d+(?:-[\w.-]+)?(?:\+[\w.-]+)?)/;
     const matcher = lineWithMagicVersion.match(prevVersionPattern);
     if (matcher && matcher[1]) {
-      const version = matcher[1];
-      this.logger.info(`Extracted previous version from diff: ${version}`);
-      return version;
+      const version2 = matcher[1];
+      this.logger.info(`Extracted previous version from diff: ${version2}`);
+      return version2;
     }
     this.logger.warn("Could not extract previous version from diff line: " + lineWithMagicVersion);
     return void 0;
@@ -10967,12 +13509,12 @@ var VERSION_BUMP_RANK = {
   ["PATCH" /* PATCH */]: 1,
   ["NO_CHANGE" /* NO_CHANGE */]: 0
 };
-function maxVersionBump(a, b2) {
-  return (VERSION_BUMP_RANK[a] ?? 0) >= (VERSION_BUMP_RANK[b2] ?? 0) ? a : b2;
+function maxVersionBump(a, b3) {
+  return (VERSION_BUMP_RANK[a] ?? 0) >= (VERSION_BUMP_RANK[b3] ?? 0) ? a : b3;
 }
 var SEMVER_PATTERN = /^(v)?(\d+)\.(\d+)\.(\d+)(?:-([\w.-]+))?(?:\+([\w.-]+))?$/;
-function isValidSemver(version) {
-  return SEMVER_PATTERN.test(version);
+function isValidSemver(version2) {
+  return SEMVER_PATTERN.test(version2);
 }
 function incrementVersion(currentVersion, versionBump) {
   const matcher = currentVersion.match(SEMVER_PATTERN);
@@ -11088,14 +13630,22 @@ var AutoVersionStep = class extends BaseStep {
   async handleNormalFlow(params) {
     const { prepared, service, language, mappedMagicVersion, previousGenerationSha } = params;
     const rawDiff = this.gitDiff(previousGenerationSha, prepared.currentGenerationSha);
-    if (rawDiff.trim().length === 0) {
-      this.logger.info("AutoVersionStep: empty diff between generations; skipping autoversion.");
-      return { executed: true, success: true };
-    }
     const previousVersion = await this.resolvePreviousVersion({ service, rawDiff, mappedMagicVersion });
     if (previousVersion == null) {
       return await this.handleFirstGeneration({ service, language, mappedMagicVersion });
     }
+    if (rawDiff.trim().length === 0) {
+      this.logger.info(
+        `AutoVersionStep: empty diff between generations; rewriting placeholder to ${previousVersion}.`
+      );
+      return await this.finalizeNoChange({
+        service,
+        language,
+        mappedMagicVersion,
+        previousVersion,
+        reason: "no diff between generations"
+      });
+    }
     const cleanedDiff = service.cleanDiffForAI(rawDiff, mappedMagicVersion);
     const rawBytes = Buffer.byteLength(rawDiff, "utf-8");
     const cleanedBytes = Buffer.byteLength(cleanedDiff, "utf-8");
@@ -11103,8 +13653,16 @@ var AutoVersionStep = class extends BaseStep {
       `AutoVersionStep: raw=${formatSizeKB(rawBytes)}KB (${countFilesInDiff(rawDiff)} files), cleaned=${formatSizeKB(cleanedBytes)}KB (${countFilesInDiff(cleanedDiff)} files)`
     );
     if (cleanedDiff.trim().length === 0) {
-      this.logger.info("AutoVersionStep: cleaned diff is empty; no semantic changes.");
-      return { executed: true, success: true };
+      this.logger.info(
+        `AutoVersionStep: cleaned diff is empty; no semantic changes \u2014 rewriting placeholder to ${previousVersion}.`
+      );
+      return await this.finalizeNoChange({
+        service,
+        language,
+        mappedMagicVersion,
+        previousVersion,
+        reason: "no semantic changes"
+      });
     }
     if (cleanedBytes > MAX_RAW_DIFF_BYTES) {
       this.logger.warn(
@@ -11134,13 +13692,14 @@ var AutoVersionStep = class extends BaseStep {
       analysis = { versionBump: "PATCH", message: this.brandMessage("SDK regeneration") };
     }
     if (analysis == null) {
-      this.logger.info("AutoVersionStep: FAI returned NO_CHANGE; skipping autoversion commit.");
-      return {
-        executed: true,
-        success: true,
+      this.logger.info(`AutoVersionStep: FAI returned NO_CHANGE; rewriting placeholder to ${previousVersion}.`);
+      return await this.finalizeNoChange({
+        service,
+        language,
+        mappedMagicVersion,
         previousVersion,
-        versionBump: "NO_CHANGE"
-      };
+        reason: "FAI returned NO_CHANGE"
+      });
     }
     return await this.finalizeWithBump({
       service,
@@ -11150,6 +13709,38 @@ var AutoVersionStep = class extends BaseStep {
       analysis
     });
   }
+  /**
+   * Terminal path for runs that determine no semver bump is needed. The
+   * current working tree still contains `0.0.0-fern-placeholder` from this
+   * run's generator output, so we must rewrite it to `previousVersion`
+   * before exiting — otherwise the SDK ships with the placeholder embedded
+   * in manifests (package.json, pyproject.toml, .fern/metadata.json) and
+   * user-agent strings (e.g. `X-Fern-SDK-Version`). Commits the rewrite as
+   * `[fern-autoversion]` so the replay + github steps see a stable base.
+   */
+  async finalizeNoChange(params) {
+    const { service, language, mappedMagicVersion, previousVersion, reason } = params;
+    if (!isValidSemver(previousVersion)) {
+      const errorMessage = `AutoVersionStep: resolved previousVersion ${JSON.stringify(previousVersion)} is not a valid semver string. Refusing to rewrite placeholder to avoid shell injection.`;
+      this.logger.error(errorMessage);
+      return { executed: true, success: false, errorMessage };
+    }
+    await service.replaceMagicVersion(this.outputDir, mappedMagicVersion, previousVersion);
+    if (language === "go") {
+      await service.addGoMajorVersionSuffix(this.outputDir, previousVersion);
+    }
+    const commitMessage = this.brandMessage(`SDK regeneration (no semver change: ${reason})`);
+    const commitSha = this.commitAutoversion(commitMessage);
+    return {
+      executed: true,
+      success: true,
+      version: previousVersion,
+      previousVersion,
+      versionBump: "NO_CHANGE",
+      commitMessage,
+      commitSha
+    };
+  }
   async finalizeWithBump(params) {
     const { service, language, mappedMagicVersion, previousVersion, analysis } = params;
     const newVersion = incrementVersion(previousVersion, analysis.versionBump);
@@ -11216,8 +13807,8 @@ var AutoVersionStep = class extends BaseStep {
       return void 0;
     }
   }
-  normalizeVersionPrefix(version, mappedMagicVersion) {
-    const stripped = version.startsWith("v") ? version.slice(1) : version;
+  normalizeVersionPrefix(version2, mappedMagicVersion) {
+    const stripped = version2.startsWith("v") ? version2.slice(1) : version2;
     return mappedMagicVersion.startsWith("v") ? `v${stripped}` : stripped;
   }
   gitDiff(from, to) {
@@ -11246,10 +13837,10 @@ ${body}` : `${COMMIT_MARKER} ${subject}`;
     }).trim();
   }
   async prependChangelogEntry(params) {
-    const { version, entry } = params;
+    const { version: version2, entry } = params;
     const changelogPath = (0, import_path4.join)(this.outputDir, "changelog.md");
     const now = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    const header = `## [${version}] - ${now}
+    const header = `## [${version2}] - ${now}
 `;
     const newBlock = `${header}${entry.trim()}
 
@@ -11285,7 +13876,7 @@ ${newBlock}${remainder}`;
     return `${message.trimEnd()}${FERN_TRAILER}`;
   }
   async analyzeSingle(cleanedDiff, language, previousVersion) {
-    const { client, VersionBump: VersionBump2 } = await this.loadBaml();
+    const { client, VersionBump: VersionBump3 } = await this.loadBaml();
     const result = await client.AnalyzeSdkDiff(
       cleanedDiff,
       language,
@@ -11293,7 +13884,7 @@ ${newBlock}${remainder}`;
       this.config.priorChangelog ?? "",
       this.config.specCommitMessage ?? ""
     );
-    if (result.version_bump === VersionBump2.NO_CHANGE) {
+    if (result.version_bump === VersionBump3.NO_CHANGE) {
       return null;
     }
     return {
@@ -11304,8 +13895,8 @@ ${newBlock}${remainder}`;
     };
   }
   async analyzeChunks(chunks, language, previousVersion) {
-    const { client, VersionBump: VersionBump2 } = await this.loadBaml();
-    let bestBump = VersionBump2.NO_CHANGE;
+    const { client, VersionBump: VersionBump3 } = await this.loadBaml();
+    let bestBump = VersionBump3.NO_CHANGE;
     let bestMessage = "";
     let bestVersionBumpReason;
     const changelogEntries = [];
@@ -11321,7 +13912,7 @@ ${newBlock}${remainder}`;
         this.config.priorChangelog ?? "",
         this.config.specCommitMessage ?? ""
       );
-      if (analysis.version_bump === VersionBump2.NO_CHANGE) {
+      if (analysis.version_bump === VersionBump3.NO_CHANGE) {
         continue;
       }
       const prev = bestBump;
@@ -11335,7 +13926,7 @@ ${newBlock}${remainder}`;
         changelogEntries.push(entry);
       }
     }
-    if (bestBump === VersionBump2.NO_CHANGE) {
+    if (bestBump === VersionBump3.NO_CHANGE) {
       return null;
     }
     if (changelogEntries.length <= 1) {
@@ -11382,7 +13973,7 @@ ${newBlock}${remainder}`;
     if (this.config.ai == null) {
       throw new Error("AutoVersionStep: ai config is missing. Set autoVersion.ai to a BAML provider+model pair.");
     }
-    const cliAi = await import("@fern-api/cli-ai");
+    const cliAi = await Promise.resolve().then(() => (init_lib(), lib_exports));
     const registry = cliAi.configureBamlClient(this.config.ai);
     return {
       client: cliAi.b.withOptions({ clientRegistry: registry }),
@@ -12108,8 +14699,10 @@ var GithubStep = class extends BaseStep {
   name = "github";
   async execute(context) {
     const replayResult = context.previousStepResults.replay;
+    const autoVersionResult = context.previousStepResults.autoVersion;
     const skipCommit = this.config.skipCommit ?? this.deriveSkipCommit(replayResult);
     const replayConflictInfo = this.config.replayConflictInfo ?? this.deriveReplayConflictInfo(replayResult);
+    const resolvedPrFields = this.resolvePrFields(autoVersionResult);
     try {
       this.logger.debug("Starting GitHub self-hosted flow in directory: " + this.outputDir);
       const repository = ClonedRepository.createAtPath(this.outputDir);
@@ -12128,10 +14721,11 @@ var GithubStep = class extends BaseStep {
             newPrBranch,
             skipCommit,
             replayConflictInfo,
-            replayResult
+            replayResult,
+            resolvedPrFields
           );
         case "push":
-          return await this.executePushMode(repository);
+          return await this.executePushMode(repository, resolvedPrFields);
         default: {
           const exhaustive = mode;
           throw new Error(`Unexpected GitHub mode: ${String(exhaustive)}`);
@@ -12147,7 +14741,7 @@ var GithubStep = class extends BaseStep {
       };
     }
   }
-  async executePullRequestMode(repository, newPrBranch, skipCommit, replayConflictInfo, replayResult) {
+  async executePullRequestMode(repository, newPrBranch, skipCommit, replayConflictInfo, replayResult, resolved) {
     const baseBranch = this.config.branch ?? await repository.getDefaultBranch();
     const octokit = new import_rest2.Octokit({ auth: this.config.token });
     const { owner, repo } = parseRepository(this.config.uri);
@@ -12181,7 +14775,7 @@ var GithubStep = class extends BaseStep {
           generationBaseSha = await createReplayBranch(
             repository,
             prBranch,
-            this.config.commitMessage,
+            resolved.commitMessage,
             replayConflictInfo,
             this.logger
           );
@@ -12203,8 +14797,7 @@ var GithubStep = class extends BaseStep {
     if (!skipCommit) {
       await this.ensureFernignore();
       this.logger.debug("Committing changes...");
-      const finalCommitMessage2 = this.config.commitMessage ?? "SDK Generation";
-      await repository.commitAllChanges(finalCommitMessage2);
+      await repository.commitAllChanges(resolved.commitMessage);
       this.logger.debug(`Committed changes to local copy of GitHub repository at ${this.outputDir}`);
     }
     if (shouldCheckNoDiff(this.config)) {
@@ -12244,22 +14837,21 @@ var GithubStep = class extends BaseStep {
         }
       }
     }
-    const finalCommitMessage = this.config.commitMessage ?? "SDK Generation";
     const headSha = await repository.getHeadSha();
-    const changelogUrl = this.config.changelogEntry ? `https://github.com/${this.config.uri}/blob/${headSha}/changelog.md` : void 0;
+    const changelogUrl = resolved.changelogEntry ? `https://github.com/${this.config.uri}/blob/${headSha}/changelog.md` : void 0;
     const { prTitle, prBody } = parseCommitMessageForPR(
-      finalCommitMessage,
-      this.config.changelogEntry,
-      this.config.prDescription,
-      this.config.versionBumpReason,
-      this.config.previousVersion,
-      this.config.newVersion,
-      this.config.versionBump,
+      resolved.commitMessage,
+      resolved.changelogEntry,
+      resolved.prDescription,
+      resolved.versionBumpReason,
+      resolved.previousVersion,
+      resolved.newVersion,
+      resolved.versionBump,
       changelogUrl
     );
     const replaySection = formatReplayPrBody(replayResult, { branchName: prBranch, repoUri: this.config.uri });
     let enrichedBody = replaySection != null ? prBody + "\n\n---\n\n" + replaySection : prBody;
-    enrichedBody = enrichPrBodyForAutomation(enrichedBody, this.config);
+    enrichedBody = enrichPrBodyForAutomation(enrichedBody, this.config, resolved);
     if (isUpdatingExistingPR && existingPR != null) {
       this.logger.info(`Updated existing pull request: ${existingPR.htmlUrl}`);
       result.prUrl = existingPR.htmlUrl;
@@ -12290,7 +14882,7 @@ var GithubStep = class extends BaseStep {
         this.logger.info(`Created pull request: ${pullRequest.html_url}`);
         result.prUrl = pullRequest.html_url;
         result.prNumber = pullRequest.number;
-        if (shouldEnableAutomerge(this.config) && pullRequest.node_id) {
+        if (shouldEnableAutomerge(this.config, resolved) && pullRequest.node_id) {
           try {
             await octokit.graphql(
               `mutation($pullRequestId: ID!) {
@@ -12318,7 +14910,7 @@ var GithubStep = class extends BaseStep {
     }
     return result;
   }
-  async executePushMode(repository) {
+  async executePushMode(repository, resolved) {
     const baseBranch = this.config.branch ?? await repository.getDefaultBranch();
     if (this.config.branch != null) {
       this.logger.debug(`Checking out branch ${this.config.branch}`);
@@ -12326,8 +14918,7 @@ var GithubStep = class extends BaseStep {
     }
     await this.ensureFernignore();
     this.logger.debug("Committing changes...");
-    const finalCommitMessage = this.config.commitMessage ?? "SDK Generation";
-    await repository.commitAllChanges(finalCommitMessage);
+    await repository.commitAllChanges(resolved.commitMessage);
     this.logger.debug(`Committed changes to local copy of GitHub repository at ${this.outputDir}`);
     if (shouldCheckNoDiff(this.config)) {
       const noDiff = await repository.treeHashEquals(`origin/${baseBranch}`);
@@ -12390,14 +14981,33 @@ var GithubStep = class extends BaseStep {
     }
     return void 0;
   }
+  resolvePrFields(autoVersion) {
+    return resolvePrFields(this.config, autoVersion);
+  }
 };
-function enrichPrBodyForAutomation(body, config) {
+function resolvePrFields(config, autoVersion) {
+  const autoVersionBreaking = autoVersion?.versionBump === "MAJOR";
+  return {
+    commitMessage: config.commitMessage ?? autoVersion?.commitMessage ?? "SDK Generation",
+    changelogEntry: config.changelogEntry ?? autoVersion?.changelogEntry,
+    prDescription: config.prDescription ?? autoVersion?.prDescription,
+    versionBumpReason: config.versionBumpReason ?? autoVersion?.versionBumpReason,
+    previousVersion: config.previousVersion ?? autoVersion?.previousVersion,
+    newVersion: config.newVersion ?? autoVersion?.version,
+    versionBump: config.versionBump ?? autoVersion?.versionBump,
+    hasBreakingChanges: config.hasBreakingChanges ?? autoVersionBreaking,
+    breakingChangesSummary: config.breakingChangesSummary ?? autoVersion?.prDescription
+  };
+}
+function enrichPrBodyForAutomation(body, config, breaking = {}) {
   if (!config.automationMode) {
     return body;
   }
+  const hasBreakingChanges = breaking.hasBreakingChanges ?? config.hasBreakingChanges;
+  const breakingChangesSummary = breaking.breakingChangesSummary ?? config.breakingChangesSummary;
   let result = body;
-  if (config.hasBreakingChanges && config.breakingChangesSummary) {
-    result += "\n\n---\n\n## \u26A0\uFE0F Breaking Changes\n\nThis release contains breaking changes that require manual review:\n\n" + config.breakingChangesSummary;
+  if (hasBreakingChanges && breakingChangesSummary) {
+    result += "\n\n---\n\n## \u26A0\uFE0F Breaking Changes\n\nThis release contains breaking changes that require manual review:\n\n" + breakingChangesSummary;
   }
   if (config.runId) {
     result += `
@@ -12408,8 +15018,9 @@ _Fern Run ID: \`${config.runId}\`_`;
   }
   return result;
 }
-function shouldEnableAutomerge(config) {
-  return config.automationMode === true && config.autoMerge === true && config.hasBreakingChanges !== true;
+function shouldEnableAutomerge(config, breaking = {}) {
+  const hasBreakingChanges = breaking.hasBreakingChanges ?? config.hasBreakingChanges;
+  return config.automationMode === true && config.autoMerge === true && hasBreakingChanges !== true;
 }
 function shouldCheckNoDiff(config) {
   return config.skipIfNoDiff === true;