@base44-preview/cli 0.0.35-pr.328.b98b32e → 0.0.35-pr.332.152a3fd

package/dist/cli/index.js

@@ -12345,6 +12345,398 @@ var require_front_matter = __commonJS((exports, module) => {
   }
 });
 
+// node_modules/dotenv/package.json
+var require_package2 = __commonJS((exports, module) => {
+  module.exports = {
+    name: "dotenv",
+    version: "17.3.1",
+    description: "Loads environment variables from .env file",
+    main: "lib/main.js",
+    types: "lib/main.d.ts",
+    exports: {
+      ".": {
+        types: "./lib/main.d.ts",
+        require: "./lib/main.js",
+        default: "./lib/main.js"
+      },
+      "./config": "./config.js",
+      "./config.js": "./config.js",
+      "./lib/env-options": "./lib/env-options.js",
+      "./lib/env-options.js": "./lib/env-options.js",
+      "./lib/cli-options": "./lib/cli-options.js",
+      "./lib/cli-options.js": "./lib/cli-options.js",
+      "./package.json": "./package.json"
+    },
+    scripts: {
+      "dts-check": "tsc --project tests/types/tsconfig.json",
+      lint: "standard",
+      pretest: "npm run lint && npm run dts-check",
+      test: "tap run tests/**/*.js --allow-empty-coverage --disable-coverage --timeout=60000",
+      "test:coverage": "tap run tests/**/*.js --show-full-coverage --timeout=60000 --coverage-report=text --coverage-report=lcov",
+      prerelease: "npm test",
+      release: "standard-version"
+    },
+    repository: {
+      type: "git",
+      url: "git://github.com/motdotla/dotenv.git"
+    },
+    homepage: "https://github.com/motdotla/dotenv#readme",
+    funding: "https://dotenvx.com",
+    keywords: [
+      "dotenv",
+      "env",
+      ".env",
+      "environment",
+      "variables",
+      "config",
+      "settings"
+    ],
+    readmeFilename: "README.md",
+    license: "BSD-2-Clause",
+    devDependencies: {
+      "@types/node": "^18.11.3",
+      decache: "^4.6.2",
+      sinon: "^14.0.1",
+      standard: "^17.0.0",
+      "standard-version": "^9.5.0",
+      tap: "^19.2.0",
+      typescript: "^4.8.4"
+    },
+    engines: {
+      node: ">=12"
+    },
+    browser: {
+      fs: false
+    }
+  };
+});
+
+// node_modules/dotenv/lib/main.js
+var require_main = __commonJS((exports, module) => {
+  var fs14 = __require("fs");
+  var path11 = __require("path");
+  var os = __require("os");
+  var crypto = __require("crypto");
+  var packageJson = require_package2();
+  var version2 = packageJson.version;
+  var TIPS = [
+    "\uD83D\uDD10 encrypt with Dotenvx: https://dotenvx.com",
+    "\uD83D\uDD10 prevent committing .env to code: https://dotenvx.com/precommit",
+    "\uD83D\uDD10 prevent building .env in docker: https://dotenvx.com/prebuild",
+    "\uD83E\uDD16 agentic secret storage: https://dotenvx.com/as2",
+    "⚡️ secrets for agents: https://dotenvx.com/as2",
+    "\uD83D\uDEE1️ auth for agents: https://vestauth.com",
+    "\uD83D\uDEE0️  run anywhere with `dotenvx run -- yourcommand`",
+    "⚙️  specify custom .env file path with { path: '/custom/path/.env' }",
+    "⚙️  enable debug logging with { debug: true }",
+    "⚙️  override existing env vars with { override: true }",
+    "⚙️  suppress all logs with { quiet: true }",
+    "⚙️  write to custom object with { processEnv: myObject }",
+    "⚙️  load multiple .env files with { path: ['.env.local', '.env'] }"
+  ];
+  function _getRandomTip() {
+    return TIPS[Math.floor(Math.random() * TIPS.length)];
+  }
+  function parseBoolean(value) {
+    if (typeof value === "string") {
+      return !["false", "0", "no", "off", ""].includes(value.toLowerCase());
+    }
+    return Boolean(value);
+  }
+  function supportsAnsi() {
+    return process.stdout.isTTY;
+  }
+  function dim(text) {
+    return supportsAnsi() ? `\x1B[2m${text}\x1B[0m` : text;
+  }
+  var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+  function parse9(src) {
+    const obj = {};
+    let lines = src.toString();
+    lines = lines.replace(/\r\n?/mg, `
+`);
+    let match;
+    while ((match = LINE.exec(lines)) != null) {
+      const key = match[1];
+      let value = match[2] || "";
+      value = value.trim();
+      const maybeQuote = value[0];
+      value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
+      if (maybeQuote === '"') {
+        value = value.replace(/\\n/g, `
+`);
+        value = value.replace(/\\r/g, "\r");
+      }
+      obj[key] = value;
+    }
+    return obj;
+  }
+  function _parseVault(options) {
+    options = options || {};
+    const vaultPath = _vaultPath(options);
+    options.path = vaultPath;
+    const result = DotenvModule.configDotenv(options);
+    if (!result.parsed) {
+      const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+      err.code = "MISSING_DATA";
+      throw err;
+    }
+    const keys = _dotenvKey(options).split(",");
+    const length = keys.length;
+    let decrypted;
+    for (let i = 0;i < length; i++) {
+      try {
+        const key = keys[i].trim();
+        const attrs = _instructions(result, key);
+        decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+        break;
+      } catch (error48) {
+        if (i + 1 >= length) {
+          throw error48;
+        }
+      }
+    }
+    return DotenvModule.parse(decrypted);
+  }
+  function _warn(message) {
+    console.error(`[dotenv@${version2}][WARN] ${message}`);
+  }
+  function _debug(message) {
+    console.log(`[dotenv@${version2}][DEBUG] ${message}`);
+  }
+  function _log(message) {
+    console.log(`[dotenv@${version2}] ${message}`);
+  }
+  function _dotenvKey(options) {
+    if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+      return options.DOTENV_KEY;
+    }
+    if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+      return process.env.DOTENV_KEY;
+    }
+    return "";
+  }
+  function _instructions(result, dotenvKey) {
+    let uri;
+    try {
+      uri = new URL(dotenvKey);
+    } catch (error48) {
+      if (error48.code === "ERR_INVALID_URL") {
+        const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      throw error48;
+    }
+    const key = uri.password;
+    if (!key) {
+      const err = new Error("INVALID_DOTENV_KEY: Missing key part");
+      err.code = "INVALID_DOTENV_KEY";
+      throw err;
+    }
+    const environment = uri.searchParams.get("environment");
+    if (!environment) {
+      const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
+      err.code = "INVALID_DOTENV_KEY";
+      throw err;
+    }
+    const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+    const ciphertext = result.parsed[environmentKey];
+    if (!ciphertext) {
+      const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+      err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+      throw err;
+    }
+    return { ciphertext, key };
+  }
+  function _vaultPath(options) {
+    let possibleVaultPath = null;
+    if (options && options.path && options.path.length > 0) {
+      if (Array.isArray(options.path)) {
+        for (const filepath of options.path) {
+          if (fs14.existsSync(filepath)) {
+            possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+          }
+        }
+      } else {
+        possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+      }
+    } else {
+      possibleVaultPath = path11.resolve(process.cwd(), ".env.vault");
+    }
+    if (fs14.existsSync(possibleVaultPath)) {
+      return possibleVaultPath;
+    }
+    return null;
+  }
+  function _resolveHome(envPath) {
+    return envPath[0] === "~" ? path11.join(os.homedir(), envPath.slice(1)) : envPath;
+  }
+  function _configVault(options) {
+    const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
+    const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
+    if (debug || !quiet) {
+      _log("Loading env from encrypted .env.vault");
+    }
+    const parsed = DotenvModule._parseVault(options);
+    let processEnv = process.env;
+    if (options && options.processEnv != null) {
+      processEnv = options.processEnv;
+    }
+    DotenvModule.populate(processEnv, parsed, options);
+    return { parsed };
+  }
+  function configDotenv(options) {
+    const dotenvPath = path11.resolve(process.cwd(), ".env");
+    let encoding = "utf8";
+    let processEnv = process.env;
+    if (options && options.processEnv != null) {
+      processEnv = options.processEnv;
+    }
+    let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
+    let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
+    if (options && options.encoding) {
+      encoding = options.encoding;
+    } else {
+      if (debug) {
+        _debug("No encoding is specified. UTF-8 is used by default");
+      }
+    }
+    let optionPaths = [dotenvPath];
+    if (options && options.path) {
+      if (!Array.isArray(options.path)) {
+        optionPaths = [_resolveHome(options.path)];
+      } else {
+        optionPaths = [];
+        for (const filepath of options.path) {
+          optionPaths.push(_resolveHome(filepath));
+        }
+      }
+    }
+    let lastError;
+    const parsedAll = {};
+    for (const path12 of optionPaths) {
+      try {
+        const parsed = DotenvModule.parse(fs14.readFileSync(path12, { encoding }));
+        DotenvModule.populate(parsedAll, parsed, options);
+      } catch (e2) {
+        if (debug) {
+          _debug(`Failed to load ${path12} ${e2.message}`);
+        }
+        lastError = e2;
+      }
+    }
+    const populated = DotenvModule.populate(processEnv, parsedAll, options);
+    debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
+    quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
+    if (debug || !quiet) {
+      const keysCount = Object.keys(populated).length;
+      const shortPaths = [];
+      for (const filePath of optionPaths) {
+        try {
+          const relative = path11.relative(process.cwd(), filePath);
+          shortPaths.push(relative);
+        } catch (e2) {
+          if (debug) {
+            _debug(`Failed to load ${filePath} ${e2.message}`);
+          }
+          lastError = e2;
+        }
+      }
+      _log(`injecting env (${keysCount}) from ${shortPaths.join(",")} ${dim(`-- tip: ${_getRandomTip()}`)}`);
+    }
+    if (lastError) {
+      return { parsed: parsedAll, error: lastError };
+    } else {
+      return { parsed: parsedAll };
+    }
+  }
+  function config9(options) {
+    if (_dotenvKey(options).length === 0) {
+      return DotenvModule.configDotenv(options);
+    }
+    const vaultPath = _vaultPath(options);
+    if (!vaultPath) {
+      _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
+      return DotenvModule.configDotenv(options);
+    }
+    return DotenvModule._configVault(options);
+  }
+  function decrypt(encrypted, keyStr) {
+    const key = Buffer.from(keyStr.slice(-64), "hex");
+    let ciphertext = Buffer.from(encrypted, "base64");
+    const nonce = ciphertext.subarray(0, 12);
+    const authTag = ciphertext.subarray(-16);
+    ciphertext = ciphertext.subarray(12, -16);
+    try {
+      const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+      aesgcm.setAuthTag(authTag);
+      return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+    } catch (error48) {
+      const isRange = error48 instanceof RangeError;
+      const invalidKeyLength = error48.message === "Invalid key length";
+      const decryptionFailed = error48.message === "Unsupported state or unable to authenticate data";
+      if (isRange || invalidKeyLength) {
+        const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      } else if (decryptionFailed) {
+        const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+        err.code = "DECRYPTION_FAILED";
+        throw err;
+      } else {
+        throw error48;
+      }
+    }
+  }
+  function populate(processEnv, parsed, options = {}) {
+    const debug = Boolean(options && options.debug);
+    const override = Boolean(options && options.override);
+    const populated = {};
+    if (typeof parsed !== "object") {
+      const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+      err.code = "OBJECT_REQUIRED";
+      throw err;
+    }
+    for (const key of Object.keys(parsed)) {
+      if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+        if (override === true) {
+          processEnv[key] = parsed[key];
+          populated[key] = parsed[key];
+        }
+        if (debug) {
+          if (override === true) {
+            _debug(`"${key}" is already defined and WAS overwritten`);
+          } else {
+            _debug(`"${key}" is already defined and was NOT overwritten`);
+          }
+        }
+      } else {
+        processEnv[key] = parsed[key];
+        populated[key] = parsed[key];
+      }
+    }
+    return populated;
+  }
+  var DotenvModule = {
+    configDotenv,
+    _configVault,
+    _parseVault,
+    config: config9,
+    decrypt,
+    parse: parse9,
+    populate
+  };
+  exports.configDotenv = DotenvModule.configDotenv;
+  exports._configVault = DotenvModule._configVault;
+  exports._parseVault = DotenvModule._parseVault;
+  exports.config = DotenvModule.config;
+  exports.decrypt = DotenvModule.decrypt;
+  exports.parse = DotenvModule.parse;
+  exports.populate = DotenvModule.populate;
+  module.exports = DotenvModule;
+});
+
 // node_modules/isexe/windows.js
 var require_windows = __commonJS((exports, module) => {
   module.exports = isexe;
@@ -12578,7 +12970,7 @@ var require_resolveCommand = __commonJS((exports, module) => {
   var which = require_which();
   var getPathKey = require_path_key();
   function resolveCommandAttempt(parsed, withoutPathExt) {
-    const env2 = parsed.options.env || process.env;
+    const env3 = parsed.options.env || process.env;
     const cwd = process.cwd();
     const hasCustomCwd = parsed.options.cwd != null;
     const shouldSwitchCwd = hasCustomCwd && process.chdir !== undefined && !process.chdir.disabled;
@@ -12590,7 +12982,7 @@ var require_resolveCommand = __commonJS((exports, module) => {
     let resolved;
     try {
       resolved = which.sync(parsed.command, {
-        path: env2[getPathKey({ env: env2 })],
+        path: env3[getPathKey({ env: env3 })],
         pathExt: withoutPathExt ? path11.delimiter : undefined
       });
     } catch (e2) {} finally {
@@ -12708,7 +13100,7 @@ var require_parse4 = __commonJS((exports, module) => {
     }
     return parsed;
   }
-  function parse9(command, args, options) {
+  function parse10(command, args, options) {
     if (args && !Array.isArray(args)) {
       options = args;
       args = null;
@@ -12727,7 +13119,7 @@ var require_parse4 = __commonJS((exports, module) => {
     };
     return options.shell ? parsed : parseNonShell(parsed);
   }
-  module.exports = parse9;
+  module.exports = parse10;
 });
 
 // node_modules/cross-spawn/lib/enoent.js
@@ -12780,16 +13172,16 @@ var require_enoent = __commonJS((exports, module) => {
 // node_modules/cross-spawn/index.js
 var require_cross_spawn = __commonJS((exports, module) => {
   var cp = __require("child_process");
-  var parse9 = require_parse4();
+  var parse10 = require_parse4();
   var enoent = require_enoent();
   function spawn(command, args, options) {
-    const parsed = parse9(command, args, options);
+    const parsed = parse10(command, args, options);
     const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
     enoent.hookChildProcess(spawned, parsed);
     return spawned;
   }
   function spawnSync(command, args, options) {
-    const parsed = parse9(command, args, options);
+    const parsed = parse10(command, args, options);
     const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
     result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
     return result;
@@ -12797,7 +13189,7 @@ var require_cross_spawn = __commonJS((exports, module) => {
   module.exports = spawn;
   module.exports.spawn = spawn;
   module.exports.sync = spawnSync;
-  module.exports._parse = parse9;
+  module.exports._parse = parse10;
   module.exports._enoent = enoent;
 });
 
@@ -108409,11 +108801,11 @@ function chooseDescription(descriptions, printWidth) {
   return firstWidth > printWidth && firstWidth > secondWidth ? secondDescription : firstDescription;
 }
 function createSchema(SchemaConstructor, parameters) {
-  const schema8 = new SchemaConstructor(parameters);
-  const subSchema = Object.create(schema8);
+  const schema9 = new SchemaConstructor(parameters);
+  const subSchema = Object.create(schema9);
   for (const handlerKey of HANDLER_KEYS) {
     if (handlerKey in parameters) {
-      subSchema[handlerKey] = normalizeHandler(parameters[handlerKey], schema8, Schema.prototype[handlerKey].length);
+      subSchema[handlerKey] = normalizeHandler(parameters[handlerKey], schema9, Schema.prototype[handlerKey].length);
     }
   }
   return subSchema;
@@ -111753,9 +112145,9 @@ function optionInfoToSchema(optionInfo, {
       throw new Error(`Unexpected type ${optionInfo.type}`);
   }
   if (optionInfo.exception) {
-    parameters.validate = (value, schema8, utils3) => optionInfo.exception(value) || schema8.validate(value, utils3);
+    parameters.validate = (value, schema9, utils3) => optionInfo.exception(value) || schema9.validate(value, utils3);
   } else {
-    parameters.validate = (value, schema8, utils3) => value === undefined || schema8.validate(value, utils3);
+    parameters.validate = (value, schema9, utils3) => value === undefined || schema9.validate(value, utils3);
   }
   if (optionInfo.redirect) {
     handlers.redirect = (value) => !value ? undefined : {
@@ -111770,7 +112162,7 @@ function optionInfoToSchema(optionInfo, {
   }
   if (isCLI && !optionInfo.array) {
     const originalPreprocess = parameters.preprocess || ((x10) => x10);
-    parameters.preprocess = (value, schema8, utils3) => schema8.preprocess(originalPreprocess(Array.isArray(value) ? method_at_default2(0, value, -1) : value), utils3);
+    parameters.preprocess = (value, schema9, utils3) => schema9.preprocess(originalPreprocess(Array.isArray(value) ? method_at_default2(0, value, -1) : value), utils3);
   }
   return optionInfo.array ? ArraySchema.create({
     ...isCLI ? {
@@ -113048,7 +113440,7 @@ var require2, __filename2, __dirname4, __create2, __defProp3, __getOwnPropDesc,
         __defProp3(to5, key2, { get: () => from[key2], enumerable: !(desc2 = __getOwnPropDesc(from, key2)) || desc2.enumerable });
   }
   return to5;
-}, __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp3(target, "default", { value: mod, enumerable: true }) : target, mod)), require_array2, require_errno2, require_fs5, require_path2, require_is_extglob2, require_is_glob2, require_glob_parent2, require_utils6, require_stringify3, require_is_number2, require_to_regex_range2, require_fill_range2, require_compile2, require_expand2, require_constants4, require_parse5, require_braces2, require_constants22, require_utils22, require_scan2, require_parse22, require_picomatch2, require_picomatch22, require_micromatch2, require_pattern2, require_merge22, require_stream5, require_string2, require_utils32, require_tasks2, require_async7, require_sync7, require_fs22, require_settings5, require_out5, require_queue_microtask2, require_run_parallel2, require_constants32, require_fs32, require_utils42, require_common4, require_async22, require_sync22, require_fs42, require_settings22, require_out22, require_reusify2, require_queue2, require_common22, require_reader3, require_async32, require_async42, require_stream22, require_sync32, require_sync42, require_settings32, require_out32, require_reader22, require_stream32, require_async52, require_matcher2, require_partial2, require_deep2, require_entry3, require_error3, require_entry22, require_provider2, require_async62, require_stream42, require_sync52, require_sync62, require_settings42, require_out42, require_picocolors2, require_debug, require_constants42, require_re, require_parse_options, require_identifiers, require_semver, require_compare, require_gte, require_pseudomap, require_map2, require_yallist, require_lru_cache, require_sigmund, require_fnmatch, require_ini, require_package2, require_src2, require_js_tokens, require_readlines, require_ignore2, index_exports, Diff = class {
+}, __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp3(target, "default", { value: mod, enumerable: true }) : target, mod)), require_array2, require_errno2, require_fs5, require_path2, require_is_extglob2, require_is_glob2, require_glob_parent2, require_utils6, require_stringify3, require_is_number2, require_to_regex_range2, require_fill_range2, require_compile2, require_expand2, require_constants4, require_parse5, require_braces2, require_constants22, require_utils22, require_scan2, require_parse22, require_picomatch2, require_picomatch22, require_micromatch2, require_pattern2, require_merge22, require_stream5, require_string2, require_utils32, require_tasks2, require_async7, require_sync7, require_fs22, require_settings5, require_out5, require_queue_microtask2, require_run_parallel2, require_constants32, require_fs32, require_utils42, require_common4, require_async22, require_sync22, require_fs42, require_settings22, require_out22, require_reusify2, require_queue2, require_common22, require_reader3, require_async32, require_async42, require_stream22, require_sync32, require_sync42, require_settings32, require_out32, require_reader22, require_stream32, require_async52, require_matcher2, require_partial2, require_deep2, require_entry3, require_error3, require_entry22, require_provider2, require_async62, require_stream42, require_sync52, require_sync62, require_settings42, require_out42, require_picocolors2, require_debug, require_constants42, require_re, require_parse_options, require_identifiers, require_semver, require_compare, require_gte, require_pseudomap, require_map2, require_yallist, require_lru_cache, require_sigmund, require_fnmatch, require_ini, require_package3, require_src2, require_js_tokens, require_readlines, require_ignore2, index_exports, Diff = class {
   diff(oldStr, newStr, options8 = {}) {
     let callback;
     if (typeof options8 === "function") {
@@ -113347,9 +113739,9 @@ var require2, __filename2, __dirname4, __create2, __defProp3, __getOwnPropDesc,
     };
     applyNormalization();
     for (const key2 of Object.keys(this._utils.schemas)) {
-      const schema8 = this._utils.schemas[key2];
+      const schema9 = this._utils.schemas[key2];
       if (!(key2 in newOptions)) {
-        const defaultResult = normalizeDefaultResult(schema8.default(this._utils));
+        const defaultResult = normalizeDefaultResult(schema9.default(this._utils));
         if ("value" in defaultResult) {
           restOptionsArray.push({ [key2]: defaultResult.value });
         }
@@ -113360,13 +113752,13 @@ var require2, __filename2, __dirname4, __create2, __defProp3, __getOwnPropDesc,
       if (!(key2 in newOptions)) {
         continue;
       }
-      const schema8 = this._utils.schemas[key2];
+      const schema9 = this._utils.schemas[key2];
       const value = newOptions[key2];
-      const newValue = schema8.postprocess(value, this._utils);
+      const newValue = schema9.postprocess(value, this._utils);
       if (newValue === VALUE_UNCHANGED) {
         continue;
       }
-      this._applyValidation(newValue, key2, schema8);
+      this._applyValidation(newValue, key2, schema9);
       newOptions[key2] = newValue;
     }
     this._applyPostprocess(newOptions);
@@ -113377,14 +113769,14 @@ var require2, __filename2, __dirname4, __create2, __defProp3, __getOwnPropDesc,
     const transferredOptionsArray = [];
     const { knownKeys, unknownKeys } = this._partitionOptionKeys(options8);
     for (const key2 of knownKeys) {
-      const schema8 = this._utils.schemas[key2];
-      const value = schema8.preprocess(options8[key2], this._utils);
-      this._applyValidation(value, key2, schema8);
+      const schema9 = this._utils.schemas[key2];
+      const value = schema9.preprocess(options8[key2], this._utils);
+      this._applyValidation(value, key2, schema9);
       const appendTransferredOptions = ({ from, to: to5 }) => {
         transferredOptionsArray.push(typeof to5 === "string" ? { [to5]: from } : { [to5.key]: to5.value });
       };
       const warnDeprecated = ({ value: currentValue, redirectTo }) => {
-        const deprecatedResult = normalizeDeprecatedResult(schema8.deprecated(currentValue, this._utils), value, true);
+        const deprecatedResult = normalizeDeprecatedResult(schema9.deprecated(currentValue, this._utils), value, true);
         if (deprecatedResult === false) {
           return;
         }
@@ -113402,13 +113794,13 @@ var require2, __filename2, __dirname4, __create2, __defProp3, __getOwnPropDesc,
           }
         }
       };
-      const forwardResult = normalizeForwardResult(schema8.forward(value, this._utils), value);
+      const forwardResult = normalizeForwardResult(schema9.forward(value, this._utils), value);
       forwardResult.forEach(appendTransferredOptions);
-      const redirectResult = normalizeRedirectResult(schema8.redirect(value, this._utils), value);
+      const redirectResult = normalizeRedirectResult(schema9.redirect(value, this._utils), value);
       redirectResult.redirect.forEach(appendTransferredOptions);
       if ("remain" in redirectResult) {
         const remainingValue = redirectResult.remain;
-        newOptions[key2] = key2 in newOptions ? schema8.overlap(newOptions[key2], remainingValue, this._utils) : remainingValue;
+        newOptions[key2] = key2 in newOptions ? schema9.overlap(newOptions[key2], remainingValue, this._utils) : remainingValue;
         warnDeprecated({ value: remainingValue });
       }
       for (const { from, to: to5 } of redirectResult.redirect) {
@@ -113436,8 +113828,8 @@ var require2, __filename2, __dirname4, __create2, __defProp3, __getOwnPropDesc,
     const [knownKeys, unknownKeys] = partition(Object.keys(options8).filter((key2) => !this._identifyMissing(key2, options8)), (key2) => (key2 in this._utils.schemas));
     return { knownKeys, unknownKeys };
   }
-  _applyValidation(value, key2, schema8) {
-    const validateResult = normalizeValidateResult(schema8.validate(value, this._utils), value);
+  _applyValidation(value, key2, schema9) {
+    const validateResult = normalizeValidateResult(schema9.validate(value, this._utils), value);
     if (validateResult !== true) {
       throw this._invalidHandler(key2, validateResult.value, this._utils);
     }
@@ -113479,8 +113871,8 @@ var require2, __filename2, __dirname4, __create2, __defProp3, __getOwnPropDesc,
       for (const key2 of unknownKeys) {
         const value = postprocessed.override[key2];
         this._applyUnknownHandler(key2, value, options8, (knownResultKey, knownResultValue) => {
-          const schema8 = this._utils.schemas[knownResultKey];
-          this._applyValidation(knownResultValue, knownResultKey, schema8);
+          const schema9 = this._utils.schemas[knownResultKey];
+          this._applyValidation(knownResultValue, knownResultKey, schema9);
           options8[knownResultKey] = knownResultValue;
         });
       }
@@ -118988,8 +119380,8 @@ var init_prettier = __esm(() => {
     "node_modules/picocolors/picocolors.js"(exports, module) {
       var p4 = process || {};
       var argv = p4.argv || [];
-      var env2 = p4.env || {};
-      var isColorSupported2 = !(!!env2.NO_COLOR || argv.includes("--no-color")) && (!!env2.FORCE_COLOR || argv.includes("--color") || p4.platform === "win32" || (p4.stdout || {}).isTTY && env2.TERM !== "dumb" || !!env2.CI);
+      var env3 = p4.env || {};
+      var isColorSupported2 = !(!!env3.NO_COLOR || argv.includes("--no-color")) && (!!env3.FORCE_COLOR || argv.includes("--color") || p4.platform === "win32" || (p4.stdout || {}).isTTY && env3.TERM !== "dumb" || !!env3.CI);
       var formatter = (open2, close, replace3 = open2) => (input) => {
         let string4 = "" + input, index = string4.indexOf(close, open2.length);
         return ~index ? open2 + replaceClose(string4, close, replace3, index) + close : open2 + string4 + close;
@@ -121151,7 +121543,7 @@ globstar while`, file2, fr10, pattern, pr8, swallowee);
       exports.parseString = parseString2;
     }
   });
-  require_package2 = __commonJS2({
+  require_package3 = __commonJS2({
     "node_modules/editorconfig/package.json"(exports, module) {
       module.exports = {
         name: "editorconfig",
@@ -121340,7 +121732,7 @@ globstar while`, file2, fr10, pattern, pr8, swallowee);
       var fnmatch_1 = __importDefault(require_fnmatch());
       var ini_1 = require_ini();
       exports.parseString = ini_1.parseString;
-      var package_json_1 = __importDefault(require_package2());
+      var package_json_1 = __importDefault(require_package3());
       var knownProps = {
         end_of_line: true,
         indent_style: true,
@@ -127118,11 +127510,11 @@ var require_prettier = __commonJS((exports, module) => {
 var require_formatter = __commonJS((exports) => {
   var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P9, generator) {
     function adopt(value) {
-      return value instanceof P9 ? value : new P9(function(resolve5) {
-        resolve5(value);
+      return value instanceof P9 ? value : new P9(function(resolve6) {
+        resolve6(value);
       });
     }
-    return new (P9 || (P9 = Promise))(function(resolve5, reject) {
+    return new (P9 || (P9 = Promise))(function(resolve6, reject) {
       function fulfilled(value) {
         try {
           step(generator.next(value));
@@ -127138,7 +127530,7 @@ var require_formatter = __commonJS((exports) => {
         }
       }
       function step(result) {
-        result.done ? resolve5(result.value) : adopt(result.value).then(fulfilled, rejected);
+        result.done ? resolve6(result.value) : adopt(result.value).then(fulfilled, rejected);
       }
       step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
@@ -127193,23 +127585,23 @@ var require_JSONSchema = __commonJS((exports) => {
   exports.Parent = Symbol("Parent");
   exports.Types = Symbol("Types");
   exports.Intersection = Symbol("Intersection");
-  exports.getRootSchema = (0, lodash_1.memoize)((schema8) => {
-    const parent = schema8[exports.Parent];
+  exports.getRootSchema = (0, lodash_1.memoize)((schema9) => {
+    const parent = schema9[exports.Parent];
     if (!parent) {
-      return schema8;
+      return schema9;
     }
     return (0, exports.getRootSchema)(parent);
   });
-  function isBoolean(schema8) {
-    return schema8 === true || schema8 === false;
+  function isBoolean(schema9) {
+    return schema9 === true || schema9 === false;
   }
   exports.isBoolean = isBoolean;
-  function isPrimitive(schema8) {
-    return !(0, lodash_1.isPlainObject)(schema8);
+  function isPrimitive(schema9) {
+    return !(0, lodash_1.isPlainObject)(schema9);
   }
   exports.isPrimitive = isPrimitive;
-  function isCompound(schema8) {
-    return Array.isArray(schema8.type) || "anyOf" in schema8 || "oneOf" in schema8;
+  function isCompound(schema9) {
+    return Array.isArray(schema9.type) || "anyOf" in schema9 || "oneOf" in schema9;
   }
   exports.isCompound = isCompound;
 });
@@ -127436,9 +127828,9 @@ var require_type2 = __commonJS((exports, module) => {
 var require_schema2 = __commonJS((exports, module) => {
   var YAMLException = require_exception2();
   var Type = require_type2();
-  function compileList(schema8, name2) {
+  function compileList(schema9, name2) {
     var result = [];
-    schema8[name2].forEach(function(currentType) {
+    schema9[name2].forEach(function(currentType) {
       var newIndex = result.length;
       result.forEach(function(previousType, previousIndex) {
         if (previousType.tag === currentType.tag && previousType.kind === currentType.kind && previousType.multi === currentType.multi) {
@@ -129383,7 +129775,7 @@ var require_dumper2 = __commonJS((exports, module) => {
     "OFF"
   ];
   var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;
-  function compileStyleMap(schema8, map2) {
+  function compileStyleMap(schema9, map2) {
     var result, keys, index, length, tag, style, type;
     if (map2 === null)
       return {};
@@ -129395,7 +129787,7 @@ var require_dumper2 = __commonJS((exports, module) => {
       if (tag.slice(0, 2) === "!!") {
         tag = "tag:yaml.org,2002:" + tag.slice(2);
       }
-      type = schema8.compiledTypeMap["fallback"][tag];
+      type = schema9.compiledTypeMap["fallback"][tag];
       if (type && _hasOwnProperty.call(type.styleAliases, style)) {
         style = type.styleAliases[style];
       }
@@ -130054,11 +130446,11 @@ var require_utils7 = __commonJS((exports) => {
   function traverseArray(arr, callback, processed) {
     arr.forEach((s5, k9) => traverse(s5, callback, processed, k9.toString()));
   }
-  function traverseIntersection(schema8, callback, processed) {
-    if (typeof schema8 !== "object" || !schema8) {
+  function traverseIntersection(schema9, callback, processed) {
+    if (typeof schema9 !== "object" || !schema9) {
       return;
     }
-    const r5 = schema8;
+    const r5 = schema9;
     const intersection2 = r5[JSONSchema_1.Intersection];
     if (!intersection2) {
       return;
@@ -130067,60 +130459,60 @@ var require_utils7 = __commonJS((exports) => {
       traverseArray(intersection2.allOf, callback, processed);
     }
   }
-  function traverse(schema8, callback, processed = new Set, key2) {
-    if (processed.has(schema8)) {
+  function traverse(schema9, callback, processed = new Set, key2) {
+    if (processed.has(schema9)) {
       return;
     }
-    processed.add(schema8);
-    callback(schema8, key2 !== null && key2 !== undefined ? key2 : null);
-    if (schema8.anyOf) {
-      traverseArray(schema8.anyOf, callback, processed);
+    processed.add(schema9);
+    callback(schema9, key2 !== null && key2 !== undefined ? key2 : null);
+    if (schema9.anyOf) {
+      traverseArray(schema9.anyOf, callback, processed);
     }
-    if (schema8.allOf) {
-      traverseArray(schema8.allOf, callback, processed);
+    if (schema9.allOf) {
+      traverseArray(schema9.allOf, callback, processed);
     }
-    if (schema8.oneOf) {
-      traverseArray(schema8.oneOf, callback, processed);
+    if (schema9.oneOf) {
+      traverseArray(schema9.oneOf, callback, processed);
     }
-    if (schema8.properties) {
-      traverseObjectKeys(schema8.properties, callback, processed);
+    if (schema9.properties) {
+      traverseObjectKeys(schema9.properties, callback, processed);
     }
-    if (schema8.patternProperties) {
-      traverseObjectKeys(schema8.patternProperties, callback, processed);
+    if (schema9.patternProperties) {
+      traverseObjectKeys(schema9.patternProperties, callback, processed);
     }
-    if (schema8.additionalProperties && typeof schema8.additionalProperties === "object") {
-      traverse(schema8.additionalProperties, callback, processed);
+    if (schema9.additionalProperties && typeof schema9.additionalProperties === "object") {
+      traverse(schema9.additionalProperties, callback, processed);
     }
-    if (schema8.items) {
-      const { items } = schema8;
+    if (schema9.items) {
+      const { items } = schema9;
       if (Array.isArray(items)) {
         traverseArray(items, callback, processed);
       } else {
         traverse(items, callback, processed);
       }
     }
-    if (schema8.additionalItems && typeof schema8.additionalItems === "object") {
-      traverse(schema8.additionalItems, callback, processed);
+    if (schema9.additionalItems && typeof schema9.additionalItems === "object") {
+      traverse(schema9.additionalItems, callback, processed);
     }
-    if (schema8.dependencies) {
-      if (Array.isArray(schema8.dependencies)) {
-        traverseArray(schema8.dependencies, callback, processed);
+    if (schema9.dependencies) {
+      if (Array.isArray(schema9.dependencies)) {
+        traverseArray(schema9.dependencies, callback, processed);
       } else {
-        traverseObjectKeys(schema8.dependencies, callback, processed);
+        traverseObjectKeys(schema9.dependencies, callback, processed);
       }
     }
-    if (schema8.definitions) {
-      traverseObjectKeys(schema8.definitions, callback, processed);
+    if (schema9.definitions) {
+      traverseObjectKeys(schema9.definitions, callback, processed);
     }
-    if (schema8.$defs) {
-      traverseObjectKeys(schema8.$defs, callback, processed);
+    if (schema9.$defs) {
+      traverseObjectKeys(schema9.$defs, callback, processed);
     }
-    if (schema8.not) {
-      traverse(schema8.not, callback, processed);
+    if (schema9.not) {
+      traverse(schema9.not, callback, processed);
     }
-    traverseIntersection(schema8, callback, processed);
-    Object.keys(schema8).filter((key3) => !BLACKLISTED_KEYS.has(key3)).forEach((key3) => {
-      const child = schema8[key3];
+    traverseIntersection(schema9, callback, processed);
+    Object.keys(schema9).filter((key3) => !BLACKLISTED_KEYS.has(key3)).forEach((key3) => {
+      const child = schema9[key3];
       if (child && typeof child === "object") {
         traverseObjectKeys(child, callback, processed);
       }
@@ -130202,14 +130594,14 @@ var require_utils7 = __commonJS((exports) => {
         return (_g2 = color()) === null || _g2 === undefined ? undefined : _g2.whiteBright.bgYellow;
     }
   }
-  function escapeBlockComment(schema8) {
+  function escapeBlockComment(schema9) {
     const replacer = "* /";
-    if (schema8 === null || typeof schema8 !== "object") {
+    if (schema9 === null || typeof schema9 !== "object") {
       return;
     }
-    for (const key2 of Object.keys(schema8)) {
-      if (key2 === "description" && typeof schema8[key2] === "string") {
-        schema8[key2] = schema8[key2].replace(/\*\//g, replacer);
+    for (const key2 of Object.keys(schema9)) {
+      if (key2 === "description" && typeof schema9[key2] === "string") {
+        schema9[key2] = schema9[key2].replace(/\*\//g, replacer);
       }
     }
   }
@@ -130221,45 +130613,45 @@ var require_utils7 = __commonJS((exports) => {
     return path_1.posix.join(path_1.posix.normalize(outputPath), ...filePathRel);
   }
   exports.pathTransform = pathTransform;
-  function maybeStripDefault(schema8) {
-    if (!("default" in schema8)) {
-      return schema8;
+  function maybeStripDefault(schema9) {
+    if (!("default" in schema9)) {
+      return schema9;
     }
-    switch (schema8.type) {
+    switch (schema9.type) {
       case "array":
-        if (Array.isArray(schema8.default)) {
-          return schema8;
+        if (Array.isArray(schema9.default)) {
+          return schema9;
         }
         break;
       case "boolean":
-        if (typeof schema8.default === "boolean") {
-          return schema8;
+        if (typeof schema9.default === "boolean") {
+          return schema9;
         }
         break;
       case "integer":
       case "number":
-        if (typeof schema8.default === "number") {
-          return schema8;
+        if (typeof schema9.default === "number") {
+          return schema9;
         }
         break;
       case "string":
-        if (typeof schema8.default === "string") {
-          return schema8;
+        if (typeof schema9.default === "string") {
+          return schema9;
         }
         break;
       case "null":
-        if (schema8.default === null) {
-          return schema8;
+        if (schema9.default === null) {
+          return schema9;
         }
         break;
       case "object":
-        if ((0, lodash_1.isPlainObject)(schema8.default)) {
-          return schema8;
+        if ((0, lodash_1.isPlainObject)(schema9.default)) {
+          return schema9;
         }
         break;
     }
-    delete schema8.default;
-    return schema8;
+    delete schema9.default;
+    return schema9;
   }
   exports.maybeStripDefault = maybeStripDefault;
   function appendToDescription(existingDescription, ...values) {
@@ -130273,11 +130665,11 @@ ${values.join(`
 `);
   }
   exports.appendToDescription = appendToDescription;
-  function isSchemaLike(schema8) {
-    if (!(0, lodash_1.isPlainObject)(schema8)) {
+  function isSchemaLike(schema9) {
+    if (!(0, lodash_1.isPlainObject)(schema9)) {
       return false;
     }
-    const parent = schema8[JSONSchema_1.Parent];
+    const parent = schema9[JSONSchema_1.Parent];
     if (parent === null) {
       return true;
     }
@@ -130294,7 +130686,7 @@ ${values.join(`
       "properties",
       "required"
     ];
-    if (JSON_SCHEMA_KEYWORDS.some((_10) => parent[_10] === schema8)) {
+    if (JSON_SCHEMA_KEYWORDS.some((_10) => parent[_10] === schema9)) {
       return false;
     }
     return true;
@@ -130592,13 +130984,13 @@ var require_typesOfSchema = __commonJS((exports) => {
   exports.typesOfSchema = undefined;
   var lodash_1 = require_lodash2();
   var JSONSchema_1 = require_JSONSchema();
-  function typesOfSchema(schema8) {
-    if (schema8.tsType) {
+  function typesOfSchema(schema9) {
+    if (schema9.tsType) {
       return new Set(["CUSTOM_TYPE"]);
     }
     const matchedTypes = new Set;
     for (const [schemaType, f7] of Object.entries(matchers)) {
-      if (f7(schema8)) {
+      if (f7(schema9)) {
         matchedTypes.add(schemaType);
       }
     }
@@ -130609,26 +131001,26 @@ var require_typesOfSchema = __commonJS((exports) => {
   }
   exports.typesOfSchema = typesOfSchema;
   var matchers = {
-    ALL_OF(schema8) {
-      return "allOf" in schema8;
+    ALL_OF(schema9) {
+      return "allOf" in schema9;
     },
-    ANY(schema8) {
-      if (Object.keys(schema8).length === 0) {
+    ANY(schema9) {
+      if (Object.keys(schema9).length === 0) {
         return true;
       }
-      return schema8.type === "any";
+      return schema9.type === "any";
     },
-    ANY_OF(schema8) {
-      return "anyOf" in schema8;
+    ANY_OF(schema9) {
+      return "anyOf" in schema9;
     },
-    BOOLEAN(schema8) {
-      if ("enum" in schema8) {
+    BOOLEAN(schema9) {
+      if ("enum" in schema9) {
         return false;
       }
-      if (schema8.type === "boolean") {
+      if (schema9.type === "boolean") {
         return true;
       }
-      if (!(0, JSONSchema_1.isCompound)(schema8) && typeof schema8.default === "boolean") {
+      if (!(0, JSONSchema_1.isCompound)(schema9) && typeof schema9.default === "boolean") {
         return true;
       }
       return false;
@@ -130636,74 +131028,74 @@ var require_typesOfSchema = __commonJS((exports) => {
     CUSTOM_TYPE() {
       return false;
     },
-    NAMED_ENUM(schema8) {
-      return "enum" in schema8 && "tsEnumNames" in schema8;
+    NAMED_ENUM(schema9) {
+      return "enum" in schema9 && "tsEnumNames" in schema9;
     },
-    NAMED_SCHEMA(schema8) {
-      return "$id" in schema8 && (("patternProperties" in schema8) || ("properties" in schema8));
+    NAMED_SCHEMA(schema9) {
+      return "$id" in schema9 && (("patternProperties" in schema9) || ("properties" in schema9));
     },
-    NEVER(schema8) {
-      return schema8 === false;
+    NEVER(schema9) {
+      return schema9 === false;
     },
-    NULL(schema8) {
-      return schema8.type === "null";
+    NULL(schema9) {
+      return schema9.type === "null";
     },
-    NUMBER(schema8) {
-      if ("enum" in schema8) {
+    NUMBER(schema9) {
+      if ("enum" in schema9) {
         return false;
       }
-      if (schema8.type === "integer" || schema8.type === "number") {
+      if (schema9.type === "integer" || schema9.type === "number") {
         return true;
       }
-      if (!(0, JSONSchema_1.isCompound)(schema8) && typeof schema8.default === "number") {
+      if (!(0, JSONSchema_1.isCompound)(schema9) && typeof schema9.default === "number") {
         return true;
       }
       return false;
     },
-    OBJECT(schema8) {
-      return schema8.type === "object" && !(0, lodash_1.isPlainObject)(schema8.additionalProperties) && !schema8.allOf && !schema8.anyOf && !schema8.oneOf && !schema8.patternProperties && !schema8.properties && !schema8.required;
+    OBJECT(schema9) {
+      return schema9.type === "object" && !(0, lodash_1.isPlainObject)(schema9.additionalProperties) && !schema9.allOf && !schema9.anyOf && !schema9.oneOf && !schema9.patternProperties && !schema9.properties && !schema9.required;
     },
-    ONE_OF(schema8) {
-      return "oneOf" in schema8;
+    ONE_OF(schema9) {
+      return "oneOf" in schema9;
     },
-    REFERENCE(schema8) {
-      return "$ref" in schema8;
+    REFERENCE(schema9) {
+      return "$ref" in schema9;
     },
-    STRING(schema8) {
-      if ("enum" in schema8) {
+    STRING(schema9) {
+      if ("enum" in schema9) {
         return false;
       }
-      if (schema8.type === "string") {
+      if (schema9.type === "string") {
         return true;
       }
-      if (!(0, JSONSchema_1.isCompound)(schema8) && typeof schema8.default === "string") {
+      if (!(0, JSONSchema_1.isCompound)(schema9) && typeof schema9.default === "string") {
         return true;
       }
       return false;
     },
-    TYPED_ARRAY(schema8) {
-      if (schema8.type && schema8.type !== "array") {
+    TYPED_ARRAY(schema9) {
+      if (schema9.type && schema9.type !== "array") {
         return false;
       }
-      return "items" in schema8;
+      return "items" in schema9;
     },
-    UNION(schema8) {
-      return Array.isArray(schema8.type);
+    UNION(schema9) {
+      return Array.isArray(schema9.type);
     },
-    UNNAMED_ENUM(schema8) {
-      if ("tsEnumNames" in schema8) {
+    UNNAMED_ENUM(schema9) {
+      if ("tsEnumNames" in schema9) {
         return false;
       }
-      if (schema8.type && schema8.type !== "boolean" && schema8.type !== "integer" && schema8.type !== "number" && schema8.type !== "string") {
+      if (schema9.type && schema9.type !== "boolean" && schema9.type !== "integer" && schema9.type !== "number" && schema9.type !== "string") {
         return false;
       }
-      return "enum" in schema8;
+      return "enum" in schema9;
     },
     UNNAMED_SCHEMA() {
       return false;
     },
-    UNTYPED_ARRAY(schema8) {
-      return schema8.type === "array" && !("items" in schema8);
+    UNTYPED_ARRAY(schema9) {
+      return schema9.type === "array" && !("items" in schema9);
     }
   };
 });
@@ -130714,10 +131106,10 @@ var require_applySchemaTyping = __commonJS((exports) => {
   exports.applySchemaTyping = undefined;
   var JSONSchema_1 = require_JSONSchema();
   var typesOfSchema_1 = require_typesOfSchema();
-  function applySchemaTyping(schema8) {
+  function applySchemaTyping(schema9) {
     var _a7;
-    const types = (0, typesOfSchema_1.typesOfSchema)(schema8);
-    Object.defineProperty(schema8, JSONSchema_1.Types, {
+    const types = (0, typesOfSchema_1.typesOfSchema)(schema9);
+    Object.defineProperty(schema9, JSONSchema_1.Types, {
       enumerable: false,
       value: types,
       writable: false
@@ -130726,23 +131118,23 @@ var require_applySchemaTyping = __commonJS((exports) => {
       return;
     }
     const intersection2 = {
-      [JSONSchema_1.Parent]: schema8,
+      [JSONSchema_1.Parent]: schema9,
       [JSONSchema_1.Types]: new Set(["ALL_OF"]),
-      $id: schema8.$id,
-      description: schema8.description,
-      name: schema8.name,
-      title: schema8.title,
-      allOf: (_a7 = schema8.allOf) !== null && _a7 !== undefined ? _a7 : [],
+      $id: schema9.$id,
+      description: schema9.description,
+      name: schema9.name,
+      title: schema9.title,
+      allOf: (_a7 = schema9.allOf) !== null && _a7 !== undefined ? _a7 : [],
       required: [],
       additionalProperties: false
     };
     types.delete("ALL_OF");
-    delete schema8.allOf;
-    delete schema8.$id;
-    delete schema8.description;
-    delete schema8.name;
-    delete schema8.title;
-    Object.defineProperty(schema8, JSONSchema_1.Intersection, {
+    delete schema9.allOf;
+    delete schema9.$id;
+    delete schema9.description;
+    delete schema9.name;
+    delete schema9.title;
+    Object.defineProperty(schema9, JSONSchema_1.Intersection, {
       enumerable: false,
       value: intersection2,
       writable: false
@@ -130760,186 +131152,186 @@ var require_normalizer = __commonJS((exports) => {
   var applySchemaTyping_1 = require_applySchemaTyping();
   var util_1 = __require("util");
   var rules = new Map;
-  function hasType(schema8, type) {
-    return schema8.type === type || Array.isArray(schema8.type) && schema8.type.includes(type);
+  function hasType(schema9, type) {
+    return schema9.type === type || Array.isArray(schema9.type) && schema9.type.includes(type);
   }
-  function isObjectType(schema8) {
-    return schema8.properties !== undefined || hasType(schema8, "object") || hasType(schema8, "any");
+  function isObjectType(schema9) {
+    return schema9.properties !== undefined || hasType(schema9, "object") || hasType(schema9, "any");
   }
-  function isArrayType(schema8) {
-    return schema8.items !== undefined || hasType(schema8, "array") || hasType(schema8, "any");
+  function isArrayType(schema9) {
+    return schema9.items !== undefined || hasType(schema9, "array") || hasType(schema9, "any");
   }
-  function isEnumTypeWithoutTsEnumNames(schema8) {
-    return schema8.type === "string" && schema8.enum !== undefined && schema8.tsEnumNames === undefined;
+  function isEnumTypeWithoutTsEnumNames(schema9) {
+    return schema9.type === "string" && schema9.enum !== undefined && schema9.tsEnumNames === undefined;
   }
-  rules.set('Remove `type=["null"]` if `enum=[null]`', (schema8) => {
-    if (Array.isArray(schema8.enum) && schema8.enum.some((e8) => e8 === null) && Array.isArray(schema8.type) && schema8.type.includes("null")) {
-      schema8.type = schema8.type.filter((type) => type !== "null");
+  rules.set('Remove `type=["null"]` if `enum=[null]`', (schema9) => {
+    if (Array.isArray(schema9.enum) && schema9.enum.some((e8) => e8 === null) && Array.isArray(schema9.type) && schema9.type.includes("null")) {
+      schema9.type = schema9.type.filter((type) => type !== "null");
     }
   });
-  rules.set("Destructure unary types", (schema8) => {
-    if (schema8.type && Array.isArray(schema8.type) && schema8.type.length === 1) {
-      schema8.type = schema8.type[0];
+  rules.set("Destructure unary types", (schema9) => {
+    if (schema9.type && Array.isArray(schema9.type) && schema9.type.length === 1) {
+      schema9.type = schema9.type[0];
     }
   });
-  rules.set("Add empty `required` property if none is defined", (schema8) => {
-    if (isObjectType(schema8) && !("required" in schema8)) {
-      schema8.required = [];
+  rules.set("Add empty `required` property if none is defined", (schema9) => {
+    if (isObjectType(schema9) && !("required" in schema9)) {
+      schema9.required = [];
     }
   });
-  rules.set("Transform `required`=false to `required`=[]", (schema8) => {
-    if (schema8.required === false) {
-      schema8.required = [];
+  rules.set("Transform `required`=false to `required`=[]", (schema9) => {
+    if (schema9.required === false) {
+      schema9.required = [];
     }
   });
-  rules.set("Default additionalProperties", (schema8, _10, options8) => {
-    if (isObjectType(schema8) && !("additionalProperties" in schema8) && schema8.patternProperties === undefined) {
-      schema8.additionalProperties = options8.additionalProperties;
+  rules.set("Default additionalProperties", (schema9, _10, options8) => {
+    if (isObjectType(schema9) && !("additionalProperties" in schema9) && schema9.patternProperties === undefined) {
+      schema9.additionalProperties = options8.additionalProperties;
     }
   });
-  rules.set("Transform id to $id", (schema8, fileName) => {
-    if (!(0, utils_1.isSchemaLike)(schema8)) {
+  rules.set("Transform id to $id", (schema9, fileName) => {
+    if (!(0, utils_1.isSchemaLike)(schema9)) {
       return;
     }
-    if (schema8.id && schema8.$id && schema8.id !== schema8.$id) {
-      throw ReferenceError(`Schema must define either id or $id, not both. Given id=${schema8.id}, $id=${schema8.$id} in ${fileName}`);
+    if (schema9.id && schema9.$id && schema9.id !== schema9.$id) {
+      throw ReferenceError(`Schema must define either id or $id, not both. Given id=${schema9.id}, $id=${schema9.$id} in ${fileName}`);
     }
-    if (schema8.id) {
-      schema8.$id = schema8.id;
-      delete schema8.id;
+    if (schema9.id) {
+      schema9.$id = schema9.id;
+      delete schema9.id;
     }
   });
-  rules.set("Add an $id to anything that needs it", (schema8, fileName, _options, _key, dereferencedPaths) => {
-    if (!(0, utils_1.isSchemaLike)(schema8)) {
+  rules.set("Add an $id to anything that needs it", (schema9, fileName, _options, _key, dereferencedPaths) => {
+    if (!(0, utils_1.isSchemaLike)(schema9)) {
       return;
     }
-    if (!schema8.$id && !schema8[JSONSchema_1.Parent]) {
-      schema8.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(fileName));
+    if (!schema9.$id && !schema9[JSONSchema_1.Parent]) {
+      schema9.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(fileName));
       return;
     }
-    if (!isArrayType(schema8) && !isObjectType(schema8)) {
+    if (!isArrayType(schema9) && !isObjectType(schema9)) {
       return;
     }
-    const dereferencedName = dereferencedPaths.get(schema8);
-    if (!schema8.$id && !schema8.title && dereferencedName) {
-      schema8.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(dereferencedName));
+    const dereferencedName = dereferencedPaths.get(schema9);
+    if (!schema9.$id && !schema9.title && dereferencedName) {
+      schema9.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(dereferencedName));
     }
     if (dereferencedName) {
-      dereferencedPaths.delete(schema8);
+      dereferencedPaths.delete(schema9);
     }
   });
-  rules.set("Escape closing JSDoc comment", (schema8) => {
-    (0, utils_1.escapeBlockComment)(schema8);
+  rules.set("Escape closing JSDoc comment", (schema9) => {
+    (0, utils_1.escapeBlockComment)(schema9);
   });
-  rules.set("Add JSDoc comments for minItems and maxItems", (schema8) => {
-    if (!isArrayType(schema8)) {
+  rules.set("Add JSDoc comments for minItems and maxItems", (schema9) => {
+    if (!isArrayType(schema9)) {
       return;
     }
     const commentsToAppend = [
-      "minItems" in schema8 ? `@minItems ${schema8.minItems}` : "",
-      "maxItems" in schema8 ? `@maxItems ${schema8.maxItems}` : ""
+      "minItems" in schema9 ? `@minItems ${schema9.minItems}` : "",
+      "maxItems" in schema9 ? `@maxItems ${schema9.maxItems}` : ""
     ].filter(Boolean);
     if (commentsToAppend.length) {
-      schema8.description = (0, utils_1.appendToDescription)(schema8.description, ...commentsToAppend);
+      schema9.description = (0, utils_1.appendToDescription)(schema9.description, ...commentsToAppend);
     }
   });
-  rules.set("Optionally remove maxItems and minItems", (schema8, _fileName, options8) => {
-    if (!isArrayType(schema8)) {
+  rules.set("Optionally remove maxItems and minItems", (schema9, _fileName, options8) => {
+    if (!isArrayType(schema9)) {
       return;
     }
-    if ("minItems" in schema8 && options8.ignoreMinAndMaxItems) {
-      delete schema8.minItems;
+    if ("minItems" in schema9 && options8.ignoreMinAndMaxItems) {
+      delete schema9.minItems;
     }
-    if ("maxItems" in schema8 && (options8.ignoreMinAndMaxItems || options8.maxItems === -1)) {
-      delete schema8.maxItems;
+    if ("maxItems" in schema9 && (options8.ignoreMinAndMaxItems || options8.maxItems === -1)) {
+      delete schema9.maxItems;
     }
   });
-  rules.set("Normalize schema.minItems", (schema8, _fileName, options8) => {
+  rules.set("Normalize schema.minItems", (schema9, _fileName, options8) => {
     if (options8.ignoreMinAndMaxItems) {
       return;
     }
-    if (!isArrayType(schema8)) {
+    if (!isArrayType(schema9)) {
       return;
     }
-    const { minItems } = schema8;
-    schema8.minItems = typeof minItems === "number" ? minItems : 0;
+    const { minItems } = schema9;
+    schema9.minItems = typeof minItems === "number" ? minItems : 0;
   });
-  rules.set("Remove maxItems if it is big enough to likely cause OOMs", (schema8, _fileName, options8) => {
+  rules.set("Remove maxItems if it is big enough to likely cause OOMs", (schema9, _fileName, options8) => {
     if (options8.ignoreMinAndMaxItems || options8.maxItems === -1) {
       return;
     }
-    if (!isArrayType(schema8)) {
+    if (!isArrayType(schema9)) {
       return;
     }
-    const { maxItems, minItems } = schema8;
+    const { maxItems, minItems } = schema9;
     if (maxItems !== undefined && maxItems - minItems > options8.maxItems) {
-      delete schema8.maxItems;
+      delete schema9.maxItems;
     }
   });
-  rules.set("Normalize schema.items", (schema8, _fileName, options8) => {
+  rules.set("Normalize schema.items", (schema9, _fileName, options8) => {
     if (options8.ignoreMinAndMaxItems) {
       return;
     }
-    const { maxItems, minItems } = schema8;
+    const { maxItems, minItems } = schema9;
     const hasMaxItems = typeof maxItems === "number" && maxItems >= 0;
     const hasMinItems = typeof minItems === "number" && minItems > 0;
-    if (schema8.items && !Array.isArray(schema8.items) && (hasMaxItems || hasMinItems)) {
-      const items = schema8.items;
+    if (schema9.items && !Array.isArray(schema9.items) && (hasMaxItems || hasMinItems)) {
+      const items = schema9.items;
       const newItems = Array(maxItems || minItems || 0).fill(items);
       if (!hasMaxItems) {
-        schema8.additionalItems = items;
+        schema9.additionalItems = items;
       }
-      schema8.items = newItems;
+      schema9.items = newItems;
     }
-    if (Array.isArray(schema8.items) && hasMaxItems && maxItems < schema8.items.length) {
-      schema8.items = schema8.items.slice(0, maxItems);
+    if (Array.isArray(schema9.items) && hasMaxItems && maxItems < schema9.items.length) {
+      schema9.items = schema9.items.slice(0, maxItems);
     }
-    return schema8;
+    return schema9;
   });
-  rules.set("Remove extends, if it is empty", (schema8) => {
-    if (!schema8.hasOwnProperty("extends")) {
+  rules.set("Remove extends, if it is empty", (schema9) => {
+    if (!schema9.hasOwnProperty("extends")) {
       return;
     }
-    if (schema8.extends == null || Array.isArray(schema8.extends) && schema8.extends.length === 0) {
-      delete schema8.extends;
+    if (schema9.extends == null || Array.isArray(schema9.extends) && schema9.extends.length === 0) {
+      delete schema9.extends;
     }
   });
-  rules.set("Make extends always an array, if it is defined", (schema8) => {
-    if (schema8.extends == null) {
+  rules.set("Make extends always an array, if it is defined", (schema9) => {
+    if (schema9.extends == null) {
       return;
     }
-    if (!Array.isArray(schema8.extends)) {
-      schema8.extends = [schema8.extends];
+    if (!Array.isArray(schema9.extends)) {
+      schema9.extends = [schema9.extends];
     }
   });
-  rules.set("Transform definitions to $defs", (schema8, fileName) => {
-    if (schema8.definitions && schema8.$defs && !(0, util_1.isDeepStrictEqual)(schema8.definitions, schema8.$defs)) {
-      throw ReferenceError(`Schema must define either definitions or $defs, not both. Given id=${schema8.id} in ${fileName}`);
+  rules.set("Transform definitions to $defs", (schema9, fileName) => {
+    if (schema9.definitions && schema9.$defs && !(0, util_1.isDeepStrictEqual)(schema9.definitions, schema9.$defs)) {
+      throw ReferenceError(`Schema must define either definitions or $defs, not both. Given id=${schema9.id} in ${fileName}`);
     }
-    if (schema8.definitions) {
-      schema8.$defs = schema8.definitions;
-      delete schema8.definitions;
+    if (schema9.definitions) {
+      schema9.$defs = schema9.definitions;
+      delete schema9.definitions;
     }
   });
-  rules.set("Transform const to singleton enum", (schema8) => {
-    if (schema8.const !== undefined) {
-      schema8.enum = [schema8.const];
-      delete schema8.const;
+  rules.set("Transform const to singleton enum", (schema9) => {
+    if (schema9.const !== undefined) {
+      schema9.enum = [schema9.const];
+      delete schema9.const;
     }
   });
-  rules.set("Add tsEnumNames to enum types", (schema8, _10, options8) => {
+  rules.set("Add tsEnumNames to enum types", (schema9, _10, options8) => {
     var _a7;
-    if (isEnumTypeWithoutTsEnumNames(schema8) && options8.inferStringEnumKeysFromValues) {
-      schema8.tsEnumNames = (_a7 = schema8.enum) === null || _a7 === undefined ? undefined : _a7.map(String);
+    if (isEnumTypeWithoutTsEnumNames(schema9) && options8.inferStringEnumKeysFromValues) {
+      schema9.tsEnumNames = (_a7 = schema9.enum) === null || _a7 === undefined ? undefined : _a7.map(String);
     }
   });
-  rules.set("Pre-calculate schema types and intersections", (schema8) => {
-    if (schema8 !== null && typeof schema8 === "object") {
-      (0, applySchemaTyping_1.applySchemaTyping)(schema8);
+  rules.set("Pre-calculate schema types and intersections", (schema9) => {
+    if (schema9 !== null && typeof schema9 === "object") {
+      (0, applySchemaTyping_1.applySchemaTyping)(schema9);
     }
   });
   function normalize(rootSchema, dereferencedPaths, filename, options8) {
-    rules.forEach((rule) => (0, utils_1.traverse)(rootSchema, (schema8, key2) => rule(schema8, filename, options8, key2, dereferencedPaths)));
+    rules.forEach((rule) => (0, utils_1.traverse)(rootSchema, (schema9, key2) => rule(schema9, filename, options8, key2, dereferencedPaths)));
     return rootSchema;
   }
   exports.normalize = normalize;
@@ -131021,37 +131413,37 @@ var require_parser = __commonJS((exports) => {
   var AST_1 = require_AST();
   var JSONSchema_1 = require_JSONSchema();
   var utils_1 = require_utils7();
-  function parse10(schema8, options8, keyName, processed = new Map, usedNames = new Set) {
-    if ((0, JSONSchema_1.isPrimitive)(schema8)) {
-      if ((0, JSONSchema_1.isBoolean)(schema8)) {
-        return parseBooleanSchema(schema8, keyName, options8);
+  function parse11(schema9, options8, keyName, processed = new Map, usedNames = new Set) {
+    if ((0, JSONSchema_1.isPrimitive)(schema9)) {
+      if ((0, JSONSchema_1.isBoolean)(schema9)) {
+        return parseBooleanSchema(schema9, keyName, options8);
       }
-      return parseLiteral(schema8, keyName);
+      return parseLiteral(schema9, keyName);
     }
-    const intersection2 = schema8[JSONSchema_1.Intersection];
-    const types = schema8[JSONSchema_1.Types];
+    const intersection2 = schema9[JSONSchema_1.Intersection];
+    const types = schema9[JSONSchema_1.Types];
     if (intersection2) {
       const ast = parseAsTypeWithCache(intersection2, "ALL_OF", options8, keyName, processed, usedNames);
       types.forEach((type) => {
-        ast.params.push(parseAsTypeWithCache(schema8, type, options8, keyName, processed, usedNames));
+        ast.params.push(parseAsTypeWithCache(schema9, type, options8, keyName, processed, usedNames));
       });
-      (0, utils_1.log)("blue", "parser", "Types:", [...types], "Input:", schema8, "Output:", ast);
+      (0, utils_1.log)("blue", "parser", "Types:", [...types], "Input:", schema9, "Output:", ast);
       return ast;
     }
     if (types.size === 1) {
       const type = [...types][0];
-      const ast = parseAsTypeWithCache(schema8, type, options8, keyName, processed, usedNames);
-      (0, utils_1.log)("blue", "parser", "Type:", type, "Input:", schema8, "Output:", ast);
+      const ast = parseAsTypeWithCache(schema9, type, options8, keyName, processed, usedNames);
+      (0, utils_1.log)("blue", "parser", "Type:", type, "Input:", schema9, "Output:", ast);
       return ast;
     }
     throw new ReferenceError("Expected intersection schema. Please file an issue on GitHub.");
   }
-  exports.parse = parse10;
-  function parseAsTypeWithCache(schema8, type, options8, keyName, processed = new Map, usedNames = new Set) {
-    let cachedTypeMap = processed.get(schema8);
+  exports.parse = parse11;
+  function parseAsTypeWithCache(schema9, type, options8, keyName, processed = new Map, usedNames = new Set) {
+    let cachedTypeMap = processed.get(schema9);
     if (!cachedTypeMap) {
       cachedTypeMap = new Map;
-      processed.set(schema8, cachedTypeMap);
+      processed.set(schema9, cachedTypeMap);
     }
     const cachedAST = cachedTypeMap.get(type);
     if (cachedAST) {
@@ -131059,10 +131451,10 @@ var require_parser = __commonJS((exports) => {
     }
     const ast = {};
     cachedTypeMap.set(type, ast);
-    return Object.assign(ast, parseNonLiteral(schema8, type, options8, keyName, processed, usedNames));
+    return Object.assign(ast, parseNonLiteral(schema9, type, options8, keyName, processed, usedNames));
   }
-  function parseBooleanSchema(schema8, keyName, options8) {
-    if (schema8) {
+  function parseBooleanSchema(schema9, keyName, options8) {
+    if (schema9) {
       return {
         keyName,
         type: options8.unknownAny ? "UNKNOWN" : "ANY"
@@ -131073,240 +131465,240 @@ var require_parser = __commonJS((exports) => {
       type: "NEVER"
     };
   }
-  function parseLiteral(schema8, keyName) {
+  function parseLiteral(schema9, keyName) {
     return {
       keyName,
-      params: schema8,
+      params: schema9,
       type: "LITERAL"
     };
   }
-  function parseNonLiteral(schema8, type, options8, keyName, processed, usedNames) {
-    const definitions = getDefinitionsMemoized((0, JSONSchema_1.getRootSchema)(schema8));
-    const keyNameFromDefinition = (0, lodash_1.findKey)(definitions, (_10) => _10 === schema8);
+  function parseNonLiteral(schema9, type, options8, keyName, processed, usedNames) {
+    const definitions = getDefinitionsMemoized((0, JSONSchema_1.getRootSchema)(schema9));
+    const keyNameFromDefinition = (0, lodash_1.findKey)(definitions, (_10) => _10 === schema9);
     switch (type) {
       case "ALL_OF":
         return {
-          comment: schema8.description,
-          deprecated: schema8.deprecated,
+          comment: schema9.description,
+          deprecated: schema9.deprecated,
           keyName,
-          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
-          params: schema8.allOf.map((_10) => parse10(_10, options8, undefined, processed, usedNames)),
+          standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
+          params: schema9.allOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
           type: "INTERSECTION"
         };
       case "ANY":
-        return Object.assign(Object.assign({}, options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY), { comment: schema8.description, deprecated: schema8.deprecated, keyName, standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8) });
+        return Object.assign(Object.assign({}, options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY), { comment: schema9.description, deprecated: schema9.deprecated, keyName, standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8) });
       case "ANY_OF":
         return {
-          comment: schema8.description,
-          deprecated: schema8.deprecated,
+          comment: schema9.description,
+          deprecated: schema9.deprecated,
           keyName,
-          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
-          params: schema8.anyOf.map((_10) => parse10(_10, options8, undefined, processed, usedNames)),
+          standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
+          params: schema9.anyOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
           type: "UNION"
         };
       case "BOOLEAN":
         return {
-          comment: schema8.description,
-          deprecated: schema8.deprecated,
+          comment: schema9.description,
+          deprecated: schema9.deprecated,
           keyName,
-          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
           type: "BOOLEAN"
         };
       case "CUSTOM_TYPE":
         return {
-          comment: schema8.description,
-          deprecated: schema8.deprecated,
+          comment: schema9.description,
+          deprecated: schema9.deprecated,
           keyName,
-          params: schema8.tsType,
-          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
+          params: schema9.tsType,
+          standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
           type: "CUSTOM_TYPE"
         };
       case "NAMED_ENUM":
         return {
-          comment: schema8.description,
-          deprecated: schema8.deprecated,
+          comment: schema9.description,
+          deprecated: schema9.deprecated,
           keyName,
-          standaloneName: standaloneName(schema8, keyNameFromDefinition !== null && keyNameFromDefinition !== undefined ? keyNameFromDefinition : keyName, usedNames, options8),
-          params: schema8.enum.map((_10, n5) => ({
+          standaloneName: standaloneName(schema9, keyNameFromDefinition !== null && keyNameFromDefinition !== undefined ? keyNameFromDefinition : keyName, usedNames, options8),
+          params: schema9.enum.map((_10, n5) => ({
             ast: parseLiteral(_10, undefined),
-            keyName: schema8.tsEnumNames[n5]
+            keyName: schema9.tsEnumNames[n5]
           })),
           type: "ENUM"
         };
       case "NAMED_SCHEMA":
-        return newInterface(schema8, options8, processed, usedNames, keyName);
+        return newInterface(schema9, options8, processed, usedNames, keyName);
       case "NEVER":
         return {
-          comment: schema8.description,
-          deprecated: schema8.deprecated,
+          comment: schema9.description,
+          deprecated: schema9.deprecated,
           keyName,
-          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
           type: "NEVER"
         };
       case "NULL":
         return {
-          comment: schema8.description,
-          deprecated: schema8.deprecated,
+          comment: schema9.description,
+          deprecated: schema9.deprecated,
           keyName,
-          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
           type: "NULL"
         };
       case "NUMBER":
         return {
-          comment: schema8.description,
-          deprecated: schema8.deprecated,
+          comment: schema9.description,
+          deprecated: schema9.deprecated,
           keyName,
-          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
           type: "NUMBER"
         };
       case "OBJECT":
         return {
-          comment: schema8.description,
+          comment: schema9.description,
           keyName,
-          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
           type: "OBJECT",
-          deprecated: schema8.deprecated
+          deprecated: schema9.deprecated
         };
       case "ONE_OF":
         return {
-          comment: schema8.description,
-          deprecated: schema8.deprecated,
+          comment: schema9.description,
+          deprecated: schema9.deprecated,
           keyName,
-          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
-          params: schema8.oneOf.map((_10) => parse10(_10, options8, undefined, processed, usedNames)),
+          standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
+          params: schema9.oneOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
           type: "UNION"
         };
       case "REFERENCE":
-        throw Error((0, util_1.format)("Refs should have been resolved by the resolver!", schema8));
+        throw Error((0, util_1.format)("Refs should have been resolved by the resolver!", schema9));
       case "STRING":
         return {
-          comment: schema8.description,
-          deprecated: schema8.deprecated,
+          comment: schema9.description,
+          deprecated: schema9.deprecated,
           keyName,
-          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
           type: "STRING"
         };
       case "TYPED_ARRAY":
-        if (Array.isArray(schema8.items)) {
-          const minItems2 = schema8.minItems;
-          const maxItems2 = schema8.maxItems;
+        if (Array.isArray(schema9.items)) {
+          const minItems2 = schema9.minItems;
+          const maxItems2 = schema9.maxItems;
           const arrayType = {
-            comment: schema8.description,
-            deprecated: schema8.deprecated,
+            comment: schema9.description,
+            deprecated: schema9.deprecated,
             keyName,
             maxItems: maxItems2,
             minItems: minItems2,
-            standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
-            params: schema8.items.map((_10) => parse10(_10, options8, undefined, processed, usedNames)),
+            standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
+            params: schema9.items.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
             type: "TUPLE"
           };
-          if (schema8.additionalItems === true) {
+          if (schema9.additionalItems === true) {
             arrayType.spreadParam = options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY;
-          } else if (schema8.additionalItems) {
-            arrayType.spreadParam = parse10(schema8.additionalItems, options8, undefined, processed, usedNames);
+          } else if (schema9.additionalItems) {
+            arrayType.spreadParam = parse11(schema9.additionalItems, options8, undefined, processed, usedNames);
           }
           return arrayType;
         } else {
           return {
-            comment: schema8.description,
-            deprecated: schema8.deprecated,
+            comment: schema9.description,
+            deprecated: schema9.deprecated,
             keyName,
-            standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
-            params: parse10(schema8.items, options8, `{keyNameFromDefinition}Items`, processed, usedNames),
+            standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
+            params: parse11(schema9.items, options8, `{keyNameFromDefinition}Items`, processed, usedNames),
             type: "ARRAY"
           };
         }
       case "UNION":
         return {
-          comment: schema8.description,
-          deprecated: schema8.deprecated,
+          comment: schema9.description,
+          deprecated: schema9.deprecated,
           keyName,
-          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
-          params: schema8.type.map((type2) => {
-            const member = Object.assign(Object.assign({}, (0, lodash_1.omit)(schema8, "$id", "description", "title")), { type: type2 });
+          standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
+          params: schema9.type.map((type2) => {
+            const member = Object.assign(Object.assign({}, (0, lodash_1.omit)(schema9, "$id", "description", "title")), { type: type2 });
             (0, utils_1.maybeStripDefault)(member);
             (0, applySchemaTyping_1.applySchemaTyping)(member);
-            return parse10(member, options8, undefined, processed, usedNames);
+            return parse11(member, options8, undefined, processed, usedNames);
           }),
           type: "UNION"
         };
       case "UNNAMED_ENUM":
         return {
-          comment: schema8.description,
-          deprecated: schema8.deprecated,
+          comment: schema9.description,
+          deprecated: schema9.deprecated,
           keyName,
-          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
-          params: schema8.enum.map((_10) => parseLiteral(_10, undefined)),
+          standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
+          params: schema9.enum.map((_10) => parseLiteral(_10, undefined)),
           type: "UNION"
         };
       case "UNNAMED_SCHEMA":
-        return newInterface(schema8, options8, processed, usedNames, keyName, keyNameFromDefinition);
+        return newInterface(schema9, options8, processed, usedNames, keyName, keyNameFromDefinition);
       case "UNTYPED_ARRAY":
-        const minItems = schema8.minItems;
-        const maxItems = typeof schema8.maxItems === "number" ? schema8.maxItems : -1;
+        const minItems = schema9.minItems;
+        const maxItems = typeof schema9.maxItems === "number" ? schema9.maxItems : -1;
         const params = options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY;
         if (minItems > 0 || maxItems >= 0) {
           return {
-            comment: schema8.description,
-            deprecated: schema8.deprecated,
+            comment: schema9.description,
+            deprecated: schema9.deprecated,
             keyName,
-            maxItems: schema8.maxItems,
+            maxItems: schema9.maxItems,
             minItems,
             params: Array(Math.max(maxItems, minItems) || 0).fill(params),
             spreadParam: maxItems >= 0 ? undefined : params,
-            standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
+            standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
             type: "TUPLE"
           };
         }
         return {
-          comment: schema8.description,
-          deprecated: schema8.deprecated,
+          comment: schema9.description,
+          deprecated: schema9.deprecated,
           keyName,
           params,
-          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
           type: "ARRAY"
         };
     }
   }
-  function standaloneName(schema8, keyNameFromDefinition, usedNames, options8) {
+  function standaloneName(schema9, keyNameFromDefinition, usedNames, options8) {
     var _a7;
-    const name2 = ((_a7 = options8.customName) === null || _a7 === undefined ? undefined : _a7.call(options8, schema8, keyNameFromDefinition)) || schema8.title || schema8.$id || keyNameFromDefinition;
+    const name2 = ((_a7 = options8.customName) === null || _a7 === undefined ? undefined : _a7.call(options8, schema9, keyNameFromDefinition)) || schema9.title || schema9.$id || keyNameFromDefinition;
     if (name2) {
       return (0, utils_1.generateName)(name2, usedNames);
     }
   }
-  function newInterface(schema8, options8, processed, usedNames, keyName, keyNameFromDefinition) {
-    const name2 = standaloneName(schema8, keyNameFromDefinition, usedNames, options8);
+  function newInterface(schema9, options8, processed, usedNames, keyName, keyNameFromDefinition) {
+    const name2 = standaloneName(schema9, keyNameFromDefinition, usedNames, options8);
     return {
-      comment: schema8.description,
-      deprecated: schema8.deprecated,
+      comment: schema9.description,
+      deprecated: schema9.deprecated,
       keyName,
-      params: parseSchema(schema8, options8, processed, usedNames, name2),
+      params: parseSchema(schema9, options8, processed, usedNames, name2),
       standaloneName: name2,
-      superTypes: parseSuperTypes(schema8, options8, processed, usedNames),
+      superTypes: parseSuperTypes(schema9, options8, processed, usedNames),
       type: "INTERFACE"
     };
   }
-  function parseSuperTypes(schema8, options8, processed, usedNames) {
-    const superTypes = schema8.extends;
+  function parseSuperTypes(schema9, options8, processed, usedNames) {
+    const superTypes = schema9.extends;
     if (!superTypes) {
       return [];
     }
-    return superTypes.map((_10) => parse10(_10, options8, undefined, processed, usedNames));
+    return superTypes.map((_10) => parse11(_10, options8, undefined, processed, usedNames));
   }
-  function parseSchema(schema8, options8, processed, usedNames, parentSchemaName) {
-    let asts = (0, lodash_1.map)(schema8.properties, (value, key2) => ({
-      ast: parse10(value, options8, key2, processed, usedNames),
+  function parseSchema(schema9, options8, processed, usedNames, parentSchemaName) {
+    let asts = (0, lodash_1.map)(schema9.properties, (value, key2) => ({
+      ast: parse11(value, options8, key2, processed, usedNames),
       isPatternProperty: false,
-      isRequired: (0, lodash_1.includes)(schema8.required || [], key2),
+      isRequired: (0, lodash_1.includes)(schema9.required || [], key2),
       isUnreachableDefinition: false,
       keyName: key2
     }));
     let singlePatternProperty = false;
-    if (schema8.patternProperties) {
-      singlePatternProperty = !schema8.additionalProperties && Object.keys(schema8.patternProperties).length === 1;
-      asts = asts.concat((0, lodash_1.map)(schema8.patternProperties, (value, key2) => {
-        const ast = parse10(value, options8, key2, processed, usedNames);
+    if (schema9.patternProperties) {
+      singlePatternProperty = !schema9.additionalProperties && Object.keys(schema9.patternProperties).length === 1;
+      asts = asts.concat((0, lodash_1.map)(schema9.patternProperties, (value, key2) => {
+        const ast = parse11(value, options8, key2, processed, usedNames);
         const comment = `This interface was referenced by \`${parentSchemaName}\`'s JSON-Schema definition
 via the \`patternProperty\` "${key2.replace("*/", "*\\/")}".`;
         ast.comment = ast.comment ? `${ast.comment}
@@ -131315,15 +131707,15 @@ ${comment}` : comment;
         return {
           ast,
           isPatternProperty: !singlePatternProperty,
-          isRequired: singlePatternProperty || (0, lodash_1.includes)(schema8.required || [], key2),
+          isRequired: singlePatternProperty || (0, lodash_1.includes)(schema9.required || [], key2),
           isUnreachableDefinition: false,
           keyName: singlePatternProperty ? "[k: string]" : key2
         };
       }));
     }
     if (options8.unreachableDefinitions) {
-      asts = asts.concat((0, lodash_1.map)(schema8.$defs, (value, key2) => {
-        const ast = parse10(value, options8, key2, processed, usedNames);
+      asts = asts.concat((0, lodash_1.map)(schema9.$defs, (value, key2) => {
+        const ast = parse11(value, options8, key2, processed, usedNames);
         const comment = `This interface was referenced by \`${parentSchemaName}\`'s JSON-Schema
 via the \`definition\` "${key2}".`;
         ast.comment = ast.comment ? `${ast.comment}
@@ -131332,13 +131724,13 @@ ${comment}` : comment;
         return {
           ast,
           isPatternProperty: false,
-          isRequired: (0, lodash_1.includes)(schema8.required || [], key2),
+          isRequired: (0, lodash_1.includes)(schema9.required || [], key2),
           isUnreachableDefinition: true,
           keyName: key2
         };
       }));
     }
-    switch (schema8.additionalProperties) {
+    switch (schema9.additionalProperties) {
       case undefined:
       case true:
         if (singlePatternProperty) {
@@ -131355,7 +131747,7 @@ ${comment}` : comment;
         return asts;
       default:
         return asts.concat({
-          ast: parse10(schema8.additionalProperties, options8, "[k: string]", processed, usedNames),
+          ast: parse11(schema9.additionalProperties, options8, "[k: string]", processed, usedNames),
           isPatternProperty: false,
           isRequired: true,
           isUnreachableDefinition: false,
@@ -131363,22 +131755,22 @@ ${comment}` : comment;
         });
     }
   }
-  function getDefinitions(schema8, isSchema = true, processed = new Set) {
-    if (processed.has(schema8)) {
+  function getDefinitions(schema9, isSchema = true, processed = new Set) {
+    if (processed.has(schema9)) {
       return {};
     }
-    processed.add(schema8);
-    if (Array.isArray(schema8)) {
-      return schema8.reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(cur, false, processed)), {});
+    processed.add(schema9);
+    if (Array.isArray(schema9)) {
+      return schema9.reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(cur, false, processed)), {});
     }
-    if ((0, lodash_1.isPlainObject)(schema8)) {
-      return Object.assign(Object.assign({}, isSchema && hasDefinitions(schema8) ? schema8.$defs : {}), Object.keys(schema8).reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(schema8[cur], false, processed)), {}));
+    if ((0, lodash_1.isPlainObject)(schema9)) {
+      return Object.assign(Object.assign({}, isSchema && hasDefinitions(schema9) ? schema9.$defs : {}), Object.keys(schema9).reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(schema9[cur], false, processed)), {}));
     }
     return {};
   }
   var getDefinitionsMemoized = (0, lodash_1.memoize)(getDefinitions);
-  function hasDefinitions(schema8) {
-    return "$defs" in schema8;
+  function hasDefinitions(schema9) {
+    return "$defs" in schema9;
   }
 });
 
@@ -131791,7 +132183,7 @@ var require_url = __commonJS((exports) => {
   };
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.parse = undefined;
-  exports.resolve = resolve5;
+  exports.resolve = resolve6;
   exports.cwd = cwd;
   exports.getProtocol = getProtocol;
   exports.getExtension = getExtension;
@@ -131817,9 +132209,9 @@ var require_url = __commonJS((exports) => {
     [/#/g, "%23"]
   ];
   var urlDecodePatterns = [/%23/g, "#", /%24/g, "$", /%26/g, "&", /%2C/g, ",", /%40/g, "@"];
-  var parse10 = (u4) => new URL(u4);
-  exports.parse = parse10;
-  function resolve5(from, to5) {
+  var parse11 = (u4) => new URL(u4);
+  exports.parse = parse11;
+  function resolve6(from, to5) {
     const fromUrl = new URL((0, convert_path_to_posix_1.default)(from), "https://aaa.nonexistanturl.com");
     const resolvedUrl = new URL((0, convert_path_to_posix_1.default)(to5), fromUrl);
     const endSpaces = to5.match(/(\s*)$/)?.[1] || "";
@@ -131955,7 +132347,7 @@ var require_url = __commonJS((exports) => {
   }
   function relative2(from, to5) {
     if (!isFileSystemPath(from) || !isFileSystemPath(to5)) {
-      return resolve5(from, to5);
+      return resolve6(from, to5);
     }
     const fromDir = path_1.default.dirname(stripHash(from));
     const toPath4 = stripHash(to5);
@@ -132631,7 +133023,7 @@ var require_plugins = __commonJS((exports) => {
     let plugin;
     let lastError;
     let index = 0;
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       runNextPlugin();
       function runNextPlugin() {
         plugin = plugins[index++];
@@ -132659,7 +133051,7 @@ var require_plugins = __commonJS((exports) => {
         }
       }
       function onSuccess(result) {
-        resolve5({
+        resolve6({
           plugin,
           result
         });
@@ -132742,7 +133134,7 @@ var require_parse6 = __commonJS((exports) => {
   var url3 = __importStar(require_url());
   var plugins = __importStar(require_plugins());
   var errors_js_1 = require_errors();
-  async function parse10(path18, $refs, options8) {
+  async function parse11(path18, $refs, options8) {
     const hashIndex = path18.indexOf("#");
     let hash2 = "";
     if (hashIndex >= 0) {
@@ -132818,7 +133210,7 @@ Parsed value is empty`);
   function isEmpty(value) {
     return value === undefined || typeof value === "object" && Object.keys(value).length === 0 || typeof value === "string" && value.trim().length === 0 || Buffer.isBuffer(value) && value.length === 0;
   }
-  exports.default = parse10;
+  exports.default = parse11;
 });
 
 // node_modules/@apidevtools/json-schema-ref-parser/dist/lib/parsers/json.js
@@ -133083,9 +133475,9 @@ var require_type3 = __commonJS((exports, module) => {
 var require_schema3 = __commonJS((exports, module) => {
   var YAMLException = require_exception3();
   var Type = require_type3();
-  function compileList(schema8, name2) {
+  function compileList(schema9, name2) {
     var result = [];
-    schema8[name2].forEach(function(currentType) {
+    schema9[name2].forEach(function(currentType) {
       var newIndex = result.length;
       result.forEach(function(previousType, previousIndex) {
         if (previousType.tag === currentType.tag && previousType.kind === currentType.kind && previousType.multi === currentType.multi) {
@@ -135030,7 +135422,7 @@ var require_dumper3 = __commonJS((exports, module) => {
     "OFF"
   ];
   var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;
-  function compileStyleMap(schema8, map2) {
+  function compileStyleMap(schema9, map2) {
     var result, keys, index, length, tag, style, type;
     if (map2 === null)
       return {};
@@ -135042,7 +135434,7 @@ var require_dumper3 = __commonJS((exports, module) => {
       if (tag.slice(0, 2) === "!!") {
         tag = "tag:yaml.org,2002:" + tag.slice(2);
       }
-      type = schema8.compiledTypeMap["fallback"][tag];
+      type = schema9.compiledTypeMap["fallback"][tag];
       if (type && _hasOwnProperty.call(type.styleAliases, style)) {
         style = type.styleAliases[style];
       }
@@ -135977,7 +136369,7 @@ var require_normalize_args = __commonJS((exports) => {
   var options_js_1 = require_options();
   function normalizeArgs(_args) {
     let path18;
-    let schema8;
+    let schema9;
     let options8;
     let callback;
     const args = Array.prototype.slice.call(_args);
@@ -135987,15 +136379,15 @@ var require_normalize_args = __commonJS((exports) => {
     if (typeof args[0] === "string") {
       path18 = args[0];
       if (typeof args[2] === "object") {
-        schema8 = args[1];
+        schema9 = args[1];
         options8 = args[2];
       } else {
-        schema8 = undefined;
+        schema9 = undefined;
         options8 = args[1];
       }
     } else {
       path18 = "";
-      schema8 = args[0];
+      schema9 = args[0];
       options8 = args[1];
     }
     try {
@@ -136003,12 +136395,12 @@ var require_normalize_args = __commonJS((exports) => {
     } catch (e8) {
       console.error(`JSON Schema Ref Parser: Error normalizing options: ${e8}`);
     }
-    if (!options8.mutateInputSchema && typeof schema8 === "object") {
-      schema8 = JSON.parse(JSON.stringify(schema8));
+    if (!options8.mutateInputSchema && typeof schema9 === "object") {
+      schema9 = JSON.parse(JSON.stringify(schema9));
     }
     return {
       path: path18,
-      schema: schema8,
+      schema: schema9,
       options: options8,
       callback
     };
@@ -136767,11 +137159,11 @@ var require_lib3 = __commonJS((exports) => {
 var require_resolver = __commonJS((exports) => {
   var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P9, generator) {
     function adopt(value) {
-      return value instanceof P9 ? value : new P9(function(resolve5) {
-        resolve5(value);
+      return value instanceof P9 ? value : new P9(function(resolve6) {
+        resolve6(value);
       });
     }
-    return new (P9 || (P9 = Promise))(function(resolve5, reject) {
+    return new (P9 || (P9 = Promise))(function(resolve6, reject) {
       function fulfilled(value) {
         try {
           step(generator.next(value));
@@ -136787,7 +137179,7 @@ var require_resolver = __commonJS((exports) => {
         }
       }
       function step(result) {
-        result.done ? resolve5(result.value) : adopt(result.value).then(fulfilled, rejected);
+        result.done ? resolve6(result.value) : adopt(result.value).then(fulfilled, rejected);
       }
       step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
@@ -136797,12 +137189,12 @@ var require_resolver = __commonJS((exports) => {
   var json_schema_ref_parser_1 = require_lib3();
   var utils_1 = require_utils7();
   function dereference(schema_1, _a7) {
-    return __awaiter(this, arguments, undefined, function* (schema8, { cwd, $refOptions }) {
-      (0, utils_1.log)("green", "dereferencer", "Dereferencing input schema:", cwd, schema8);
+    return __awaiter(this, arguments, undefined, function* (schema9, { cwd, $refOptions }) {
+      (0, utils_1.log)("green", "dereferencer", "Dereferencing input schema:", cwd, schema9);
       const parser = new json_schema_ref_parser_1.$RefParser;
       const dereferencedPaths = new WeakMap;
-      const dereferencedSchema = yield parser.dereference(cwd, schema8, Object.assign(Object.assign({}, $refOptions), { dereference: Object.assign(Object.assign({}, $refOptions.dereference), { onDereference($ref, schema9) {
-        dereferencedPaths.set(schema9, $ref);
+      const dereferencedSchema = yield parser.dereference(cwd, schema9, Object.assign(Object.assign({}, $refOptions), { dereference: Object.assign(Object.assign({}, $refOptions.dereference), { onDereference($ref, schema10) {
+        dereferencedPaths.set(schema10, $ref);
       } }) }));
       return { dereferencedPaths, dereferencedSchema };
     });
@@ -136816,46 +137208,46 @@ var require_validator = __commonJS((exports) => {
   exports.validate = undefined;
   var utils_1 = require_utils7();
   var rules = new Map;
-  rules.set("Enum members and tsEnumNames must be of the same length", (schema8) => {
-    if (schema8.enum && schema8.tsEnumNames && schema8.enum.length !== schema8.tsEnumNames.length) {
+  rules.set("Enum members and tsEnumNames must be of the same length", (schema9) => {
+    if (schema9.enum && schema9.tsEnumNames && schema9.enum.length !== schema9.tsEnumNames.length) {
       return false;
     }
   });
-  rules.set("tsEnumNames must be an array of strings", (schema8) => {
-    if (schema8.tsEnumNames && schema8.tsEnumNames.some((_10) => typeof _10 !== "string")) {
+  rules.set("tsEnumNames must be an array of strings", (schema9) => {
+    if (schema9.tsEnumNames && schema9.tsEnumNames.some((_10) => typeof _10 !== "string")) {
       return false;
     }
   });
-  rules.set("When both maxItems and minItems are present, maxItems >= minItems", (schema8) => {
-    const { maxItems, minItems } = schema8;
+  rules.set("When both maxItems and minItems are present, maxItems >= minItems", (schema9) => {
+    const { maxItems, minItems } = schema9;
     if (typeof maxItems === "number" && typeof minItems === "number") {
       return maxItems >= minItems;
     }
   });
-  rules.set("When maxItems exists, maxItems >= 0", (schema8) => {
-    const { maxItems } = schema8;
+  rules.set("When maxItems exists, maxItems >= 0", (schema9) => {
+    const { maxItems } = schema9;
     if (typeof maxItems === "number") {
       return maxItems >= 0;
     }
   });
-  rules.set("When minItems exists, minItems >= 0", (schema8) => {
-    const { minItems } = schema8;
+  rules.set("When minItems exists, minItems >= 0", (schema9) => {
+    const { minItems } = schema9;
     if (typeof minItems === "number") {
       return minItems >= 0;
     }
   });
-  rules.set("deprecated must be a boolean", (schema8) => {
-    const typeOfDeprecated = typeof schema8.deprecated;
+  rules.set("deprecated must be a boolean", (schema9) => {
+    const typeOfDeprecated = typeof schema9.deprecated;
     return typeOfDeprecated === "boolean" || typeOfDeprecated === "undefined";
   });
-  function validate2(schema8, filename) {
+  function validate2(schema9, filename) {
     const errors4 = [];
     rules.forEach((rule, ruleName) => {
-      (0, utils_1.traverse)(schema8, (schema9, key2) => {
-        if (rule(schema9) === false) {
+      (0, utils_1.traverse)(schema9, (schema10, key2) => {
+        if (rule(schema10) === false) {
           errors4.push(`Error at key "${key2}" in file "${filename}": ${ruleName}`);
         }
-        return schema9;
+        return schema10;
       });
     });
     return errors4;
@@ -136869,25 +137261,25 @@ var require_linker = __commonJS((exports) => {
   exports.link = undefined;
   var JSONSchema_1 = require_JSONSchema();
   var lodash_1 = require_lodash2();
-  function link2(schema8, parent = null) {
-    if (!Array.isArray(schema8) && !(0, lodash_1.isPlainObject)(schema8)) {
-      return schema8;
+  function link2(schema9, parent = null) {
+    if (!Array.isArray(schema9) && !(0, lodash_1.isPlainObject)(schema9)) {
+      return schema9;
     }
-    if (schema8.hasOwnProperty(JSONSchema_1.Parent)) {
-      return schema8;
+    if (schema9.hasOwnProperty(JSONSchema_1.Parent)) {
+      return schema9;
     }
-    Object.defineProperty(schema8, JSONSchema_1.Parent, {
+    Object.defineProperty(schema9, JSONSchema_1.Parent, {
       enumerable: false,
       value: parent,
       writable: false
     });
-    if (Array.isArray(schema8)) {
-      schema8.forEach((child) => link2(child, schema8));
+    if (Array.isArray(schema9)) {
+      schema9.forEach((child) => link2(child, schema9));
     }
-    for (const key2 in schema8) {
-      link2(schema8[key2], schema8);
+    for (const key2 in schema9) {
+      link2(schema9[key2], schema9);
     }
-    return schema8;
+    return schema9;
   }
   exports.link = link2;
 });
@@ -136908,11 +137300,11 @@ var require_optionValidator = __commonJS((exports) => {
 var require_src3 = __commonJS((exports) => {
   var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P9, generator) {
     function adopt(value) {
-      return value instanceof P9 ? value : new P9(function(resolve5) {
-        resolve5(value);
+      return value instanceof P9 ? value : new P9(function(resolve6) {
+        resolve6(value);
       });
     }
-    return new (P9 || (P9 = Promise))(function(resolve5, reject) {
+    return new (P9 || (P9 = Promise))(function(resolve6, reject) {
       function fulfilled(value) {
         try {
           step(generator.next(value));
@@ -136928,7 +137320,7 @@ var require_src3 = __commonJS((exports) => {
         }
       }
       function step(result) {
-        result.done ? resolve5(result.value) : adopt(result.value).then(fulfilled, rejected);
+        result.done ? resolve6(result.value) : adopt(result.value).then(fulfilled, rejected);
       }
       step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
@@ -136979,8 +137371,8 @@ var require_src3 = __commonJS((exports) => {
     unknownAny: true
   };
   function compileFromFile(filename, options8 = exports.DEFAULT_OPTIONS) {
-    const schema8 = parseAsJSONSchema(filename);
-    return compile(schema8, (0, utils_1.stripExtension)(filename), Object.assign({ cwd: (0, path_1.dirname)(filename) }, options8));
+    const schema9 = parseAsJSONSchema(filename);
+    return compile(schema9, (0, utils_1.stripExtension)(filename), Object.assign({ cwd: (0, path_1.dirname)(filename) }, options8));
   }
   exports.compileFromFile = compileFromFile;
   function parseAsJSONSchema(filename) {
@@ -136990,7 +137382,7 @@ var require_src3 = __commonJS((exports) => {
     return (0, utils_1.parseFileAsJSONSchema)(filename, contents.toString());
   }
   function compile(schema_1, name_1) {
-    return __awaiter(this, arguments, undefined, function* (schema8, name2, options8 = {}) {
+    return __awaiter(this, arguments, undefined, function* (schema9, name2, options8 = {}) {
       (0, optionValidator_1.validateOptions)(options8);
       const _options = (0, lodash_1.merge)({}, exports.DEFAULT_OPTIONS, options8);
       const start = Date.now();
@@ -137000,7 +137392,7 @@ var require_src3 = __commonJS((exports) => {
       if (!(0, lodash_1.endsWith)(_options.cwd, "/")) {
         _options.cwd += "/";
       }
-      const _schema = (0, lodash_1.cloneDeep)(schema8);
+      const _schema = (0, lodash_1.cloneDeep)(schema9);
       const { dereferencedPaths, dereferencedSchema } = yield (0, resolver_1.dereference)(_schema, _options);
       if (process.env.VERBOSE) {
         if ((0, util_1.isDeepStrictEqual)(_schema, dereferencedSchema)) {
@@ -137125,7 +137517,7 @@ var require_vary = __commonJS((exports, module) => {
     if (!field) {
       throw new TypeError("field argument is required");
     }
-    var fields = !Array.isArray(field) ? parse10(String(field)) : field;
+    var fields = !Array.isArray(field) ? parse11(String(field)) : field;
     for (var j10 = 0;j10 < fields.length; j10++) {
       if (!FIELD_NAME_REGEXP.test(fields[j10])) {
         throw new TypeError("field argument contains an invalid header name");
@@ -137135,7 +137527,7 @@ var require_vary = __commonJS((exports, module) => {
       return header2;
     }
     var val = header2;
-    var vals = parse10(header2.toLowerCase());
+    var vals = parse11(header2.toLowerCase());
     if (fields.indexOf("*") !== -1 || vals.indexOf("*") !== -1) {
       return "*";
     }
@@ -137148,7 +137540,7 @@ var require_vary = __commonJS((exports, module) => {
     }
     return val;
   }
-  function parse10(header2) {
+  function parse11(header2) {
     var end = 0;
     var list3 = [];
     var start = 0;
@@ -137400,13 +137792,13 @@ var require_ms = __commonJS((exports, module) => {
     options8 = options8 || {};
     var type = typeof val;
     if (type === "string" && val.length > 0) {
-      return parse10(val);
+      return parse11(val);
     } else if (type === "number" && isFinite(val)) {
       return options8.long ? fmtLong(val) : fmtShort(val);
     }
     throw new Error("val is not a non-empty string or a valid number. val=" + JSON.stringify(val));
   };
-  function parse10(str) {
+  function parse11(str) {
     str = String(str);
     if (str.length > 100) {
       return;
@@ -137500,7 +137892,7 @@ var require_ms = __commonJS((exports, module) => {
 
 // node_modules/debug/src/common.js
 var require_common7 = __commonJS((exports, module) => {
-  function setup(env2) {
+  function setup(env3) {
     createDebug.debug = createDebug;
     createDebug.default = createDebug;
     createDebug.coerce = coerce;
@@ -137509,8 +137901,8 @@ var require_common7 = __commonJS((exports, module) => {
     createDebug.enabled = enabled;
     createDebug.humanize = require_ms();
     createDebug.destroy = destroy;
-    Object.keys(env2).forEach((key2) => {
-      createDebug[key2] = env2[key2];
+    Object.keys(env3).forEach((key2) => {
+      createDebug[key2] = env3[key2];
     });
     createDebug.names = [];
     createDebug.skips = [];
@@ -138716,7 +139108,7 @@ var require_bytes = __commonJS((exports, module) => {
    */
   module.exports = bytes;
   module.exports.format = format3;
-  module.exports.parse = parse10;
+  module.exports.parse = parse11;
   var formatThousandsRegExp = /\B(?=(\d{3})+(?!\d))/g;
   var formatDecimalsRegExp = /(?:\.0*|(\.[^0]+)0+)$/;
   var map2 = {
@@ -138730,7 +139122,7 @@ var require_bytes = __commonJS((exports, module) => {
   var parseRegExp = /^((-|\+)?(\d+(?:\.\d+)?)) *(kb|mb|gb|tb|pb)$/i;
   function bytes(value, options8) {
     if (typeof value === "string") {
-      return parse10(value);
+      return parse11(value);
     }
     if (typeof value === "number") {
       return format3(value, options8);
@@ -138774,7 +139166,7 @@ var require_bytes = __commonJS((exports, module) => {
     }
     return str + unitSeparator + unit;
   }
-  function parse10(val) {
+  function parse11(val) {
     if (typeof val === "number" && !isNaN(val)) {
       return val;
     }
@@ -142553,11 +142945,11 @@ var require_raw_body = __commonJS((exports, module) => {
     if (done) {
       return readStream(stream, encoding, length, limit, wrap(done));
     }
-    return new Promise(function executor(resolve5, reject) {
+    return new Promise(function executor(resolve6, reject) {
       readStream(stream, encoding, length, limit, function onRead2(err, buf) {
         if (err)
           return reject(err);
-        resolve5(buf);
+        resolve6(buf);
       });
     });
   }
@@ -142878,7 +143270,7 @@ var require_content_type = __commonJS((exports) => {
   var QUOTE_REGEXP = /([\\"])/g;
   var TYPE_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
   exports.format = format3;
-  exports.parse = parse10;
+  exports.parse = parse11;
   function format3(obj) {
     if (!obj || typeof obj !== "object") {
       throw new TypeError("argument obj is required");
@@ -142902,7 +143294,7 @@ var require_content_type = __commonJS((exports) => {
     }
     return string4;
   }
-  function parse10(string4) {
+  function parse11(string4) {
     if (!string4) {
       throw new TypeError("argument string is required");
     }
@@ -152469,7 +152861,7 @@ var require_media_typer = __commonJS((exports) => {
   var TYPE_NAME_REGEXP = /^[A-Za-z0-9][A-Za-z0-9!#$&^_-]{0,126}$/;
   var TYPE_REGEXP = /^ *([A-Za-z0-9][A-Za-z0-9!#$&^_-]{0,126})\/([A-Za-z0-9][A-Za-z0-9!#$&^_.+-]{0,126}) *$/;
   exports.format = format3;
-  exports.parse = parse10;
+  exports.parse = parse11;
   exports.test = test;
   function format3(obj) {
     if (!obj || typeof obj !== "object") {
@@ -152502,7 +152894,7 @@ var require_media_typer = __commonJS((exports) => {
     }
     return TYPE_REGEXP.test(string4.toLowerCase());
   }
-  function parse10(string4) {
+  function parse11(string4) {
     if (!string4) {
       throw new TypeError("argument string is required");
     }
@@ -152691,7 +153083,7 @@ var require_read = __commonJS((exports, module) => {
   var hasBody = require_type_is().hasBody;
   var { getCharset } = require_utils8();
   module.exports = read3;
-  function read3(req, res, next, parse10, debug, options8) {
+  function read3(req, res, next, parse11, debug, options8) {
     if (onFinished.isFinished(req)) {
       debug("body already parsed");
       next();
@@ -152779,7 +153171,7 @@ var require_read = __commonJS((exports, module) => {
       try {
         debug("parse body");
         str = typeof body !== "string" && encoding !== null ? iconv.decode(body, encoding) : body;
-        req.body = parse10(str, encoding);
+        req.body = parse11(str, encoding);
       } catch (err) {
         next(createError2(400, err, {
           body: str,
@@ -152855,7 +153247,7 @@ var require_json5 = __commonJS((exports, module) => {
     const normalizedOptions = normalizeOptions5(options8, "application/json");
     var reviver = options8?.reviver;
     var strict = options8?.strict !== false;
-    function parse10(body) {
+    function parse11(body) {
       if (body.length === 0) {
         return {};
       }
@@ -152881,7 +153273,7 @@ var require_json5 = __commonJS((exports, module) => {
       isValidCharset: (charset) => charset.slice(0, 4) === "utf-"
     };
     return function jsonParser(req, res, next) {
-      read3(req, res, next, parse10, debug, readOptions);
+      read3(req, res, next, parse11, debug, readOptions);
     };
   }
   function createStrictSyntaxError(str, char) {
@@ -155224,11 +155616,11 @@ var require_parse7 = __commonJS((exports, module) => {
 // node_modules/qs/lib/index.js
 var require_lib6 = __commonJS((exports, module) => {
   var stringify = require_stringify4();
-  var parse10 = require_parse7();
+  var parse11 = require_parse7();
   var formats = require_formats();
   module.exports = {
     formats,
-    parse: parse10,
+    parse: parse11,
     stringify
   };
 });
@@ -155253,7 +155645,7 @@ var require_urlencoded = __commonJS((exports, module) => {
       throw new TypeError("option defaultCharset must be either utf-8 or iso-8859-1");
     }
     var queryparse = createQueryParser(options8);
-    function parse10(body, encoding) {
+    function parse11(body, encoding) {
       return body.length ? queryparse(body, encoding) : {};
     }
     const readOptions = {
@@ -155261,7 +155653,7 @@ var require_urlencoded = __commonJS((exports, module) => {
       isValidCharset: (charset) => charset === "utf-8" || charset === "iso-8859-1"
     };
     return function urlencodedParser(req, res, next) {
-      read3(req, res, next, parse10, debug, readOptions);
+      read3(req, res, next, parse11, debug, readOptions);
     };
   }
   function createQueryParser(options8) {
@@ -155454,7 +155846,7 @@ var require_parseurl = __commonJS((exports, module) => {
    * MIT Licensed
    */
   var url3 = __require("url");
-  var parse10 = url3.parse;
+  var parse11 = url3.parse;
   var Url = url3.Url;
   module.exports = parseurl;
   module.exports.original = originalurl;
@@ -155486,7 +155878,7 @@ var require_parseurl = __commonJS((exports, module) => {
   }
   function fastparse(str) {
     if (typeof str !== "string" || str.charCodeAt(0) !== 47) {
-      return parse10(str);
+      return parse11(str);
     }
     var pathname = str;
     var query = null;
@@ -155508,7 +155900,7 @@ var require_parseurl = __commonJS((exports, module) => {
         case 35:
         case 160:
         case 65279:
-          return parse10(str);
+          return parse11(str);
       }
     }
     var url4 = Url !== undefined ? new Url : {};
@@ -155558,7 +155950,7 @@ var require_finalhandler = __commonJS((exports, module) => {
   module.exports = finalhandler;
   function finalhandler(req, res, options8) {
     var opts = options8 || {};
-    var env2 = opts.env || "development";
+    var env3 = opts.env || "development";
     var onerror = opts.onerror;
     return function(err) {
       var headers;
@@ -155575,7 +155967,7 @@ var require_finalhandler = __commonJS((exports, module) => {
         } else {
           headers = getErrorHeaders(err);
         }
-        msg = getErrorMessage(err, status, env2);
+        msg = getErrorMessage(err, status, env3);
       } else {
         status = 404;
         msg = "Cannot " + req.method + " " + encodeUrl(getResourceName(req));
@@ -155600,9 +155992,9 @@ var require_finalhandler = __commonJS((exports, module) => {
     }
     return { ...err.headers };
   }
-  function getErrorMessage(err, status, env2) {
+  function getErrorMessage(err, status, env3) {
     var msg;
-    if (env2 !== "production") {
+    if (env3 !== "production") {
       msg = err.stack;
       if (!msg && typeof err.toString === "function") {
         msg = err.toString();
@@ -155682,7 +156074,7 @@ var require_view = __commonJS((exports, module) => {
   var basename4 = path18.basename;
   var extname2 = path18.extname;
   var join15 = path18.join;
-  var resolve5 = path18.resolve;
+  var resolve6 = path18.resolve;
   module.exports = View;
   function View(name2, options8) {
     var opts = options8 || {};
@@ -155716,7 +156108,7 @@ var require_view = __commonJS((exports, module) => {
     debug('lookup "%s"', name2);
     for (var i5 = 0;i5 < roots.length && !path19; i5++) {
       var root2 = roots[i5];
-      var loc = resolve5(root2, name2);
+      var loc = resolve6(root2, name2);
       var dir = dirname11(loc);
       var file2 = basename4(loc);
       path19 = this.resolve(dir, file2);
@@ -155741,7 +156133,7 @@ var require_view = __commonJS((exports, module) => {
     });
     sync = false;
   };
-  View.prototype.resolve = function resolve6(dir, file2) {
+  View.prototype.resolve = function resolve7(dir, file2) {
     var ext = this.ext;
     var path19 = join15(dir, file2);
     var stat2 = tryStat(path19);
@@ -155820,7 +156212,7 @@ var require_forwarded = __commonJS((exports, module) => {
     if (!req) {
       throw new TypeError("argument req is required");
     }
-    var proxyAddrs = parse10(req.headers["x-forwarded-for"] || "");
+    var proxyAddrs = parse11(req.headers["x-forwarded-for"] || "");
     var socketAddr = getSocketAddr(req);
     var addrs = [socketAddr].concat(proxyAddrs);
     return addrs;
@@ -155828,7 +156220,7 @@ var require_forwarded = __commonJS((exports, module) => {
   function getSocketAddr(req) {
     return req.socket ? req.socket.remoteAddress : req.connection.remoteAddress;
   }
-  function parse10(header2) {
+  function parse11(header2) {
     var end = header2.length;
     var list3 = [];
     var start = header2.length;
@@ -156858,7 +157250,7 @@ var require_is_promise = __commonJS((exports, module) => {
 var require_dist = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.PathError = exports.TokenData = undefined;
-  exports.parse = parse10;
+  exports.parse = parse11;
   exports.compile = compile2;
   exports.match = match;
   exports.pathToRegexp = pathToRegexp;
@@ -156904,7 +157296,7 @@ var require_dist = __commonJS((exports) => {
     }
   }
   exports.PathError = PathError;
-  function parse10(str, options8 = {}) {
+  function parse11(str, options8 = {}) {
     const { encodePath = NOOP_VALUE } = options8;
     const chars = [...str];
     const tokens = [];
@@ -156994,7 +157386,7 @@ var require_dist = __commonJS((exports) => {
   }
   function compile2(path18, options8 = {}) {
     const { encode: encode5 = encodeURIComponent, delimiter = DEFAULT_DELIMITER } = options8;
-    const data = typeof path18 === "object" ? path18 : parse10(path18, options8);
+    const data = typeof path18 === "object" ? path18 : parse11(path18, options8);
     const fn9 = tokensToFunction(data.tokens, delimiter, encode5);
     return function path19(params = {}) {
       const [path20, ...missing] = fn9(params);
@@ -157089,7 +157481,7 @@ var require_dist = __commonJS((exports) => {
     const flags = sensitive ? "" : "i";
     const sources = [];
     for (const input of pathsToArray(path18, [])) {
-      const data = typeof input === "object" ? input : parse10(input, options8);
+      const data = typeof input === "object" ? input : parse11(input, options8);
       for (const tokens of flatten(data.tokens, 0, [])) {
         sources.push(toRegExpSource(tokens, delimiter, keys, data.originalPath));
       }
@@ -157900,7 +158292,7 @@ var require_application = __commonJS((exports, module) => {
   var compileETag = require_utils10().compileETag;
   var compileQueryParser = require_utils10().compileQueryParser;
   var compileTrust = require_utils10().compileTrust;
-  var resolve5 = __require("node:path").resolve;
+  var resolve6 = __require("node:path").resolve;
   var once9 = require_once();
   var Router = require_router();
   var slice = Array.prototype.slice;
@@ -157928,10 +158320,10 @@ var require_application = __commonJS((exports, module) => {
     });
   };
   app.defaultConfiguration = function defaultConfiguration() {
-    var env2 = "development";
+    var env3 = "development";
     this.enable("x-powered-by");
     this.set("etag", "weak");
-    this.set("env", env2);
+    this.set("env", env3);
     this.set("query parser", "simple");
     this.set("subdomain offset", 2);
     this.set("trust proxy", false);
@@ -157939,7 +158331,7 @@ var require_application = __commonJS((exports, module) => {
       configurable: true,
       value: true
     });
-    debug("booting in %s mode", env2);
+    debug("booting in %s mode", env3);
     this.on("mount", function onmount(parent) {
       if (this.settings[trustProxyDefaultSymbol] === true && typeof parent.settings["trust proxy fn"] === "function") {
         delete this.settings["trust proxy"];
@@ -157954,9 +158346,9 @@ var require_application = __commonJS((exports, module) => {
     this.mountpath = "/";
     this.locals.settings = this.settings;
     this.set("view", View);
-    this.set("views", resolve5("views"));
+    this.set("views", resolve6("views"));
     this.set("jsonp callback name", "callback");
-    if (env2 === "production") {
+    if (env3 === "production") {
       this.enable("view cache");
     }
   };
@@ -158919,7 +159311,7 @@ var require_request = __commonJS((exports, module) => {
   var http = __require("node:http");
   var fresh = require_fresh();
   var parseRange = require_range_parser();
-  var parse10 = require_parseurl();
+  var parse11 = require_parseurl();
   var proxyaddr = require_proxy_addr();
   var req = Object.create(http.IncomingMessage.prototype);
   module.exports = req;
@@ -158965,7 +159357,7 @@ var require_request = __commonJS((exports, module) => {
     if (!queryparse) {
       return Object.create(null);
     }
-    var querystring = parse10(this).query;
+    var querystring = parse11(this).query;
     return queryparse(querystring);
   });
   req.is = function is8(types) {
@@ -159010,7 +159402,7 @@ var require_request = __commonJS((exports, module) => {
     return subdomains2.slice(offset);
   });
   defineGetter(req, "path", function path18() {
-    return parse10(this).pathname;
+    return parse11(this).pathname;
   });
   defineGetter(req, "host", function host() {
     var trust = this.app.get("trust proxy fn");
@@ -159068,7 +159460,7 @@ var require_content_disposition = __commonJS((exports, module) => {
    * MIT Licensed
    */
   module.exports = contentDisposition;
-  module.exports.parse = parse10;
+  module.exports.parse = parse11;
   var basename4 = __require("path").basename;
   var ENCODE_URL_ATTR_CHAR_REGEXP = /[\x00-\x20"'()*,/:;<=>?@[\\\]{}\x7f]/g;
   var HEX_ESCAPE_REGEXP = /%[0-9A-Fa-f]{2}/;
@@ -159159,7 +159551,7 @@ var require_content_disposition = __commonJS((exports, module) => {
   function getlatin1(val) {
     return String(val).replace(NON_LATIN1_REGEXP, "?");
   }
-  function parse10(string4) {
+  function parse11(string4) {
     if (!string4 || typeof string4 !== "string") {
       throw new TypeError("argument string is required");
     }
@@ -159228,19 +159620,19 @@ var require_content_disposition = __commonJS((exports, module) => {
 // node_modules/cookie-signature/index.js
 var require_cookie_signature = __commonJS((exports) => {
   var crypto = __require("crypto");
-  exports.sign = function(val, secret) {
+  exports.sign = function(val, secret2) {
     if (typeof val != "string")
       throw new TypeError("Cookie value must be provided as a string.");
-    if (secret == null)
+    if (secret2 == null)
       throw new TypeError("Secret key must be provided.");
-    return val + "." + crypto.createHmac("sha256", secret).update(val).digest("base64").replace(/\=+$/, "");
+    return val + "." + crypto.createHmac("sha256", secret2).update(val).digest("base64").replace(/\=+$/, "");
   };
-  exports.unsign = function(input, secret) {
+  exports.unsign = function(input, secret2) {
     if (typeof input != "string")
       throw new TypeError("Signed cookie string must be provided.");
-    if (secret == null)
+    if (secret2 == null)
       throw new TypeError("Secret key must be provided.");
-    var tentativeValue = input.slice(0, input.lastIndexOf(".")), expectedInput = exports.sign(tentativeValue, secret), expectedBuffer = Buffer.from(expectedInput), inputBuffer = Buffer.from(input);
+    var tentativeValue = input.slice(0, input.lastIndexOf(".")), expectedInput = exports.sign(tentativeValue, secret2), expectedBuffer = Buffer.from(expectedInput), inputBuffer = Buffer.from(input);
     return expectedBuffer.length === inputBuffer.length && crypto.timingSafeEqual(expectedBuffer, inputBuffer) ? tentativeValue : false;
   };
 });
@@ -159253,7 +159645,7 @@ var require_cookie = __commonJS((exports) => {
    * Copyright(c) 2015 Douglas Christopher Wilson
    * MIT Licensed
    */
-  exports.parse = parse10;
+  exports.parse = parse11;
   exports.serialize = serialize2;
   var __toString = Object.prototype.toString;
   var __hasOwnProperty = Object.prototype.hasOwnProperty;
@@ -159261,7 +159653,7 @@ var require_cookie = __commonJS((exports) => {
   var cookieValueRegExp = /^("?)[\u0021\u0023-\u002B\u002D-\u003A\u003C-\u005B\u005D-\u007E]*\1$/;
   var domainValueRegExp = /^([.]?[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)([.][a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*$/i;
   var pathValueRegExp = /^[\u0020-\u003A\u003D-\u007E]*$/;
-  function parse10(str, opt) {
+  function parse11(str, opt) {
     if (typeof str !== "string") {
       throw new TypeError("argument str must be a string");
     }
@@ -159445,7 +159837,7 @@ var require_send = __commonJS((exports, module) => {
   var extname2 = path18.extname;
   var join15 = path18.join;
   var normalize = path18.normalize;
-  var resolve5 = path18.resolve;
+  var resolve6 = path18.resolve;
   var sep = path18.sep;
   var BYTES_RANGE_REGEXP = /^ *bytes=/;
   var MAX_MAXAGE = 60 * 60 * 24 * 365 * 1000;
@@ -159474,7 +159866,7 @@ var require_send = __commonJS((exports, module) => {
     this._maxage = opts.maxAge || opts.maxage;
     this._maxage = typeof this._maxage === "string" ? ms8(this._maxage) : Number(this._maxage);
     this._maxage = !isNaN(this._maxage) ? Math.min(Math.max(0, this._maxage), MAX_MAXAGE) : 0;
-    this._root = opts.root ? resolve5(opts.root) : null;
+    this._root = opts.root ? resolve6(opts.root) : null;
   }
   util2.inherits(SendStream, Stream2);
   SendStream.prototype.error = function error48(status, err) {
@@ -159623,7 +160015,7 @@ var require_send = __commonJS((exports, module) => {
         return res;
       }
       parts = normalize(path19).split(sep);
-      path19 = resolve5(path19);
+      path19 = resolve6(path19);
     }
     if (containsDotFile(parts)) {
       debug('%s dotfile "%s"', this._dotfiles, path19);
@@ -159951,7 +160343,7 @@ var require_response = __commonJS((exports, module) => {
   var cookie = require_cookie();
   var send = require_send();
   var extname2 = path18.extname;
-  var resolve5 = path18.resolve;
+  var resolve6 = path18.resolve;
   var vary = require_vary();
   var { Buffer: Buffer7 } = __require("node:buffer");
   var res = Object.create(http.ServerResponse.prototype);
@@ -160160,7 +160552,7 @@ var require_response = __commonJS((exports, module) => {
     }
     opts = Object.create(opts);
     opts.headers = headers;
-    var fullPath = !opts.root ? resolve5(path19) : path19;
+    var fullPath = !opts.root ? resolve6(path19) : path19;
     return this.sendFile(fullPath, opts, done);
   };
   res.contentType = res.type = function contentType(type) {
@@ -160231,14 +160623,14 @@ var require_response = __commonJS((exports, module) => {
   };
   res.cookie = function(name2, value, options8) {
     var opts = { ...options8 };
-    var secret = this.req.secret;
+    var secret2 = this.req.secret;
     var signed = opts.signed;
-    if (signed && !secret) {
+    if (signed && !secret2) {
       throw new Error('cookieParser("secret") required for signed cookies');
     }
     var val = typeof value === "object" ? "j:" + JSON.stringify(value) : String(value);
     if (signed) {
-      val = "s:" + sign2(val, secret);
+      val = "s:" + sign2(val, secret2);
     }
     if (opts.maxAge != null) {
       var maxAge = opts.maxAge - 0;
@@ -160421,7 +160813,7 @@ var require_serve_static = __commonJS((exports, module) => {
   var encodeUrl = require_encodeurl();
   var escapeHtml = require_escape_html();
   var parseUrl = require_parseurl();
-  var resolve5 = __require("path").resolve;
+  var resolve6 = __require("path").resolve;
   var send = require_send();
   var url3 = __require("url");
   module.exports = serveStatic;
@@ -160440,7 +160832,7 @@ var require_serve_static = __commonJS((exports, module) => {
       throw new TypeError("option setHeaders must be function");
     }
     opts.maxage = opts.maxage || opts.maxAge || 0;
-    opts.root = resolve5(root2);
+    opts.root = resolve6(root2);
     var onDirectory = redirect ? createRedirectDirectoryListener() : createNotFoundDirectoryListener();
     return function serveStatic2(req, res, next) {
       if (req.method !== "GET" && req.method !== "HEAD") {
@@ -163431,8 +163823,8 @@ var require_executor = __commonJS((exports, module) => {
     }
     resetBuffer() {
       this.buffer = new Waterfall;
-      this.buffer.chain(new Promise((resolve5) => {
-        this._triggerBuffer = resolve5;
+      this.buffer.chain(new Promise((resolve6) => {
+        this._triggerBuffer = resolve6;
       }));
       if (this.ready)
         this._triggerBuffer();
@@ -164452,7 +164844,7 @@ var require_storage = __commonJS((exports, module) => {
       throw e8;
     }
   };
-  var writeFileLinesAsync = (filename, lines, mode = DEFAULT_FILE_MODE) => new Promise((resolve5, reject) => {
+  var writeFileLinesAsync = (filename, lines, mode = DEFAULT_FILE_MODE) => new Promise((resolve6, reject) => {
     try {
       const stream = writeFileStream(filename, { mode });
       const readable2 = Readable6.from(lines);
@@ -164469,7 +164861,7 @@ var require_storage = __commonJS((exports, module) => {
           if (err)
             reject(err);
           else
-            resolve5();
+            resolve6();
         });
       });
       readable2.on("error", (err) => {
@@ -164640,7 +165032,7 @@ var require_persistence = __commonJS((exports, module) => {
       return { data: tdata, indexes };
     }
     treatRawStreamAsync(rawStream) {
-      return new Promise((resolve5, reject) => {
+      return new Promise((resolve6, reject) => {
         const dataById = {};
         const indexes = {};
         let corruptItems = 0;
@@ -164683,7 +165075,7 @@ var require_persistence = __commonJS((exports, module) => {
             }
           }
           const data = Object.values(dataById);
-          resolve5({ data, indexes });
+          resolve6({ data, indexes });
         });
         lineStream.on("error", function(err) {
           reject(err, null);
@@ -186678,7 +187070,7 @@ var require_extension = __commonJS((exports, module) => {
     else
       dest[name2].push(elem);
   }
-  function parse10(header2) {
+  function parse11(header2) {
     const offers = Object.create(null);
     let params = Object.create(null);
     let mustUnescape = false;
@@ -186831,7 +187223,7 @@ var require_extension = __commonJS((exports, module) => {
       }).join(", ");
     }).join(", ");
   }
-  module.exports = { format: format3, parse: parse10 };
+  module.exports = { format: format3, parse: parse11 };
 });
 
 // node_modules/ws/lib/websocket.js
@@ -186861,7 +187253,7 @@ var require_websocket2 = __commonJS((exports, module) => {
   var {
     EventTarget: { addEventListener, removeEventListener }
   } = require_event_target();
-  var { format: format3, parse: parse10 } = require_extension();
+  var { format: format3, parse: parse11 } = require_extension();
   var { toBuffer } = require_buffer_util();
   var closeTimeout = 30 * 1000;
   var kAborted = Symbol("kAborted");
@@ -187404,7 +187796,7 @@ var require_websocket2 = __commonJS((exports, module) => {
         }
         let extensions;
         try {
-          extensions = parse10(secWebSocketExtensions);
+          extensions = parse11(secWebSocketExtensions);
         } catch (err) {
           const message = "Invalid Sec-WebSocket-Extensions header";
           abortHandshake(websocket, socket, message);
@@ -187699,7 +188091,7 @@ var require_stream6 = __commonJS((exports, module) => {
 // node_modules/ws/lib/subprotocol.js
 var require_subprotocol = __commonJS((exports, module) => {
   var { tokenChars } = require_validation();
-  function parse10(header2) {
+  function parse11(header2) {
     const protocols = new Set;
     let start = -1;
     let end = -1;
@@ -187738,7 +188130,7 @@ var require_subprotocol = __commonJS((exports, module) => {
     protocols.add(protocol);
     return protocols;
   }
-  module.exports = { parse: parse10 };
+  module.exports = { parse: parse11 };
 });
 
 // node_modules/ws/lib/websocket-server.js
@@ -190294,13 +190686,13 @@ var require_broadcast_operator = __commonJS((exports) => {
       return true;
     }
     emitWithAck(ev2, ...args) {
-      return new Promise((resolve5, reject) => {
+      return new Promise((resolve6, reject) => {
         args.push((err, responses) => {
           if (err) {
             err.responses = responses;
             return reject(err);
           } else {
-            return resolve5(responses);
+            return resolve6(responses);
           }
         });
         this.emit(ev2, ...args);
@@ -190488,12 +190880,12 @@ var require_socket2 = __commonJS((exports) => {
     }
     emitWithAck(ev2, ...args) {
       const withErr = this.flags.timeout !== undefined;
-      return new Promise((resolve5, reject) => {
+      return new Promise((resolve6, reject) => {
         args.push((arg1, arg2) => {
           if (withErr) {
-            return arg1 ? reject(arg1) : resolve5(arg2);
+            return arg1 ? reject(arg1) : resolve6(arg2);
           } else {
-            return resolve5(arg1);
+            return resolve6(arg1);
           }
         });
         this.emit(ev2, ...args);
@@ -190948,13 +191340,13 @@ var require_namespace = __commonJS((exports) => {
       return true;
     }
     serverSideEmitWithAck(ev2, ...args) {
-      return new Promise((resolve5, reject) => {
+      return new Promise((resolve6, reject) => {
         args.push((err, responses) => {
           if (err) {
             err.responses = responses;
             return reject(err);
           } else {
-            return resolve5(responses);
+            return resolve6(responses);
           }
         });
         this.serverSideEmit(ev2, ...args);
@@ -191638,7 +192030,7 @@ var require_cluster_adapter = __commonJS((exports) => {
         return localSockets;
       }
       const requestId = randomId();
-      return new Promise((resolve5, reject) => {
+      return new Promise((resolve6, reject) => {
         const timeout3 = setTimeout(() => {
           const storedRequest2 = this.requests.get(requestId);
           if (storedRequest2) {
@@ -191648,7 +192040,7 @@ var require_cluster_adapter = __commonJS((exports) => {
         }, opts.flags.timeout || DEFAULT_TIMEOUT);
         const storedRequest = {
           type: MessageType.FETCH_SOCKETS,
-          resolve: resolve5,
+          resolve: resolve6,
           timeout: timeout3,
           current: 0,
           expected: expectedResponseCount,
@@ -191858,7 +192250,7 @@ var require_cluster_adapter = __commonJS((exports) => {
         return localSockets;
       }
       const requestId = randomId();
-      return new Promise((resolve5, reject) => {
+      return new Promise((resolve6, reject) => {
         const timeout3 = setTimeout(() => {
           const storedRequest2 = this.customRequests.get(requestId);
           if (storedRequest2) {
@@ -191868,7 +192260,7 @@ var require_cluster_adapter = __commonJS((exports) => {
         }, opts.flags.timeout || DEFAULT_TIMEOUT);
         const storedRequest = {
           type: MessageType.FETCH_SOCKETS,
-          resolve: resolve5,
+          resolve: resolve6,
           timeout: timeout3,
           missingUids: new Set([...this.nodesMap.keys()]),
           responses: localSockets
@@ -192153,7 +192545,7 @@ var require_uws = __commonJS((exports) => {
 });
 
 // node_modules/socket.io/package.json
-var require_package3 = __commonJS((exports, module) => {
+var require_package4 = __commonJS((exports, module) => {
   module.exports = {
     name: "socket.io",
     version: "4.8.3",
@@ -192309,7 +192701,7 @@ var require_dist4 = __commonJS((exports, module) => {
   var uws_1 = require_uws();
   var cors_1 = __importDefault(require_lib4());
   var debug = (0, debug_1.default)("socket.io:server");
-  var clientVersion = require_package3().version;
+  var clientVersion = require_package4().version;
   var dotMapRegex = /\.map/;
 
   class Server extends typed_events_1.StrictEventEmitter {
@@ -192597,13 +192989,13 @@ var require_dist4 = __commonJS((exports, module) => {
       this.engine.close();
       (0, uws_1.restoreAdapter)();
       if (this.httpServer) {
-        return new Promise((resolve5) => {
+        return new Promise((resolve6) => {
           this.httpServer.close((err) => {
             fn9 && fn9(err);
             if (err) {
               debug("server was not running");
             }
-            resolve5();
+            resolve6();
           });
         });
       } else {
@@ -216626,6 +217018,68 @@ async function getUserInfo(accessToken) {
   }
   return result.data;
 }
+// src/core/resources/secret/schema.ts
+var ListSecretsResponseSchema = exports_external.record(exports_external.string(), exports_external.string());
+var SetSecretsResponseSchema = exports_external.object({
+  success: exports_external.boolean()
+});
+var DeleteSecretResponseSchema = exports_external.object({
+  success: exports_external.boolean()
+});
+
+// src/core/resources/secret/api.ts
+async function listSecrets() {
+  const appClient = getAppClient();
+  let response;
+  try {
+    response = await appClient.get("secrets");
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "listing secrets");
+  }
+  const result = ListSecretsResponseSchema.safeParse(await response.json());
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid response from server", result.error);
+  }
+  return result.data;
+}
+async function setSecrets(secrets) {
+  const appClient = getAppClient();
+  let response;
+  try {
+    response = await appClient.post("secrets", {
+      json: secrets
+    });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "setting secrets");
+  }
+  const result = SetSecretsResponseSchema.safeParse(await response.json());
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid response from server", result.error);
+  }
+  return result.data;
+}
+async function deleteSecret(name2) {
+  const appClient = getAppClient();
+  let response;
+  try {
+    response = await appClient.delete("secrets", {
+      searchParams: { secret_name: name2 }
+    });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "deleting secret");
+  }
+  const result = DeleteSecretResponseSchema.safeParse(await response.json());
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid response from server", result.error);
+  }
+  return result.data;
+}
+// src/core/utils/env.ts
+var import_dotenv = __toESM(require_main(), 1);
+async function parseEnvFile(filePath) {
+  const content = await readTextFile(filePath);
+  return import_dotenv.parse(content);
+}
 // node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
 var wrapAnsi16 = (offset = 0) => (code2) => `\x1B[${code2 + offset}m`;
@@ -216813,7 +217267,7 @@ function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process5.
   const terminatorPosition = argv.indexOf("--");
   return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
 }
-var { env } = process5;
+var { env: env2 } = process5;
 var flagForceColor;
 if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
   flagForceColor = 0;
@@ -216821,14 +217275,14 @@ if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || has
   flagForceColor = 1;
 }
 function envForceColor() {
-  if ("FORCE_COLOR" in env) {
-    if (env.FORCE_COLOR === "true") {
+  if ("FORCE_COLOR" in env2) {
+    if (env2.FORCE_COLOR === "true") {
       return 1;
     }
-    if (env.FORCE_COLOR === "false") {
+    if (env2.FORCE_COLOR === "false") {
       return 0;
     }
-    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+    return env2.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env2.FORCE_COLOR, 10), 3);
   }
 }
 function translateLevel(level) {
@@ -216859,14 +217313,14 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
       return 2;
     }
   }
-  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+  if ("TF_BUILD" in env2 && "AGENT_NAME" in env2) {
     return 1;
   }
   if (haveStream && !streamIsTTY && forceColor === undefined) {
     return 0;
   }
   const min = forceColor || 0;
-  if (env.TERM === "dumb") {
+  if (env2.TERM === "dumb") {
     return min;
   }
   if (process5.platform === "win32") {
@@ -216876,33 +217330,33 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
     }
     return 1;
   }
-  if ("CI" in env) {
-    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => (key in env))) {
+  if ("CI" in env2) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => (key in env2))) {
       return 3;
     }
-    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => (sign in env)) || env.CI_NAME === "codeship") {
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => (sign in env2)) || env2.CI_NAME === "codeship") {
       return 1;
     }
     return min;
   }
-  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 (env.COLORTERM === "truecolor") {
+  if (env2.COLORTERM === "truecolor") {
     return 3;
   }
-  if (env.TERM === "xterm-kitty") {
+  if (env2.TERM === "xterm-kitty") {
     return 3;
   }
-  if (env.TERM === "xterm-ghostty") {
+  if (env2.TERM === "xterm-ghostty") {
     return 3;
   }
-  if (env.TERM === "wezterm") {
+  if (env2.TERM === "wezterm") {
     return 3;
   }
-  if ("TERM_PROGRAM" in env) {
-    const version2 = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
-    switch (env.TERM_PROGRAM) {
+  if ("TERM_PROGRAM" in env2) {
+    const version2 = Number.parseInt((env2.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env2.TERM_PROGRAM) {
       case "iTerm.app": {
         return version2 >= 3 ? 3 : 2;
       }
@@ -216911,13 +217365,13 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
       }
     }
   }
-  if (/-256(color)?$/i.test(env.TERM)) {
+  if (/-256(color)?$/i.test(env2.TERM)) {
     return 2;
   }
-  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env2.TERM)) {
     return 1;
   }
-  if ("COLORTERM" in env) {
+  if ("COLORTERM" in env2) {
     return 1;
   }
   return min;
@@ -217756,12 +218210,12 @@ var NO_ESCAPE_REGEXP = /^[\w./-]+$/;
 // node_modules/is-unicode-supported/index.js
 import process7 from "node:process";
 function isUnicodeSupported() {
-  const { env: env2 } = process7;
-  const { TERM, TERM_PROGRAM } = env2;
+  const { env: env3 } = process7;
+  const { TERM, TERM_PROGRAM } = env3;
   if (process7.platform !== "win32") {
     return TERM !== "linux";
   }
-  return Boolean(env2.WT_SESSION) || Boolean(env2.TERMINUS_SUBLIME) || env2.ConEmuTask === "{cmd::Cmder}" || TERM_PROGRAM === "Terminus-Sublime" || TERM_PROGRAM === "vscode" || TERM === "xterm-256color" || TERM === "alacritty" || TERM === "rxvt-unicode" || TERM === "rxvt-unicode-256color" || env2.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+  return Boolean(env3.WT_SESSION) || Boolean(env3.TERMINUS_SUBLIME) || env3.ConEmuTask === "{cmd::Cmder}" || TERM_PROGRAM === "Terminus-Sublime" || TERM_PROGRAM === "vscode" || TERM === "xterm-256color" || TERM === "alacritty" || TERM === "rxvt-unicode" || TERM === "rxvt-unicode-256color" || env3.TERMINAL_EMULATOR === "JetBrains-JediTerm";
 }
 
 // node_modules/figures/index.js
@@ -218274,13 +218728,13 @@ import path12 from "node:path";
 // node_modules/npm-run-path/node_modules/path-key/index.js
 function pathKey(options = {}) {
   const {
-    env: env2 = process.env,
+    env: env3 = process.env,
     platform: platform6 = process.platform
   } = options;
   if (platform6 !== "win32") {
     return "PATH";
   }
-  return Object.keys(env2).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+  return Object.keys(env3).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
 }
 
 // node_modules/npm-run-path/node_modules/unicorn-magic/node.js
@@ -218340,12 +218794,12 @@ var applyExecPath = (result, pathParts, execPath, cwdPath) => {
     result.push(pathPart);
   }
 };
-var npmRunPathEnv = ({ env: env2 = process8.env, ...options } = {}) => {
-  env2 = { ...env2 };
-  const pathName = pathKey({ env: env2 });
-  options.path = env2[pathName];
-  env2[pathName] = npmRunPath(options);
-  return env2;
+var npmRunPathEnv = ({ env: env3 = process8.env, ...options } = {}) => {
+  env3 = { ...env3 };
+  const pathName = pathKey({ env: env3 });
+  options.path = env3[pathName];
+  env3[pathName] = npmRunPath(options);
+  return env3;
 };
 
 // node_modules/execa/lib/terminate/kill.js
@@ -219694,17 +220148,17 @@ var addDefaultOptions = ({
   serialization
 });
 var getEnv = ({ env: envOption, extendEnv, preferLocal, node, localDirectory, nodePath: nodePath2 }) => {
-  const env2 = extendEnv ? { ...process10.env, ...envOption } : envOption;
+  const env3 = extendEnv ? { ...process10.env, ...envOption } : envOption;
   if (preferLocal || node) {
     return npmRunPathEnv({
-      env: env2,
+      env: env3,
       cwd: localDirectory,
       execPath: nodePath2,
       preferLocal,
       addExecPath: node
     });
   }
-  return env2;
+  return env3;
 };
 
 // node_modules/execa/lib/arguments/shell.js
@@ -223964,6 +224418,7 @@ var package_default = {
     commander: "^12.1.0",
     "common-tags": "^1.8.2",
     cors: "^2.8.5",
+    dotenv: "17.3.1",
     ejs: "^3.1.10",
     execa: "^9.6.1",
     express: "^5.0.1",
@@ -225610,8 +226065,114 @@ function getLogsCommand(context) {
   });
 }
 
-// src/cli/commands/site/deploy.ts
+// src/cli/commands/secrets/delete.ts
+async function deleteSecretAction(key) {
+  await runTask(`Deleting secret "${key}"`, async () => {
+    return await deleteSecret(key);
+  }, {
+    successMessage: `Secret "${key}" deleted`,
+    errorMessage: `Failed to delete secret "${key}"`
+  });
+  return {
+    outroMessage: "Secret deleted successfully."
+  };
+}
+function getSecretsDeleteCommand(context) {
+  return new Command("delete").description("Delete a secret").argument("<key>", "Secret name to delete").action(async (key) => {
+    await runCommand(() => deleteSecretAction(key), { requireAuth: true }, context);
+  });
+}
+
+// src/cli/commands/secrets/list.ts
+async function listSecretsAction() {
+  const secrets = await runTask("Fetching secrets from Base44", async () => {
+    return await listSecrets();
+  }, {
+    successMessage: "Secrets fetched successfully",
+    errorMessage: "Failed to fetch secrets"
+  });
+  const names = Object.keys(secrets);
+  if (names.length === 0) {
+    return { outroMessage: "No secrets configured." };
+  }
+  for (const name2 of names) {
+    R2.info(name2);
+  }
+  return {
+    outroMessage: `Found ${names.length} secrets.`
+  };
+}
+function getSecretsListCommand(context) {
+  return new Command("list").description("List secret names").action(async () => {
+    await runCommand(listSecretsAction, { requireAuth: true }, context);
+  });
+}
+
+// src/cli/commands/secrets/set.ts
 import { resolve as resolve3 } from "node:path";
+function parseEntries(entries) {
+  const secrets = {};
+  for (const entry of entries) {
+    const eqIndex = entry.indexOf("=");
+    if (eqIndex === -1) {
+      throw new InvalidInputError(`Invalid format: "${entry}". Expected KEY=VALUE.`);
+    }
+    const key = entry.slice(0, eqIndex);
+    const value = entry.slice(eqIndex + 1);
+    if (!key) {
+      throw new InvalidInputError(`Invalid format: "${entry}". Key cannot be empty.`);
+    }
+    secrets[key] = value;
+  }
+  return secrets;
+}
+function validateInput(command) {
+  const entries = command.args;
+  const { envFile } = command.opts();
+  const hasEntries = entries.length > 0;
+  const hasEnvFile = Boolean(envFile);
+  if (!hasEntries && !hasEnvFile) {
+    throw new InvalidInputError("Provide KEY=VALUE pairs or use --env-file. Example: base44 secrets set KEY1=VALUE1 KEY2=VALUE2");
+  }
+  if (hasEntries && hasEnvFile) {
+    throw new InvalidInputError("Provide KEY=VALUE pairs or --env-file, but not both.");
+  }
+}
+async function setSecretsAction(entries, options) {
+  let secrets;
+  if (options.envFile) {
+    secrets = await parseEnvFile(resolve3(options.envFile));
+    if (Object.keys(secrets).length === 0) {
+      throw new InvalidInputError("The env file contains no valid KEY=VALUE entries.");
+    }
+  } else {
+    secrets = parseEntries(entries);
+  }
+  const names = Object.keys(secrets);
+  await runTask(`Setting ${names.length} secrets`, async () => {
+    return await setSecrets(secrets);
+  }, {
+    successMessage: `${names.length} secrets set successfully`,
+    errorMessage: "Failed to set secrets"
+  });
+  R2.info(`Set: ${names.join(", ")}`);
+  return {
+    outroMessage: "Secrets set successfully."
+  };
+}
+function getSecretsSetCommand(context) {
+  return new Command("set").description("Set one or more secrets (KEY=VALUE format)").argument("[entries...]", "KEY=VALUE pairs (e.g. KEY1=VALUE1 KEY2=VALUE2)").option("--env-file <path>", "Path to .env file").hook("preAction", validateInput).action(async (entries, options) => {
+    await runCommand(() => setSecretsAction(entries, options), { requireAuth: true }, context);
+  });
+}
+
+// src/cli/commands/secrets/index.ts
+function getSecretsCommand(context) {
+  return new Command("secrets").description("Manage project secrets (environment variables)").addCommand(getSecretsListCommand(context)).addCommand(getSecretsSetCommand(context)).addCommand(getSecretsDeleteCommand(context));
+}
+
+// src/cli/commands/site/deploy.ts
+import { resolve as resolve4 } from "node:path";
 async function deployAction2(options) {
   const { project: project2 } = await readProjectConfig();
   if (!project2.site?.outputDirectory) {
@@ -225623,7 +226184,7 @@ async function deployAction2(options) {
       ]
     });
   }
-  const outputDir = resolve3(project2.root, project2.site.outputDirectory);
+  const outputDir = resolve4(project2.root, project2.site.outputDirectory);
   if (!options.yes) {
     const shouldDeploy = await Re({
       message: `Deploy site from ${project2.site.outputDirectory}?`
@@ -225725,9 +226286,9 @@ async function generateContent(input) {
 `);
 }
 async function compileEntity(entity2) {
-  const { name: name2, ...schema8 } = entity2;
+  const { name: name2, ...schema9 } = entity2;
   const jsonSchema = {
-    ...schema8,
+    ...schema9,
     title: name2,
     additionalProperties: false
   };
@@ -225831,14 +226392,14 @@ var getLocalHosts = () => {
   }
   return results;
 };
-var checkAvailablePort = (options8) => new Promise((resolve5, reject) => {
+var checkAvailablePort = (options8) => new Promise((resolve6, reject) => {
   const server = net.createServer();
   server.unref();
   server.on("error", reject);
   server.listen(options8, () => {
     const { port } = server.address();
     server.close(() => {
-      resolve5(port);
+      resolve6(port);
     });
   });
 });
@@ -226062,7 +226623,7 @@ class FunctionManager {
     });
   }
   waitForReady(name2, runningFunc) {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       runningFunc.process.on("exit", (code2) => {
         if (!runningFunc.ready) {
           clearTimeout(timeout3);
@@ -226085,7 +226646,7 @@ class FunctionManager {
           runningFunc.ready = true;
           clearTimeout(timeout3);
           runningFunc.process.stdout?.off("data", onData);
-          resolve5(runningFunc.port);
+          resolve6(runningFunc.port);
         }
       };
       runningFunc.process.stdout?.on("data", onData);
@@ -226474,7 +227035,7 @@ async function createDevServer(options8) {
   app.use((req, res, next) => {
     return remoteProxy(req, res, next);
   });
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const server = app.listen(port, "127.0.0.1", (err) => {
       if (err) {
         if ("code" in err && err.code === "EADDRINUSE") {
@@ -226494,7 +227055,7 @@ async function createDevServer(options8) {
         };
         process.on("SIGINT", shutdown);
         process.on("SIGTERM", shutdown);
-        resolve5({
+        resolve6({
           port,
           server
         });
@@ -226529,7 +227090,7 @@ function getDevCommand(context) {
 }
 
 // src/cli/commands/project/eject.ts
-import { resolve as resolve5 } from "node:path";
+import { resolve as resolve6 } from "node:path";
 var import_lodash2 = __toESM(require_lodash(), 1);
 async function eject(options8) {
   const projects = await listProjects();
@@ -226549,6 +227110,9 @@ async function eject(options8) {
     selectedProject = foundProject;
     R2.info(`Selected project: ${theme.styles.bold(selectedProject.name)}`);
   } else {
+    if (ejectableProjects.length === 0) {
+      return { outroMessage: "No projects available to eject." };
+    }
     const projectOptions = ejectableProjects.map((p4) => ({
       value: p4,
       label: p4.name,
@@ -226575,7 +227139,7 @@ async function eject(options8) {
     Ne("Operation cancelled.");
     throw new CLIExitError(0);
   }
-  const resolvedPath = resolve5(selectedPath);
+  const resolvedPath = resolve6(selectedPath);
   await runTask("Downloading your project's code...", async (updateMessage) => {
     await createProjectFilesForExistingProject({
       projectId,
@@ -226638,6 +227202,7 @@ function createProgram(context) {
   program2.addCommand(getAgentsCommand(context));
   program2.addCommand(getConnectorsCommand(context));
   program2.addCommand(getFunctionsDeployCommand(context));
+  program2.addCommand(getSecretsCommand(context));
   program2.addCommand(getSiteCommand(context));
   program2.addCommand(getTypesCommand(context));
   program2.addCommand(getDevCommand(context), { hidden: true });
@@ -228937,14 +229502,14 @@ async function addSourceContext(frames) {
   return frames;
 }
 function getContextLinesFromFile(path18, ranges, output) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const stream = createReadStream2(path18);
     const lineReaded = createInterface2({
       input: stream
     });
     function destroyStreamAndResolve() {
       stream.destroy();
-      resolve6();
+      resolve7();
     }
     let lineNumber = 0;
     let currentRangeIndex = 0;
@@ -230056,15 +230621,15 @@ class PostHogBackendClient extends PostHogCoreStateless {
       return true;
     if (this.featureFlagsPoller === undefined)
       return false;
-    return new Promise((resolve6) => {
+    return new Promise((resolve7) => {
       const timeout3 = setTimeout(() => {
         cleanup();
-        resolve6(false);
+        resolve7(false);
       }, timeoutMs);
       const cleanup = this._events.on("localEvaluationFlagsLoaded", (count2) => {
         clearTimeout(timeout3);
         cleanup();
-        resolve6(count2 > 0);
+        resolve7(count2 > 0);
       });
     });
   }
@@ -230876,4 +231441,4 @@ export {
   CLIExitError
 };
 
-//# debugId=7558064655620E3C64756E2164756E21
+//# debugId=1F6461CDF975117264756E2164756E21