@base44-preview/cli 0.1.7-pr.585.083d2ac → 0.1.7-pr.586.967fb6f

package/dist/cli/index.js

@@ -31176,7 +31176,7 @@ function cleanDoc(doc2) {
   return mapDoc(doc2, (currentDoc) => cleanDocFn(currentDoc));
 }
 function replaceEndOfLine(doc2, replacement = literalline) {
-  return mapDoc(doc2, (currentDoc) => typeof currentDoc === "string" ? join26(replacement, currentDoc.split(`
+  return mapDoc(doc2, (currentDoc) => typeof currentDoc === "string" ? join24(replacement, currentDoc.split(`
 `)) : currentDoc);
 }
 function canBreakFn(doc2) {
@@ -31256,7 +31256,7 @@ function indentIfBreak(contents, options) {
     negate: options.negate
   };
 }
-function join26(separator, docs) {
+function join24(separator, docs) {
   assertDoc(separator);
   assertDocArray(docs);
   const parts = [];
@@ -31967,7 +31967,7 @@ var init_doc = __esm(() => {
   MODE_FLAT = Symbol("MODE_FLAT");
   DOC_FILL_PRINTED_LENGTH = Symbol("DOC_FILL_PRINTED_LENGTH");
   builders = {
-    join: join26,
+    join: join24,
     line,
     softline,
     hardline,
@@ -119578,11 +119578,11 @@ function chooseDescription(descriptions, printWidth) {
   return firstWidth > printWidth && firstWidth > secondWidth ? secondDescription : firstDescription;
 }
 function createSchema(SchemaConstructor, parameters) {
-  const schema13 = new SchemaConstructor(parameters);
-  const subSchema = Object.create(schema13);
+  const schema12 = new SchemaConstructor(parameters);
+  const subSchema = Object.create(schema12);
   for (const handlerKey of HANDLER_KEYS) {
     if (handlerKey in parameters) {
-      subSchema[handlerKey] = normalizeHandler(parameters[handlerKey], schema13, Schema2.prototype[handlerKey].length);
+      subSchema[handlerKey] = normalizeHandler(parameters[handlerKey], schema12, Schema2.prototype[handlerKey].length);
     }
   }
   return subSchema;
@@ -120385,7 +120385,7 @@ function skipVoid(str, ptr, banNewLines, banComments) {
     ptr++;
   return banComments || c24 !== "#" ? ptr : skipVoid(str, skipComment(str, ptr), banNewLines);
 }
-function skipUntil(str, ptr, sep2, end, banNewLines = false) {
+function skipUntil(str, ptr, sep, end, banNewLines = false) {
   if (!end) {
     ptr = indexOfNewline(str, ptr);
     return ptr < 0 ? str.length : ptr;
@@ -120394,7 +120394,7 @@ function skipUntil(str, ptr, sep2, end, banNewLines = false) {
     let c24 = str[i5];
     if (c24 === "#") {
       i5 = indexOfNewline(str, i5);
-    } else if (c24 === sep2) {
+    } else if (c24 === sep) {
       return i5 + 1;
     } else if (c24 === end || banNewLines && (c24 === `
 ` || c24 === "\r" && str[i5 + 1] === `
@@ -120896,7 +120896,7 @@ function parse42(toml, { maxDepth = 1000, integersAsBigInt } = {}) {
   }
   return res;
 }
-async function readFile6(file2) {
+async function readFile3(file2) {
   if (isUrlString(file2)) {
     file2 = new URL(file2);
   }
@@ -121174,7 +121174,7 @@ function getDataProtocolModuleFormat(parsed) {
   const { 1: mime } = /^([^/]+\/[^;,]+)[^,]*?(;base64)?,/.exec(parsed.pathname) || [null, null, null];
   return mimeToFormat(mime);
 }
-function extname2(url3) {
+function extname(url3) {
   const pathname = url3.pathname;
   let index = pathname.length;
   while (index--) {
@@ -121189,7 +121189,7 @@ function extname2(url3) {
   return "";
 }
 function getFileProtocolModuleFormat(url3, _context, ignoreErrors) {
-  const value = extname2(url3);
+  const value = extname(url3);
   if (value === ".js") {
     const packageType = getPackageType(url3);
     if (packageType !== "none") {
@@ -121650,8 +121650,8 @@ function packageResolve(specifier, base, conditions) {
   let packageJsonPath = fileURLToPath42(packageJsonUrl);
   let lastPath;
   do {
-    const stat22 = tryStatSync(packageJsonPath.slice(0, -13));
-    if (!stat22 || !stat22.isDirectory()) {
+    const stat2 = tryStatSync(packageJsonPath.slice(0, -13));
+    if (!stat2 || !stat2.isDirectory()) {
       lastPath = packageJsonPath;
       packageJsonUrl = new URL((isScoped ? "../../../../node_modules/" : "../../../node_modules/") + packageName + "/package.json", packageJsonUrl);
       packageJsonPath = fileURLToPath42(packageJsonUrl);
@@ -122922,9 +122922,9 @@ function optionInfoToSchema(optionInfo, {
       throw new Error(`Unexpected type ${optionInfo.type}`);
   }
   if (optionInfo.exception) {
-    parameters.validate = (value, schema13, utils3) => optionInfo.exception(value) || schema13.validate(value, utils3);
+    parameters.validate = (value, schema12, utils3) => optionInfo.exception(value) || schema12.validate(value, utils3);
   } else {
-    parameters.validate = (value, schema13, utils3) => value === undefined || schema13.validate(value, utils3);
+    parameters.validate = (value, schema12, utils3) => value === undefined || schema12.validate(value, utils3);
   }
   if (optionInfo.redirect) {
     handlers.redirect = (value) => !value ? undefined : {
@@ -122939,7 +122939,7 @@ function optionInfoToSchema(optionInfo, {
   }
   if (isCLI && !optionInfo.array) {
     const originalPreprocess = parameters.preprocess || ((x10) => x10);
-    parameters.preprocess = (value, schema13, utils3) => schema13.preprocess(originalPreprocess(Array.isArray(value) ? method_at_default2(0, value, -1) : value), utils3);
+    parameters.preprocess = (value, schema12, utils3) => schema12.preprocess(originalPreprocess(Array.isArray(value) ? method_at_default2(0, value, -1) : value), utils3);
   }
   return optionInfo.array ? ArraySchema.create({
     ...isCLI ? {
@@ -123904,14 +123904,14 @@ async function printToDoc(originalText, options8) {
 async function printDocToString2(doc2, options8) {
   return printDocToStringWithoutNormalizeOptions(doc2, await normalize_format_options_default(options8));
 }
-function createParsersAndPrinters(modules2) {
+function createParsersAndPrinters(modules) {
   const parsers2 = /* @__PURE__ */ Object.create(null);
   const printers2 = /* @__PURE__ */ Object.create(null);
   for (const {
     importPlugin: importPlugin2,
     parsers: parserNames = [],
     printers: printerNames = []
-  } of modules2) {
+  } of modules) {
     const loadPlugin2 = async () => {
       const plugin = await importPlugin2();
       Object.assign(parsers2, plugin.parsers);
@@ -124516,9 +124516,9 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc2,
     };
     applyNormalization();
     for (const key2 of Object.keys(this._utils.schemas)) {
-      const schema13 = this._utils.schemas[key2];
+      const schema12 = this._utils.schemas[key2];
       if (!(key2 in newOptions)) {
-        const defaultResult = normalizeDefaultResult(schema13.default(this._utils));
+        const defaultResult = normalizeDefaultResult(schema12.default(this._utils));
         if ("value" in defaultResult) {
           restOptionsArray.push({ [key2]: defaultResult.value });
         }
@@ -124529,13 +124529,13 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc2,
       if (!(key2 in newOptions)) {
         continue;
       }
-      const schema13 = this._utils.schemas[key2];
+      const schema12 = this._utils.schemas[key2];
       const value = newOptions[key2];
-      const newValue = schema13.postprocess(value, this._utils);
+      const newValue = schema12.postprocess(value, this._utils);
       if (newValue === VALUE_UNCHANGED) {
         continue;
       }
-      this._applyValidation(newValue, key2, schema13);
+      this._applyValidation(newValue, key2, schema12);
       newOptions[key2] = newValue;
     }
     this._applyPostprocess(newOptions);
@@ -124546,14 +124546,14 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc2,
     const transferredOptionsArray = [];
     const { knownKeys, unknownKeys } = this._partitionOptionKeys(options8);
     for (const key2 of knownKeys) {
-      const schema13 = this._utils.schemas[key2];
-      const value = schema13.preprocess(options8[key2], this._utils);
-      this._applyValidation(value, key2, schema13);
+      const schema12 = this._utils.schemas[key2];
+      const value = schema12.preprocess(options8[key2], this._utils);
+      this._applyValidation(value, key2, schema12);
       const appendTransferredOptions = ({ from, to: to5 }) => {
         transferredOptionsArray.push(typeof to5 === "string" ? { [to5]: from } : { [to5.key]: to5.value });
       };
       const warnDeprecated = ({ value: currentValue, redirectTo }) => {
-        const deprecatedResult = normalizeDeprecatedResult(schema13.deprecated(currentValue, this._utils), value, true);
+        const deprecatedResult = normalizeDeprecatedResult(schema12.deprecated(currentValue, this._utils), value, true);
         if (deprecatedResult === false) {
           return;
         }
@@ -124571,13 +124571,13 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc2,
           }
         }
       };
-      const forwardResult = normalizeForwardResult(schema13.forward(value, this._utils), value);
+      const forwardResult = normalizeForwardResult(schema12.forward(value, this._utils), value);
       forwardResult.forEach(appendTransferredOptions);
-      const redirectResult = normalizeRedirectResult(schema13.redirect(value, this._utils), value);
+      const redirectResult = normalizeRedirectResult(schema12.redirect(value, this._utils), value);
       redirectResult.redirect.forEach(appendTransferredOptions);
       if ("remain" in redirectResult) {
         const remainingValue = redirectResult.remain;
-        newOptions[key2] = key2 in newOptions ? schema13.overlap(newOptions[key2], remainingValue, this._utils) : remainingValue;
+        newOptions[key2] = key2 in newOptions ? schema12.overlap(newOptions[key2], remainingValue, this._utils) : remainingValue;
         warnDeprecated({ value: remainingValue });
       }
       for (const { from, to: to5 } of redirectResult.redirect) {
@@ -124605,8 +124605,8 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc2,
     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, schema13) {
-    const validateResult = normalizeValidateResult(schema13.validate(value, this._utils), value);
+  _applyValidation(value, key2, schema12) {
+    const validateResult = normalizeValidateResult(schema12.validate(value, this._utils), value);
     if (validateResult !== true) {
       throw this._invalidHandler(key2, validateResult.value, this._utils);
     }
@@ -124648,8 +124648,8 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc2,
       for (const key2 of unknownKeys) {
         const value = postprocessed.override[key2];
         this._applyUnknownHandler(key2, value, options8, (knownResultKey, knownResultValue) => {
-          const schema13 = this._utils.schemas[knownResultKey];
-          this._applyValidation(knownResultValue, knownResultKey, schema13);
+          const schema12 = this._utils.schemas[knownResultKey];
+          this._applyValidation(knownResultValue, knownResultKey, schema12);
           options8[knownResultKey] = knownResultValue;
         });
       }
@@ -128293,7 +128293,7 @@ var init_prettier = __esm(() => {
             callSuccessCallback(callback, lstat2);
             return;
           }
-          settings.fs.stat(path152, (statError, stat22) => {
+          settings.fs.stat(path152, (statError, stat2) => {
             if (statError !== null) {
               if (settings.throwErrorOnBrokenSymbolicLink) {
                 callFailureCallback(callback, statError);
@@ -128303,9 +128303,9 @@ var init_prettier = __esm(() => {
               return;
             }
             if (settings.markSymbolicLink) {
-              stat22.isSymbolicLink = () => true;
+              stat2.isSymbolicLink = () => true;
             }
-            callSuccessCallback(callback, stat22);
+            callSuccessCallback(callback, stat2);
           });
         });
       }
@@ -128328,11 +128328,11 @@ var init_prettier = __esm(() => {
           return lstat2;
         }
         try {
-          const stat22 = settings.fs.statSync(path152);
+          const stat2 = settings.fs.statSync(path152);
           if (settings.markSymbolicLink) {
-            stat22.isSymbolicLink = () => true;
+            stat2.isSymbolicLink = () => true;
           }
-          return stat22;
+          return stat2;
         } catch (error48) {
           if (!settings.throwErrorOnBrokenSymbolicLink) {
             return lstat2;
@@ -128390,14 +128390,14 @@ var init_prettier = __esm(() => {
       var sync = require_sync7();
       var settings_1 = require_settings5();
       exports.Settings = settings_1.default;
-      function stat22(path152, optionsOrSettingsOrCallback, callback) {
+      function stat2(path152, optionsOrSettingsOrCallback, callback) {
         if (typeof optionsOrSettingsOrCallback === "function") {
           async.read(path152, getSettings(), optionsOrSettingsOrCallback);
           return;
         }
         async.read(path152, getSettings(optionsOrSettingsOrCallback), callback);
       }
-      exports.stat = stat22;
+      exports.stat = stat2;
       function statSync22(path152, optionsOrSettings) {
         const settings = getSettings(optionsOrSettings);
         return sync.read(path152, settings);
@@ -128544,7 +128544,7 @@ var init_prettier = __esm(() => {
           readdirWithFileTypes(directory, settings, callback);
           return;
         }
-        readdir3(directory, settings, callback);
+        readdir2(directory, settings, callback);
       }
       exports.read = read3;
       function readdirWithFileTypes(directory, settings, callback) {
@@ -128593,7 +128593,7 @@ var init_prettier = __esm(() => {
           });
         };
       }
-      function readdir3(directory, settings, callback) {
+      function readdir2(directory, settings, callback) {
         settings.fs.readdir(directory, (readdirError, names) => {
           if (readdirError !== null) {
             callFailureCallback(callback, readdirError);
@@ -128628,7 +128628,7 @@ var init_prettier = __esm(() => {
           });
         });
       }
-      exports.readdir = readdir3;
+      exports.readdir = readdir2;
       function callFailureCallback(callback, error48) {
         callback(error48);
       }
@@ -128649,7 +128649,7 @@ var init_prettier = __esm(() => {
         if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
           return readdirWithFileTypes(directory, settings);
         }
-        return readdir3(directory, settings);
+        return readdir2(directory, settings);
       }
       exports.read = read3;
       function readdirWithFileTypes(directory, settings) {
@@ -128674,7 +128674,7 @@ var init_prettier = __esm(() => {
         });
       }
       exports.readdirWithFileTypes = readdirWithFileTypes;
-      function readdir3(directory, settings) {
+      function readdir2(directory, settings) {
         const names = settings.fs.readdirSync(directory);
         return names.map((name2) => {
           const entryPath = common2.joinPathSegments(directory, name2, settings.pathSegmentSeparator);
@@ -128690,7 +128690,7 @@ var init_prettier = __esm(() => {
           return entry;
         });
       }
-      exports.readdir = readdir3;
+      exports.readdir = readdir2;
     }
   });
   require_fs42 = __commonJS2({
@@ -134690,7 +134690,7 @@ ${codeblock}`, options8);
     "\\": "\\"
   };
   KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/;
-  read_file_default = readFile6;
+  read_file_default = readFile3;
   loadConfigFromPackageJson = process.versions.bun ? async function loadConfigFromBunPackageJson(file2) {
     const { prettier } = await readBunPackageJson(file2);
     return prettier;
@@ -136881,7 +136881,7 @@ Expected it to be ${EXPECTED_TYPE_VALUES}.`;
       return mapDoc2(doc2, (currentDoc) => cleanDocFn2(currentDoc));
     }
     function replaceEndOfLine2(doc2, replacement = literalline2) {
-      return mapDoc2(doc2, (currentDoc) => typeof currentDoc === "string" ? join28(replacement, currentDoc.split(`
+      return mapDoc2(doc2, (currentDoc) => typeof currentDoc === "string" ? join26(replacement, currentDoc.split(`
 `)) : currentDoc);
     }
     function canBreakFn2(doc2) {
@@ -136967,7 +136967,7 @@ Expected it to be ${EXPECTED_TYPE_VALUES}.`;
         negate: options8.negate
       };
     }
-    function join28(separator, docs) {
+    function join26(separator, docs) {
       assertDoc2(separator);
       assertDocArray2(docs);
       const parts = [];
@@ -137632,7 +137632,7 @@ Expected it to be ${EXPECTED_TYPE_VALUES}.`;
       }
     }
     var builders2 = {
-      join: join28,
+      join: join26,
       line: line3,
       softline: softline2,
       hardline: hardline4,
@@ -138287,11 +138287,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(resolve16) {
-        resolve16(value);
+      return value instanceof P9 ? value : new P9(function(resolve13) {
+        resolve13(value);
       });
     }
-    return new (P9 || (P9 = Promise))(function(resolve16, reject) {
+    return new (P9 || (P9 = Promise))(function(resolve13, reject) {
       function fulfilled(value) {
         try {
           step(generator.next(value));
@@ -138307,7 +138307,7 @@ var require_formatter = __commonJS((exports) => {
         }
       }
       function step(result) {
-        result.done ? resolve16(result.value) : adopt(result.value).then(fulfilled, rejected);
+        result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
       }
       step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
@@ -138362,23 +138362,23 @@ var require_JSONSchema = __commonJS((exports) => {
   exports.Parent = Symbol("Parent");
   exports.Types = Symbol("Types");
   exports.Intersection = Symbol("Intersection");
-  exports.getRootSchema = (0, lodash_1.memoize)((schema13) => {
-    const parent = schema13[exports.Parent];
+  exports.getRootSchema = (0, lodash_1.memoize)((schema12) => {
+    const parent = schema12[exports.Parent];
     if (!parent) {
-      return schema13;
+      return schema12;
     }
     return (0, exports.getRootSchema)(parent);
   });
-  function isBoolean(schema13) {
-    return schema13 === true || schema13 === false;
+  function isBoolean(schema12) {
+    return schema12 === true || schema12 === false;
   }
   exports.isBoolean = isBoolean;
-  function isPrimitive(schema13) {
-    return !(0, lodash_1.isPlainObject)(schema13);
+  function isPrimitive(schema12) {
+    return !(0, lodash_1.isPlainObject)(schema12);
   }
   exports.isPrimitive = isPrimitive;
-  function isCompound(schema13) {
-    return Array.isArray(schema13.type) || "anyOf" in schema13 || "oneOf" in schema13;
+  function isCompound(schema12) {
+    return Array.isArray(schema12.type) || "anyOf" in schema12 || "oneOf" in schema12;
   }
   exports.isCompound = isCompound;
 });
@@ -138605,9 +138605,9 @@ var require_type2 = __commonJS((exports, module) => {
 var require_schema5 = __commonJS((exports, module) => {
   var YAMLException = require_exception2();
   var Type = require_type2();
-  function compileList(schema13, name2) {
+  function compileList(schema12, name2) {
     var result = [];
-    schema13[name2].forEach(function(currentType) {
+    schema12[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) {
@@ -140552,7 +140552,7 @@ var require_dumper2 = __commonJS((exports, module) => {
     "OFF"
   ];
   var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;
-  function compileStyleMap(schema13, map2) {
+  function compileStyleMap(schema12, map2) {
     var result, keys, index, length, tag, style, type;
     if (map2 === null)
       return {};
@@ -140564,7 +140564,7 @@ var require_dumper2 = __commonJS((exports, module) => {
       if (tag.slice(0, 2) === "!!") {
         tag = "tag:yaml.org,2002:" + tag.slice(2);
       }
-      type = schema13.compiledTypeMap["fallback"][tag];
+      type = schema12.compiledTypeMap["fallback"][tag];
       if (type && _hasOwnProperty.call(type.styleAliases, style)) {
         style = type.styleAliases[style];
       }
@@ -141223,11 +141223,11 @@ var require_utils7 = __commonJS((exports) => {
   function traverseArray(arr, callback, processed) {
     arr.forEach((s5, k9) => traverse(s5, callback, processed, k9.toString()));
   }
-  function traverseIntersection(schema13, callback, processed) {
-    if (typeof schema13 !== "object" || !schema13) {
+  function traverseIntersection(schema12, callback, processed) {
+    if (typeof schema12 !== "object" || !schema12) {
       return;
     }
-    const r5 = schema13;
+    const r5 = schema12;
     const intersection2 = r5[JSONSchema_1.Intersection];
     if (!intersection2) {
       return;
@@ -141236,60 +141236,60 @@ var require_utils7 = __commonJS((exports) => {
       traverseArray(intersection2.allOf, callback, processed);
     }
   }
-  function traverse(schema13, callback, processed = new Set, key2) {
-    if (processed.has(schema13)) {
+  function traverse(schema12, callback, processed = new Set, key2) {
+    if (processed.has(schema12)) {
       return;
     }
-    processed.add(schema13);
-    callback(schema13, key2 !== null && key2 !== undefined ? key2 : null);
-    if (schema13.anyOf) {
-      traverseArray(schema13.anyOf, callback, processed);
+    processed.add(schema12);
+    callback(schema12, key2 !== null && key2 !== undefined ? key2 : null);
+    if (schema12.anyOf) {
+      traverseArray(schema12.anyOf, callback, processed);
     }
-    if (schema13.allOf) {
-      traverseArray(schema13.allOf, callback, processed);
+    if (schema12.allOf) {
+      traverseArray(schema12.allOf, callback, processed);
     }
-    if (schema13.oneOf) {
-      traverseArray(schema13.oneOf, callback, processed);
+    if (schema12.oneOf) {
+      traverseArray(schema12.oneOf, callback, processed);
     }
-    if (schema13.properties) {
-      traverseObjectKeys(schema13.properties, callback, processed);
+    if (schema12.properties) {
+      traverseObjectKeys(schema12.properties, callback, processed);
     }
-    if (schema13.patternProperties) {
-      traverseObjectKeys(schema13.patternProperties, callback, processed);
+    if (schema12.patternProperties) {
+      traverseObjectKeys(schema12.patternProperties, callback, processed);
     }
-    if (schema13.additionalProperties && typeof schema13.additionalProperties === "object") {
-      traverse(schema13.additionalProperties, callback, processed);
+    if (schema12.additionalProperties && typeof schema12.additionalProperties === "object") {
+      traverse(schema12.additionalProperties, callback, processed);
     }
-    if (schema13.items) {
-      const { items } = schema13;
+    if (schema12.items) {
+      const { items } = schema12;
       if (Array.isArray(items)) {
         traverseArray(items, callback, processed);
       } else {
         traverse(items, callback, processed);
       }
     }
-    if (schema13.additionalItems && typeof schema13.additionalItems === "object") {
-      traverse(schema13.additionalItems, callback, processed);
+    if (schema12.additionalItems && typeof schema12.additionalItems === "object") {
+      traverse(schema12.additionalItems, callback, processed);
     }
-    if (schema13.dependencies) {
-      if (Array.isArray(schema13.dependencies)) {
-        traverseArray(schema13.dependencies, callback, processed);
+    if (schema12.dependencies) {
+      if (Array.isArray(schema12.dependencies)) {
+        traverseArray(schema12.dependencies, callback, processed);
       } else {
-        traverseObjectKeys(schema13.dependencies, callback, processed);
+        traverseObjectKeys(schema12.dependencies, callback, processed);
       }
     }
-    if (schema13.definitions) {
-      traverseObjectKeys(schema13.definitions, callback, processed);
+    if (schema12.definitions) {
+      traverseObjectKeys(schema12.definitions, callback, processed);
     }
-    if (schema13.$defs) {
-      traverseObjectKeys(schema13.$defs, callback, processed);
+    if (schema12.$defs) {
+      traverseObjectKeys(schema12.$defs, callback, processed);
     }
-    if (schema13.not) {
-      traverse(schema13.not, callback, processed);
+    if (schema12.not) {
+      traverse(schema12.not, callback, processed);
     }
-    traverseIntersection(schema13, callback, processed);
-    Object.keys(schema13).filter((key3) => !BLACKLISTED_KEYS.has(key3)).forEach((key3) => {
-      const child = schema13[key3];
+    traverseIntersection(schema12, callback, processed);
+    Object.keys(schema12).filter((key3) => !BLACKLISTED_KEYS.has(key3)).forEach((key3) => {
+      const child = schema12[key3];
       if (child && typeof child === "object") {
         traverseObjectKeys(child, callback, processed);
       }
@@ -141371,14 +141371,14 @@ var require_utils7 = __commonJS((exports) => {
         return (_g2 = color()) === null || _g2 === undefined ? undefined : _g2.whiteBright.bgYellow;
     }
   }
-  function escapeBlockComment(schema13) {
+  function escapeBlockComment(schema12) {
     const replacer = "* /";
-    if (schema13 === null || typeof schema13 !== "object") {
+    if (schema12 === null || typeof schema12 !== "object") {
       return;
     }
-    for (const key2 of Object.keys(schema13)) {
-      if (key2 === "description" && typeof schema13[key2] === "string") {
-        schema13[key2] = schema13[key2].replace(/\*\//g, replacer);
+    for (const key2 of Object.keys(schema12)) {
+      if (key2 === "description" && typeof schema12[key2] === "string") {
+        schema12[key2] = schema12[key2].replace(/\*\//g, replacer);
       }
     }
   }
@@ -141390,45 +141390,45 @@ var require_utils7 = __commonJS((exports) => {
     return path_1.posix.join(path_1.posix.normalize(outputPath), ...filePathRel);
   }
   exports.pathTransform = pathTransform;
-  function maybeStripDefault(schema13) {
-    if (!("default" in schema13)) {
-      return schema13;
+  function maybeStripDefault(schema12) {
+    if (!("default" in schema12)) {
+      return schema12;
     }
-    switch (schema13.type) {
+    switch (schema12.type) {
       case "array":
-        if (Array.isArray(schema13.default)) {
-          return schema13;
+        if (Array.isArray(schema12.default)) {
+          return schema12;
         }
         break;
       case "boolean":
-        if (typeof schema13.default === "boolean") {
-          return schema13;
+        if (typeof schema12.default === "boolean") {
+          return schema12;
         }
         break;
       case "integer":
       case "number":
-        if (typeof schema13.default === "number") {
-          return schema13;
+        if (typeof schema12.default === "number") {
+          return schema12;
         }
         break;
       case "string":
-        if (typeof schema13.default === "string") {
-          return schema13;
+        if (typeof schema12.default === "string") {
+          return schema12;
         }
         break;
       case "null":
-        if (schema13.default === null) {
-          return schema13;
+        if (schema12.default === null) {
+          return schema12;
         }
         break;
       case "object":
-        if ((0, lodash_1.isPlainObject)(schema13.default)) {
-          return schema13;
+        if ((0, lodash_1.isPlainObject)(schema12.default)) {
+          return schema12;
         }
         break;
     }
-    delete schema13.default;
-    return schema13;
+    delete schema12.default;
+    return schema12;
   }
   exports.maybeStripDefault = maybeStripDefault;
   function appendToDescription(existingDescription, ...values) {
@@ -141442,11 +141442,11 @@ ${values.join(`
 `);
   }
   exports.appendToDescription = appendToDescription;
-  function isSchemaLike(schema13) {
-    if (!(0, lodash_1.isPlainObject)(schema13)) {
+  function isSchemaLike(schema12) {
+    if (!(0, lodash_1.isPlainObject)(schema12)) {
       return false;
     }
-    const parent = schema13[JSONSchema_1.Parent];
+    const parent = schema12[JSONSchema_1.Parent];
     if (parent === null) {
       return true;
     }
@@ -141463,7 +141463,7 @@ ${values.join(`
       "properties",
       "required"
     ];
-    if (JSON_SCHEMA_KEYWORDS.some((_10) => parent[_10] === schema13)) {
+    if (JSON_SCHEMA_KEYWORDS.some((_10) => parent[_10] === schema12)) {
       return false;
     }
     return true;
@@ -141761,13 +141761,13 @@ var require_typesOfSchema = __commonJS((exports) => {
   exports.typesOfSchema = undefined;
   var lodash_1 = require_lodash8();
   var JSONSchema_1 = require_JSONSchema();
-  function typesOfSchema(schema13) {
-    if (schema13.tsType) {
+  function typesOfSchema(schema12) {
+    if (schema12.tsType) {
       return new Set(["CUSTOM_TYPE"]);
     }
     const matchedTypes = new Set;
     for (const [schemaType, f7] of Object.entries(matchers)) {
-      if (f7(schema13)) {
+      if (f7(schema12)) {
         matchedTypes.add(schemaType);
       }
     }
@@ -141778,26 +141778,26 @@ var require_typesOfSchema = __commonJS((exports) => {
   }
   exports.typesOfSchema = typesOfSchema;
   var matchers = {
-    ALL_OF(schema13) {
-      return "allOf" in schema13;
+    ALL_OF(schema12) {
+      return "allOf" in schema12;
     },
-    ANY(schema13) {
-      if (Object.keys(schema13).length === 0) {
+    ANY(schema12) {
+      if (Object.keys(schema12).length === 0) {
         return true;
       }
-      return schema13.type === "any";
+      return schema12.type === "any";
     },
-    ANY_OF(schema13) {
-      return "anyOf" in schema13;
+    ANY_OF(schema12) {
+      return "anyOf" in schema12;
     },
-    BOOLEAN(schema13) {
-      if ("enum" in schema13) {
+    BOOLEAN(schema12) {
+      if ("enum" in schema12) {
         return false;
       }
-      if (schema13.type === "boolean") {
+      if (schema12.type === "boolean") {
         return true;
       }
-      if (!(0, JSONSchema_1.isCompound)(schema13) && typeof schema13.default === "boolean") {
+      if (!(0, JSONSchema_1.isCompound)(schema12) && typeof schema12.default === "boolean") {
         return true;
       }
       return false;
@@ -141805,74 +141805,74 @@ var require_typesOfSchema = __commonJS((exports) => {
     CUSTOM_TYPE() {
       return false;
     },
-    NAMED_ENUM(schema13) {
-      return "enum" in schema13 && "tsEnumNames" in schema13;
+    NAMED_ENUM(schema12) {
+      return "enum" in schema12 && "tsEnumNames" in schema12;
     },
-    NAMED_SCHEMA(schema13) {
-      return "$id" in schema13 && (("patternProperties" in schema13) || ("properties" in schema13));
+    NAMED_SCHEMA(schema12) {
+      return "$id" in schema12 && (("patternProperties" in schema12) || ("properties" in schema12));
     },
-    NEVER(schema13) {
-      return schema13 === false;
+    NEVER(schema12) {
+      return schema12 === false;
     },
-    NULL(schema13) {
-      return schema13.type === "null";
+    NULL(schema12) {
+      return schema12.type === "null";
     },
-    NUMBER(schema13) {
-      if ("enum" in schema13) {
+    NUMBER(schema12) {
+      if ("enum" in schema12) {
         return false;
       }
-      if (schema13.type === "integer" || schema13.type === "number") {
+      if (schema12.type === "integer" || schema12.type === "number") {
         return true;
       }
-      if (!(0, JSONSchema_1.isCompound)(schema13) && typeof schema13.default === "number") {
+      if (!(0, JSONSchema_1.isCompound)(schema12) && typeof schema12.default === "number") {
         return true;
       }
       return false;
     },
-    OBJECT(schema13) {
-      return schema13.type === "object" && !(0, lodash_1.isPlainObject)(schema13.additionalProperties) && !schema13.allOf && !schema13.anyOf && !schema13.oneOf && !schema13.patternProperties && !schema13.properties && !schema13.required;
+    OBJECT(schema12) {
+      return schema12.type === "object" && !(0, lodash_1.isPlainObject)(schema12.additionalProperties) && !schema12.allOf && !schema12.anyOf && !schema12.oneOf && !schema12.patternProperties && !schema12.properties && !schema12.required;
     },
-    ONE_OF(schema13) {
-      return "oneOf" in schema13;
+    ONE_OF(schema12) {
+      return "oneOf" in schema12;
     },
-    REFERENCE(schema13) {
-      return "$ref" in schema13;
+    REFERENCE(schema12) {
+      return "$ref" in schema12;
     },
-    STRING(schema13) {
-      if ("enum" in schema13) {
+    STRING(schema12) {
+      if ("enum" in schema12) {
         return false;
       }
-      if (schema13.type === "string") {
+      if (schema12.type === "string") {
         return true;
       }
-      if (!(0, JSONSchema_1.isCompound)(schema13) && typeof schema13.default === "string") {
+      if (!(0, JSONSchema_1.isCompound)(schema12) && typeof schema12.default === "string") {
         return true;
       }
       return false;
     },
-    TYPED_ARRAY(schema13) {
-      if (schema13.type && schema13.type !== "array") {
+    TYPED_ARRAY(schema12) {
+      if (schema12.type && schema12.type !== "array") {
         return false;
       }
-      return "items" in schema13;
+      return "items" in schema12;
     },
-    UNION(schema13) {
-      return Array.isArray(schema13.type);
+    UNION(schema12) {
+      return Array.isArray(schema12.type);
     },
-    UNNAMED_ENUM(schema13) {
-      if ("tsEnumNames" in schema13) {
+    UNNAMED_ENUM(schema12) {
+      if ("tsEnumNames" in schema12) {
         return false;
       }
-      if (schema13.type && schema13.type !== "boolean" && schema13.type !== "integer" && schema13.type !== "number" && schema13.type !== "string") {
+      if (schema12.type && schema12.type !== "boolean" && schema12.type !== "integer" && schema12.type !== "number" && schema12.type !== "string") {
         return false;
       }
-      return "enum" in schema13;
+      return "enum" in schema12;
     },
     UNNAMED_SCHEMA() {
       return false;
     },
-    UNTYPED_ARRAY(schema13) {
-      return schema13.type === "array" && !("items" in schema13);
+    UNTYPED_ARRAY(schema12) {
+      return schema12.type === "array" && !("items" in schema12);
     }
   };
 });
@@ -141883,10 +141883,10 @@ var require_applySchemaTyping = __commonJS((exports) => {
   exports.applySchemaTyping = undefined;
   var JSONSchema_1 = require_JSONSchema();
   var typesOfSchema_1 = require_typesOfSchema();
-  function applySchemaTyping(schema13) {
+  function applySchemaTyping(schema12) {
     var _a7;
-    const types = (0, typesOfSchema_1.typesOfSchema)(schema13);
-    Object.defineProperty(schema13, JSONSchema_1.Types, {
+    const types = (0, typesOfSchema_1.typesOfSchema)(schema12);
+    Object.defineProperty(schema12, JSONSchema_1.Types, {
       enumerable: false,
       value: types,
       writable: false
@@ -141895,23 +141895,23 @@ var require_applySchemaTyping = __commonJS((exports) => {
       return;
     }
     const intersection2 = {
-      [JSONSchema_1.Parent]: schema13,
+      [JSONSchema_1.Parent]: schema12,
       [JSONSchema_1.Types]: new Set(["ALL_OF"]),
-      $id: schema13.$id,
-      description: schema13.description,
-      name: schema13.name,
-      title: schema13.title,
-      allOf: (_a7 = schema13.allOf) !== null && _a7 !== undefined ? _a7 : [],
+      $id: schema12.$id,
+      description: schema12.description,
+      name: schema12.name,
+      title: schema12.title,
+      allOf: (_a7 = schema12.allOf) !== null && _a7 !== undefined ? _a7 : [],
       required: [],
       additionalProperties: false
     };
     types.delete("ALL_OF");
-    delete schema13.allOf;
-    delete schema13.$id;
-    delete schema13.description;
-    delete schema13.name;
-    delete schema13.title;
-    Object.defineProperty(schema13, JSONSchema_1.Intersection, {
+    delete schema12.allOf;
+    delete schema12.$id;
+    delete schema12.description;
+    delete schema12.name;
+    delete schema12.title;
+    Object.defineProperty(schema12, JSONSchema_1.Intersection, {
       enumerable: false,
       value: intersection2,
       writable: false
@@ -141929,186 +141929,186 @@ var require_normalizer = __commonJS((exports) => {
   var applySchemaTyping_1 = require_applySchemaTyping();
   var util_1 = __require("util");
   var rules = new Map;
-  function hasType(schema13, type) {
-    return schema13.type === type || Array.isArray(schema13.type) && schema13.type.includes(type);
+  function hasType(schema12, type) {
+    return schema12.type === type || Array.isArray(schema12.type) && schema12.type.includes(type);
   }
-  function isObjectType(schema13) {
-    return schema13.properties !== undefined || hasType(schema13, "object") || hasType(schema13, "any");
+  function isObjectType(schema12) {
+    return schema12.properties !== undefined || hasType(schema12, "object") || hasType(schema12, "any");
   }
-  function isArrayType(schema13) {
-    return schema13.items !== undefined || hasType(schema13, "array") || hasType(schema13, "any");
+  function isArrayType(schema12) {
+    return schema12.items !== undefined || hasType(schema12, "array") || hasType(schema12, "any");
   }
-  function isEnumTypeWithoutTsEnumNames(schema13) {
-    return schema13.type === "string" && schema13.enum !== undefined && schema13.tsEnumNames === undefined;
+  function isEnumTypeWithoutTsEnumNames(schema12) {
+    return schema12.type === "string" && schema12.enum !== undefined && schema12.tsEnumNames === undefined;
   }
-  rules.set('Remove `type=["null"]` if `enum=[null]`', (schema13) => {
-    if (Array.isArray(schema13.enum) && schema13.enum.some((e8) => e8 === null) && Array.isArray(schema13.type) && schema13.type.includes("null")) {
-      schema13.type = schema13.type.filter((type) => type !== "null");
+  rules.set('Remove `type=["null"]` if `enum=[null]`', (schema12) => {
+    if (Array.isArray(schema12.enum) && schema12.enum.some((e8) => e8 === null) && Array.isArray(schema12.type) && schema12.type.includes("null")) {
+      schema12.type = schema12.type.filter((type) => type !== "null");
     }
   });
-  rules.set("Destructure unary types", (schema13) => {
-    if (schema13.type && Array.isArray(schema13.type) && schema13.type.length === 1) {
-      schema13.type = schema13.type[0];
+  rules.set("Destructure unary types", (schema12) => {
+    if (schema12.type && Array.isArray(schema12.type) && schema12.type.length === 1) {
+      schema12.type = schema12.type[0];
     }
   });
-  rules.set("Add empty `required` property if none is defined", (schema13) => {
-    if (isObjectType(schema13) && !("required" in schema13)) {
-      schema13.required = [];
+  rules.set("Add empty `required` property if none is defined", (schema12) => {
+    if (isObjectType(schema12) && !("required" in schema12)) {
+      schema12.required = [];
     }
   });
-  rules.set("Transform `required`=false to `required`=[]", (schema13) => {
-    if (schema13.required === false) {
-      schema13.required = [];
+  rules.set("Transform `required`=false to `required`=[]", (schema12) => {
+    if (schema12.required === false) {
+      schema12.required = [];
     }
   });
-  rules.set("Default additionalProperties", (schema13, _10, options8) => {
-    if (isObjectType(schema13) && !("additionalProperties" in schema13) && schema13.patternProperties === undefined) {
-      schema13.additionalProperties = options8.additionalProperties;
+  rules.set("Default additionalProperties", (schema12, _10, options8) => {
+    if (isObjectType(schema12) && !("additionalProperties" in schema12) && schema12.patternProperties === undefined) {
+      schema12.additionalProperties = options8.additionalProperties;
     }
   });
-  rules.set("Transform id to $id", (schema13, fileName) => {
-    if (!(0, utils_1.isSchemaLike)(schema13)) {
+  rules.set("Transform id to $id", (schema12, fileName) => {
+    if (!(0, utils_1.isSchemaLike)(schema12)) {
       return;
     }
-    if (schema13.id && schema13.$id && schema13.id !== schema13.$id) {
-      throw ReferenceError(`Schema must define either id or $id, not both. Given id=${schema13.id}, $id=${schema13.$id} in ${fileName}`);
+    if (schema12.id && schema12.$id && schema12.id !== schema12.$id) {
+      throw ReferenceError(`Schema must define either id or $id, not both. Given id=${schema12.id}, $id=${schema12.$id} in ${fileName}`);
     }
-    if (schema13.id) {
-      schema13.$id = schema13.id;
-      delete schema13.id;
+    if (schema12.id) {
+      schema12.$id = schema12.id;
+      delete schema12.id;
     }
   });
-  rules.set("Add an $id to anything that needs it", (schema13, fileName, _options, _key, dereferencedPaths) => {
-    if (!(0, utils_1.isSchemaLike)(schema13)) {
+  rules.set("Add an $id to anything that needs it", (schema12, fileName, _options, _key, dereferencedPaths) => {
+    if (!(0, utils_1.isSchemaLike)(schema12)) {
       return;
     }
-    if (!schema13.$id && !schema13[JSONSchema_1.Parent]) {
-      schema13.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(fileName));
+    if (!schema12.$id && !schema12[JSONSchema_1.Parent]) {
+      schema12.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(fileName));
       return;
     }
-    if (!isArrayType(schema13) && !isObjectType(schema13)) {
+    if (!isArrayType(schema12) && !isObjectType(schema12)) {
       return;
     }
-    const dereferencedName = dereferencedPaths.get(schema13);
-    if (!schema13.$id && !schema13.title && dereferencedName) {
-      schema13.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(dereferencedName));
+    const dereferencedName = dereferencedPaths.get(schema12);
+    if (!schema12.$id && !schema12.title && dereferencedName) {
+      schema12.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(dereferencedName));
     }
     if (dereferencedName) {
-      dereferencedPaths.delete(schema13);
+      dereferencedPaths.delete(schema12);
     }
   });
-  rules.set("Escape closing JSDoc comment", (schema13) => {
-    (0, utils_1.escapeBlockComment)(schema13);
+  rules.set("Escape closing JSDoc comment", (schema12) => {
+    (0, utils_1.escapeBlockComment)(schema12);
   });
-  rules.set("Add JSDoc comments for minItems and maxItems", (schema13) => {
-    if (!isArrayType(schema13)) {
+  rules.set("Add JSDoc comments for minItems and maxItems", (schema12) => {
+    if (!isArrayType(schema12)) {
       return;
     }
     const commentsToAppend = [
-      "minItems" in schema13 ? `@minItems ${schema13.minItems}` : "",
-      "maxItems" in schema13 ? `@maxItems ${schema13.maxItems}` : ""
+      "minItems" in schema12 ? `@minItems ${schema12.minItems}` : "",
+      "maxItems" in schema12 ? `@maxItems ${schema12.maxItems}` : ""
     ].filter(Boolean);
     if (commentsToAppend.length) {
-      schema13.description = (0, utils_1.appendToDescription)(schema13.description, ...commentsToAppend);
+      schema12.description = (0, utils_1.appendToDescription)(schema12.description, ...commentsToAppend);
     }
   });
-  rules.set("Optionally remove maxItems and minItems", (schema13, _fileName, options8) => {
-    if (!isArrayType(schema13)) {
+  rules.set("Optionally remove maxItems and minItems", (schema12, _fileName, options8) => {
+    if (!isArrayType(schema12)) {
       return;
     }
-    if ("minItems" in schema13 && options8.ignoreMinAndMaxItems) {
-      delete schema13.minItems;
+    if ("minItems" in schema12 && options8.ignoreMinAndMaxItems) {
+      delete schema12.minItems;
     }
-    if ("maxItems" in schema13 && (options8.ignoreMinAndMaxItems || options8.maxItems === -1)) {
-      delete schema13.maxItems;
+    if ("maxItems" in schema12 && (options8.ignoreMinAndMaxItems || options8.maxItems === -1)) {
+      delete schema12.maxItems;
     }
   });
-  rules.set("Normalize schema.minItems", (schema13, _fileName, options8) => {
+  rules.set("Normalize schema.minItems", (schema12, _fileName, options8) => {
     if (options8.ignoreMinAndMaxItems) {
       return;
     }
-    if (!isArrayType(schema13)) {
+    if (!isArrayType(schema12)) {
       return;
     }
-    const { minItems } = schema13;
-    schema13.minItems = typeof minItems === "number" ? minItems : 0;
+    const { minItems } = schema12;
+    schema12.minItems = typeof minItems === "number" ? minItems : 0;
   });
-  rules.set("Remove maxItems if it is big enough to likely cause OOMs", (schema13, _fileName, options8) => {
+  rules.set("Remove maxItems if it is big enough to likely cause OOMs", (schema12, _fileName, options8) => {
     if (options8.ignoreMinAndMaxItems || options8.maxItems === -1) {
       return;
     }
-    if (!isArrayType(schema13)) {
+    if (!isArrayType(schema12)) {
       return;
     }
-    const { maxItems, minItems } = schema13;
+    const { maxItems, minItems } = schema12;
     if (maxItems !== undefined && maxItems - minItems > options8.maxItems) {
-      delete schema13.maxItems;
+      delete schema12.maxItems;
     }
   });
-  rules.set("Normalize schema.items", (schema13, _fileName, options8) => {
+  rules.set("Normalize schema.items", (schema12, _fileName, options8) => {
     if (options8.ignoreMinAndMaxItems) {
       return;
     }
-    const { maxItems, minItems } = schema13;
+    const { maxItems, minItems } = schema12;
     const hasMaxItems = typeof maxItems === "number" && maxItems >= 0;
     const hasMinItems = typeof minItems === "number" && minItems > 0;
-    if (schema13.items && !Array.isArray(schema13.items) && (hasMaxItems || hasMinItems)) {
-      const items = schema13.items;
+    if (schema12.items && !Array.isArray(schema12.items) && (hasMaxItems || hasMinItems)) {
+      const items = schema12.items;
       const newItems = Array(maxItems || minItems || 0).fill(items);
       if (!hasMaxItems) {
-        schema13.additionalItems = items;
+        schema12.additionalItems = items;
       }
-      schema13.items = newItems;
+      schema12.items = newItems;
     }
-    if (Array.isArray(schema13.items) && hasMaxItems && maxItems < schema13.items.length) {
-      schema13.items = schema13.items.slice(0, maxItems);
+    if (Array.isArray(schema12.items) && hasMaxItems && maxItems < schema12.items.length) {
+      schema12.items = schema12.items.slice(0, maxItems);
     }
-    return schema13;
+    return schema12;
   });
-  rules.set("Remove extends, if it is empty", (schema13) => {
-    if (!schema13.hasOwnProperty("extends")) {
+  rules.set("Remove extends, if it is empty", (schema12) => {
+    if (!schema12.hasOwnProperty("extends")) {
       return;
     }
-    if (schema13.extends == null || Array.isArray(schema13.extends) && schema13.extends.length === 0) {
-      delete schema13.extends;
+    if (schema12.extends == null || Array.isArray(schema12.extends) && schema12.extends.length === 0) {
+      delete schema12.extends;
     }
   });
-  rules.set("Make extends always an array, if it is defined", (schema13) => {
-    if (schema13.extends == null) {
+  rules.set("Make extends always an array, if it is defined", (schema12) => {
+    if (schema12.extends == null) {
       return;
     }
-    if (!Array.isArray(schema13.extends)) {
-      schema13.extends = [schema13.extends];
+    if (!Array.isArray(schema12.extends)) {
+      schema12.extends = [schema12.extends];
     }
   });
-  rules.set("Transform definitions to $defs", (schema13, fileName) => {
-    if (schema13.definitions && schema13.$defs && !(0, util_1.isDeepStrictEqual)(schema13.definitions, schema13.$defs)) {
-      throw ReferenceError(`Schema must define either definitions or $defs, not both. Given id=${schema13.id} in ${fileName}`);
+  rules.set("Transform definitions to $defs", (schema12, fileName) => {
+    if (schema12.definitions && schema12.$defs && !(0, util_1.isDeepStrictEqual)(schema12.definitions, schema12.$defs)) {
+      throw ReferenceError(`Schema must define either definitions or $defs, not both. Given id=${schema12.id} in ${fileName}`);
     }
-    if (schema13.definitions) {
-      schema13.$defs = schema13.definitions;
-      delete schema13.definitions;
+    if (schema12.definitions) {
+      schema12.$defs = schema12.definitions;
+      delete schema12.definitions;
     }
   });
-  rules.set("Transform const to singleton enum", (schema13) => {
-    if (schema13.const !== undefined) {
-      schema13.enum = [schema13.const];
-      delete schema13.const;
+  rules.set("Transform const to singleton enum", (schema12) => {
+    if (schema12.const !== undefined) {
+      schema12.enum = [schema12.const];
+      delete schema12.const;
     }
   });
-  rules.set("Add tsEnumNames to enum types", (schema13, _10, options8) => {
+  rules.set("Add tsEnumNames to enum types", (schema12, _10, options8) => {
     var _a7;
-    if (isEnumTypeWithoutTsEnumNames(schema13) && options8.inferStringEnumKeysFromValues) {
-      schema13.tsEnumNames = (_a7 = schema13.enum) === null || _a7 === undefined ? undefined : _a7.map(String);
+    if (isEnumTypeWithoutTsEnumNames(schema12) && options8.inferStringEnumKeysFromValues) {
+      schema12.tsEnumNames = (_a7 = schema12.enum) === null || _a7 === undefined ? undefined : _a7.map(String);
     }
   });
-  rules.set("Pre-calculate schema types and intersections", (schema13) => {
-    if (schema13 !== null && typeof schema13 === "object") {
-      (0, applySchemaTyping_1.applySchemaTyping)(schema13);
+  rules.set("Pre-calculate schema types and intersections", (schema12) => {
+    if (schema12 !== null && typeof schema12 === "object") {
+      (0, applySchemaTyping_1.applySchemaTyping)(schema12);
     }
   });
   function normalize2(rootSchema, dereferencedPaths, filename, options8) {
-    rules.forEach((rule) => (0, utils_1.traverse)(rootSchema, (schema13, key2) => rule(schema13, filename, options8, key2, dereferencedPaths)));
+    rules.forEach((rule) => (0, utils_1.traverse)(rootSchema, (schema12, key2) => rule(schema12, filename, options8, key2, dereferencedPaths)));
     return rootSchema;
   }
   exports.normalize = normalize2;
@@ -142190,37 +142190,37 @@ var require_parser2 = __commonJS((exports) => {
   var AST_1 = require_AST();
   var JSONSchema_1 = require_JSONSchema();
   var utils_1 = require_utils7();
-  function parse11(schema13, options8, keyName, processed = new Map, usedNames = new Set) {
-    if ((0, JSONSchema_1.isPrimitive)(schema13)) {
-      if ((0, JSONSchema_1.isBoolean)(schema13)) {
-        return parseBooleanSchema(schema13, keyName, options8);
+  function parse11(schema12, options8, keyName, processed = new Map, usedNames = new Set) {
+    if ((0, JSONSchema_1.isPrimitive)(schema12)) {
+      if ((0, JSONSchema_1.isBoolean)(schema12)) {
+        return parseBooleanSchema(schema12, keyName, options8);
       }
-      return parseLiteral(schema13, keyName);
+      return parseLiteral(schema12, keyName);
     }
-    const intersection2 = schema13[JSONSchema_1.Intersection];
-    const types = schema13[JSONSchema_1.Types];
+    const intersection2 = schema12[JSONSchema_1.Intersection];
+    const types = schema12[JSONSchema_1.Types];
     if (intersection2) {
       const ast = parseAsTypeWithCache(intersection2, "ALL_OF", options8, keyName, processed, usedNames);
       types.forEach((type) => {
-        ast.params.push(parseAsTypeWithCache(schema13, type, options8, keyName, processed, usedNames));
+        ast.params.push(parseAsTypeWithCache(schema12, type, options8, keyName, processed, usedNames));
       });
-      (0, utils_1.log)("blue", "parser", "Types:", [...types], "Input:", schema13, "Output:", ast);
+      (0, utils_1.log)("blue", "parser", "Types:", [...types], "Input:", schema12, "Output:", ast);
       return ast;
     }
     if (types.size === 1) {
       const type = [...types][0];
-      const ast = parseAsTypeWithCache(schema13, type, options8, keyName, processed, usedNames);
-      (0, utils_1.log)("blue", "parser", "Type:", type, "Input:", schema13, "Output:", ast);
+      const ast = parseAsTypeWithCache(schema12, type, options8, keyName, processed, usedNames);
+      (0, utils_1.log)("blue", "parser", "Type:", type, "Input:", schema12, "Output:", ast);
       return ast;
     }
     throw new ReferenceError("Expected intersection schema. Please file an issue on GitHub.");
   }
   exports.parse = parse11;
-  function parseAsTypeWithCache(schema13, type, options8, keyName, processed = new Map, usedNames = new Set) {
-    let cachedTypeMap = processed.get(schema13);
+  function parseAsTypeWithCache(schema12, type, options8, keyName, processed = new Map, usedNames = new Set) {
+    let cachedTypeMap = processed.get(schema12);
     if (!cachedTypeMap) {
       cachedTypeMap = new Map;
-      processed.set(schema13, cachedTypeMap);
+      processed.set(schema12, cachedTypeMap);
     }
     const cachedAST = cachedTypeMap.get(type);
     if (cachedAST) {
@@ -142228,10 +142228,10 @@ var require_parser2 = __commonJS((exports) => {
     }
     const ast = {};
     cachedTypeMap.set(type, ast);
-    return Object.assign(ast, parseNonLiteral(schema13, type, options8, keyName, processed, usedNames));
+    return Object.assign(ast, parseNonLiteral(schema12, type, options8, keyName, processed, usedNames));
   }
-  function parseBooleanSchema(schema13, keyName, options8) {
-    if (schema13) {
+  function parseBooleanSchema(schema12, keyName, options8) {
+    if (schema12) {
       return {
         keyName,
         type: options8.unknownAny ? "UNKNOWN" : "ANY"
@@ -142242,157 +142242,157 @@ var require_parser2 = __commonJS((exports) => {
       type: "NEVER"
     };
   }
-  function parseLiteral(schema13, keyName) {
+  function parseLiteral(schema12, keyName) {
     return {
       keyName,
-      params: schema13,
+      params: schema12,
       type: "LITERAL"
     };
   }
-  function parseNonLiteral(schema13, type, options8, keyName, processed, usedNames) {
-    const definitions = getDefinitionsMemoized((0, JSONSchema_1.getRootSchema)(schema13));
-    const keyNameFromDefinition = (0, lodash_1.findKey)(definitions, (_10) => _10 === schema13);
+  function parseNonLiteral(schema12, type, options8, keyName, processed, usedNames) {
+    const definitions = getDefinitionsMemoized((0, JSONSchema_1.getRootSchema)(schema12));
+    const keyNameFromDefinition = (0, lodash_1.findKey)(definitions, (_10) => _10 === schema12);
     switch (type) {
       case "ALL_OF":
         return {
-          comment: schema13.description,
-          deprecated: schema13.deprecated,
+          comment: schema12.description,
+          deprecated: schema12.deprecated,
           keyName,
-          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
-          params: schema13.allOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
+          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
+          params: schema12.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: schema13.description, deprecated: schema13.deprecated, keyName, standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8) });
+        return Object.assign(Object.assign({}, options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY), { comment: schema12.description, deprecated: schema12.deprecated, keyName, standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8) });
       case "ANY_OF":
         return {
-          comment: schema13.description,
-          deprecated: schema13.deprecated,
+          comment: schema12.description,
+          deprecated: schema12.deprecated,
           keyName,
-          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
-          params: schema13.anyOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
+          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
+          params: schema12.anyOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
           type: "UNION"
         };
       case "BOOLEAN":
         return {
-          comment: schema13.description,
-          deprecated: schema13.deprecated,
+          comment: schema12.description,
+          deprecated: schema12.deprecated,
           keyName,
-          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
           type: "BOOLEAN"
         };
       case "CUSTOM_TYPE":
         return {
-          comment: schema13.description,
-          deprecated: schema13.deprecated,
+          comment: schema12.description,
+          deprecated: schema12.deprecated,
           keyName,
-          params: schema13.tsType,
-          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
+          params: schema12.tsType,
+          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
           type: "CUSTOM_TYPE"
         };
       case "NAMED_ENUM":
         return {
-          comment: schema13.description,
-          deprecated: schema13.deprecated,
+          comment: schema12.description,
+          deprecated: schema12.deprecated,
           keyName,
-          standaloneName: standaloneName(schema13, keyNameFromDefinition !== null && keyNameFromDefinition !== undefined ? keyNameFromDefinition : keyName, usedNames, options8),
-          params: schema13.enum.map((_10, n5) => ({
+          standaloneName: standaloneName(schema12, keyNameFromDefinition !== null && keyNameFromDefinition !== undefined ? keyNameFromDefinition : keyName, usedNames, options8),
+          params: schema12.enum.map((_10, n5) => ({
             ast: parseLiteral(_10, undefined),
-            keyName: schema13.tsEnumNames[n5]
+            keyName: schema12.tsEnumNames[n5]
           })),
           type: "ENUM"
         };
       case "NAMED_SCHEMA":
-        return newInterface(schema13, options8, processed, usedNames, keyName);
+        return newInterface(schema12, options8, processed, usedNames, keyName);
       case "NEVER":
         return {
-          comment: schema13.description,
-          deprecated: schema13.deprecated,
+          comment: schema12.description,
+          deprecated: schema12.deprecated,
           keyName,
-          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
           type: "NEVER"
         };
       case "NULL":
         return {
-          comment: schema13.description,
-          deprecated: schema13.deprecated,
+          comment: schema12.description,
+          deprecated: schema12.deprecated,
           keyName,
-          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
           type: "NULL"
         };
       case "NUMBER":
         return {
-          comment: schema13.description,
-          deprecated: schema13.deprecated,
+          comment: schema12.description,
+          deprecated: schema12.deprecated,
           keyName,
-          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
           type: "NUMBER"
         };
       case "OBJECT":
         return {
-          comment: schema13.description,
+          comment: schema12.description,
           keyName,
-          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
           type: "OBJECT",
-          deprecated: schema13.deprecated
+          deprecated: schema12.deprecated
         };
       case "ONE_OF":
         return {
-          comment: schema13.description,
-          deprecated: schema13.deprecated,
+          comment: schema12.description,
+          deprecated: schema12.deprecated,
           keyName,
-          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
-          params: schema13.oneOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
+          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
+          params: schema12.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!", schema13));
+        throw Error((0, util_1.format)("Refs should have been resolved by the resolver!", schema12));
       case "STRING":
         return {
-          comment: schema13.description,
-          deprecated: schema13.deprecated,
+          comment: schema12.description,
+          deprecated: schema12.deprecated,
           keyName,
-          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
           type: "STRING"
         };
       case "TYPED_ARRAY":
-        if (Array.isArray(schema13.items)) {
-          const minItems2 = schema13.minItems;
-          const maxItems2 = schema13.maxItems;
+        if (Array.isArray(schema12.items)) {
+          const minItems2 = schema12.minItems;
+          const maxItems2 = schema12.maxItems;
           const arrayType = {
-            comment: schema13.description,
-            deprecated: schema13.deprecated,
+            comment: schema12.description,
+            deprecated: schema12.deprecated,
             keyName,
             maxItems: maxItems2,
             minItems: minItems2,
-            standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
-            params: schema13.items.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
+            standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
+            params: schema12.items.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
             type: "TUPLE"
           };
-          if (schema13.additionalItems === true) {
+          if (schema12.additionalItems === true) {
             arrayType.spreadParam = options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY;
-          } else if (schema13.additionalItems) {
-            arrayType.spreadParam = parse11(schema13.additionalItems, options8, undefined, processed, usedNames);
+          } else if (schema12.additionalItems) {
+            arrayType.spreadParam = parse11(schema12.additionalItems, options8, undefined, processed, usedNames);
           }
           return arrayType;
         } else {
           return {
-            comment: schema13.description,
-            deprecated: schema13.deprecated,
+            comment: schema12.description,
+            deprecated: schema12.deprecated,
             keyName,
-            standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
-            params: parse11(schema13.items, options8, `{keyNameFromDefinition}Items`, processed, usedNames),
+            standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
+            params: parse11(schema12.items, options8, `{keyNameFromDefinition}Items`, processed, usedNames),
             type: "ARRAY"
           };
         }
       case "UNION":
         return {
-          comment: schema13.description,
-          deprecated: schema13.deprecated,
+          comment: schema12.description,
+          deprecated: schema12.deprecated,
           keyName,
-          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
-          params: schema13.type.map((type2) => {
-            const member = Object.assign(Object.assign({}, (0, lodash_1.omit)(schema13, "$id", "description", "title")), { type: type2 });
+          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
+          params: schema12.type.map((type2) => {
+            const member = Object.assign(Object.assign({}, (0, lodash_1.omit)(schema12, "$id", "description", "title")), { type: type2 });
             (0, utils_1.maybeStripDefault)(member);
             (0, applySchemaTyping_1.applySchemaTyping)(member);
             return parse11(member, options8, undefined, processed, usedNames);
@@ -142401,80 +142401,80 @@ var require_parser2 = __commonJS((exports) => {
         };
       case "UNNAMED_ENUM":
         return {
-          comment: schema13.description,
-          deprecated: schema13.deprecated,
+          comment: schema12.description,
+          deprecated: schema12.deprecated,
           keyName,
-          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
-          params: schema13.enum.map((_10) => parseLiteral(_10, undefined)),
+          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
+          params: schema12.enum.map((_10) => parseLiteral(_10, undefined)),
           type: "UNION"
         };
       case "UNNAMED_SCHEMA":
-        return newInterface(schema13, options8, processed, usedNames, keyName, keyNameFromDefinition);
+        return newInterface(schema12, options8, processed, usedNames, keyName, keyNameFromDefinition);
       case "UNTYPED_ARRAY":
-        const minItems = schema13.minItems;
-        const maxItems = typeof schema13.maxItems === "number" ? schema13.maxItems : -1;
+        const minItems = schema12.minItems;
+        const maxItems = typeof schema12.maxItems === "number" ? schema12.maxItems : -1;
         const params = options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY;
         if (minItems > 0 || maxItems >= 0) {
           return {
-            comment: schema13.description,
-            deprecated: schema13.deprecated,
+            comment: schema12.description,
+            deprecated: schema12.deprecated,
             keyName,
-            maxItems: schema13.maxItems,
+            maxItems: schema12.maxItems,
             minItems,
             params: Array(Math.max(maxItems, minItems) || 0).fill(params),
             spreadParam: maxItems >= 0 ? undefined : params,
-            standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
+            standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
             type: "TUPLE"
           };
         }
         return {
-          comment: schema13.description,
-          deprecated: schema13.deprecated,
+          comment: schema12.description,
+          deprecated: schema12.deprecated,
           keyName,
           params,
-          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
           type: "ARRAY"
         };
     }
   }
-  function standaloneName(schema13, keyNameFromDefinition, usedNames, options8) {
+  function standaloneName(schema12, keyNameFromDefinition, usedNames, options8) {
     var _a7;
-    const name2 = ((_a7 = options8.customName) === null || _a7 === undefined ? undefined : _a7.call(options8, schema13, keyNameFromDefinition)) || schema13.title || schema13.$id || keyNameFromDefinition;
+    const name2 = ((_a7 = options8.customName) === null || _a7 === undefined ? undefined : _a7.call(options8, schema12, keyNameFromDefinition)) || schema12.title || schema12.$id || keyNameFromDefinition;
     if (name2) {
       return (0, utils_1.generateName)(name2, usedNames);
     }
   }
-  function newInterface(schema13, options8, processed, usedNames, keyName, keyNameFromDefinition) {
-    const name2 = standaloneName(schema13, keyNameFromDefinition, usedNames, options8);
+  function newInterface(schema12, options8, processed, usedNames, keyName, keyNameFromDefinition) {
+    const name2 = standaloneName(schema12, keyNameFromDefinition, usedNames, options8);
     return {
-      comment: schema13.description,
-      deprecated: schema13.deprecated,
+      comment: schema12.description,
+      deprecated: schema12.deprecated,
       keyName,
-      params: parseSchema(schema13, options8, processed, usedNames, name2),
+      params: parseSchema(schema12, options8, processed, usedNames, name2),
       standaloneName: name2,
-      superTypes: parseSuperTypes(schema13, options8, processed, usedNames),
+      superTypes: parseSuperTypes(schema12, options8, processed, usedNames),
       type: "INTERFACE"
     };
   }
-  function parseSuperTypes(schema13, options8, processed, usedNames) {
-    const superTypes = schema13.extends;
+  function parseSuperTypes(schema12, options8, processed, usedNames) {
+    const superTypes = schema12.extends;
     if (!superTypes) {
       return [];
     }
     return superTypes.map((_10) => parse11(_10, options8, undefined, processed, usedNames));
   }
-  function parseSchema(schema13, options8, processed, usedNames, parentSchemaName) {
-    let asts = (0, lodash_1.map)(schema13.properties, (value, key2) => ({
+  function parseSchema(schema12, options8, processed, usedNames, parentSchemaName) {
+    let asts = (0, lodash_1.map)(schema12.properties, (value, key2) => ({
       ast: parse11(value, options8, key2, processed, usedNames),
       isPatternProperty: false,
-      isRequired: (0, lodash_1.includes)(schema13.required || [], key2),
+      isRequired: (0, lodash_1.includes)(schema12.required || [], key2),
       isUnreachableDefinition: false,
       keyName: key2
     }));
     let singlePatternProperty = false;
-    if (schema13.patternProperties) {
-      singlePatternProperty = !schema13.additionalProperties && Object.keys(schema13.patternProperties).length === 1;
-      asts = asts.concat((0, lodash_1.map)(schema13.patternProperties, (value, key2) => {
+    if (schema12.patternProperties) {
+      singlePatternProperty = !schema12.additionalProperties && Object.keys(schema12.patternProperties).length === 1;
+      asts = asts.concat((0, lodash_1.map)(schema12.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("*/", "*\\/")}".`;
@@ -142484,14 +142484,14 @@ ${comment}` : comment;
         return {
           ast,
           isPatternProperty: !singlePatternProperty,
-          isRequired: singlePatternProperty || (0, lodash_1.includes)(schema13.required || [], key2),
+          isRequired: singlePatternProperty || (0, lodash_1.includes)(schema12.required || [], key2),
           isUnreachableDefinition: false,
           keyName: singlePatternProperty ? "[k: string]" : key2
         };
       }));
     }
     if (options8.unreachableDefinitions) {
-      asts = asts.concat((0, lodash_1.map)(schema13.$defs, (value, key2) => {
+      asts = asts.concat((0, lodash_1.map)(schema12.$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}".`;
@@ -142501,13 +142501,13 @@ ${comment}` : comment;
         return {
           ast,
           isPatternProperty: false,
-          isRequired: (0, lodash_1.includes)(schema13.required || [], key2),
+          isRequired: (0, lodash_1.includes)(schema12.required || [], key2),
           isUnreachableDefinition: true,
           keyName: key2
         };
       }));
     }
-    switch (schema13.additionalProperties) {
+    switch (schema12.additionalProperties) {
       case undefined:
       case true:
         if (singlePatternProperty) {
@@ -142524,7 +142524,7 @@ ${comment}` : comment;
         return asts;
       default:
         return asts.concat({
-          ast: parse11(schema13.additionalProperties, options8, "[k: string]", processed, usedNames),
+          ast: parse11(schema12.additionalProperties, options8, "[k: string]", processed, usedNames),
           isPatternProperty: false,
           isRequired: true,
           isUnreachableDefinition: false,
@@ -142532,22 +142532,22 @@ ${comment}` : comment;
         });
     }
   }
-  function getDefinitions(schema13, isSchema = true, processed = new Set) {
-    if (processed.has(schema13)) {
+  function getDefinitions(schema12, isSchema = true, processed = new Set) {
+    if (processed.has(schema12)) {
       return {};
     }
-    processed.add(schema13);
-    if (Array.isArray(schema13)) {
-      return schema13.reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(cur, false, processed)), {});
+    processed.add(schema12);
+    if (Array.isArray(schema12)) {
+      return schema12.reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(cur, false, processed)), {});
     }
-    if ((0, lodash_1.isPlainObject)(schema13)) {
-      return Object.assign(Object.assign({}, isSchema && hasDefinitions(schema13) ? schema13.$defs : {}), Object.keys(schema13).reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(schema13[cur], false, processed)), {}));
+    if ((0, lodash_1.isPlainObject)(schema12)) {
+      return Object.assign(Object.assign({}, isSchema && hasDefinitions(schema12) ? schema12.$defs : {}), Object.keys(schema12).reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(schema12[cur], false, processed)), {}));
     }
     return {};
   }
   var getDefinitionsMemoized = (0, lodash_1.memoize)(getDefinitions);
-  function hasDefinitions(schema13) {
-    return "$defs" in schema13;
+  function hasDefinitions(schema12) {
+    return "$defs" in schema12;
   }
 });
 
@@ -142960,7 +142960,7 @@ var require_url = __commonJS((exports) => {
   };
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.parse = undefined;
-  exports.resolve = resolve16;
+  exports.resolve = resolve13;
   exports.cwd = cwd;
   exports.getProtocol = getProtocol;
   exports.getExtension = getExtension;
@@ -142972,7 +142972,7 @@ var require_url = __commonJS((exports) => {
   exports.fromFileSystemPath = fromFileSystemPath;
   exports.toFileSystemPath = toFileSystemPath;
   exports.safePointerToPath = safePointerToPath;
-  exports.relative = relative5;
+  exports.relative = relative4;
   var convert_path_to_posix_1 = __importDefault(require_convert_path_to_posix());
   var path_1 = __importStar(__require("path"));
   var forwardSlashPattern = /\//g;
@@ -142988,7 +142988,7 @@ var require_url = __commonJS((exports) => {
   var urlDecodePatterns = [/%23/g, "#", /%24/g, "$", /%26/g, "&", /%2C/g, ",", /%40/g, "@"];
   var parse11 = (u4) => new URL(u4);
   exports.parse = parse11;
-  function resolve16(from, to5) {
+  function resolve13(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] || "";
@@ -143122,9 +143122,9 @@ var require_url = __commonJS((exports) => {
       return decodeURIComponent(value).replace(jsonPointerSlash, "/").replace(jsonPointerTilde, "~");
     });
   }
-  function relative5(from, to5) {
+  function relative4(from, to5) {
     if (!isFileSystemPath(from) || !isFileSystemPath(to5)) {
-      return resolve16(from, to5);
+      return resolve13(from, to5);
     }
     const fromDir = path_1.default.dirname(stripHash(from));
     const toPath4 = stripHash(to5);
@@ -143800,7 +143800,7 @@ var require_plugins = __commonJS((exports) => {
     let plugin;
     let lastError;
     let index = 0;
-    return new Promise((resolve16, reject) => {
+    return new Promise((resolve13, reject) => {
       runNextPlugin();
       function runNextPlugin() {
         plugin = plugins[index++];
@@ -143828,7 +143828,7 @@ var require_plugins = __commonJS((exports) => {
         }
       }
       function onSuccess(result) {
-        resolve16({
+        resolve13({
           plugin,
           result
         });
@@ -143925,7 +143925,7 @@ var require_parse7 = __commonJS((exports) => {
       extension: url3.getExtension(path18)
     };
     try {
-      const resolver = await readFile7(file2, options8, $refs);
+      const resolver = await readFile4(file2, options8, $refs);
       $ref.pathType = resolver.plugin.name;
       file2.data = resolver.result;
       const parser2 = await parseFile(file2, options8, $refs);
@@ -143938,7 +143938,7 @@ var require_parse7 = __commonJS((exports) => {
       throw err;
     }
   }
-  async function readFile7(file2, options8, $refs) {
+  async function readFile4(file2, options8, $refs) {
     let resolvers = plugins.all(options8.resolve);
     resolvers = plugins.filter(resolvers, "canRead", file2);
     plugins.sort(resolvers);
@@ -144371,7 +144371,7 @@ var require_normalize_args = __commonJS((exports) => {
   var options_js_1 = require_options();
   function normalizeArgs(_args) {
     let path18;
-    let schema13;
+    let schema12;
     let options8;
     let callback;
     const args = Array.prototype.slice.call(_args);
@@ -144381,15 +144381,15 @@ var require_normalize_args = __commonJS((exports) => {
     if (typeof args[0] === "string") {
       path18 = args[0];
       if (typeof args[2] === "object") {
-        schema13 = args[1];
+        schema12 = args[1];
         options8 = args[2];
       } else {
-        schema13 = undefined;
+        schema12 = undefined;
         options8 = args[1];
       }
     } else {
       path18 = "";
-      schema13 = args[0];
+      schema12 = args[0];
       options8 = args[1];
     }
     try {
@@ -144397,12 +144397,12 @@ var require_normalize_args = __commonJS((exports) => {
     } catch (e8) {
       console.error(`JSON Schema Ref Parser: Error normalizing options: ${e8}`);
     }
-    if (!options8.mutateInputSchema && typeof schema13 === "object") {
-      schema13 = JSON.parse(JSON.stringify(schema13));
+    if (!options8.mutateInputSchema && typeof schema12 === "object") {
+      schema12 = JSON.parse(JSON.stringify(schema12));
     }
     return {
       path: path18,
-      schema: schema13,
+      schema: schema12,
       options: options8,
       callback
     };
@@ -145161,11 +145161,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(resolve16) {
-        resolve16(value);
+      return value instanceof P9 ? value : new P9(function(resolve13) {
+        resolve13(value);
       });
     }
-    return new (P9 || (P9 = Promise))(function(resolve16, reject) {
+    return new (P9 || (P9 = Promise))(function(resolve13, reject) {
       function fulfilled(value) {
         try {
           step(generator.next(value));
@@ -145181,7 +145181,7 @@ var require_resolver = __commonJS((exports) => {
         }
       }
       function step(result) {
-        result.done ? resolve16(result.value) : adopt(result.value).then(fulfilled, rejected);
+        result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
       }
       step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
@@ -145191,12 +145191,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* (schema13, { cwd, $refOptions }) {
-      (0, utils_1.log)("green", "dereferencer", "Dereferencing input schema:", cwd, schema13);
+    return __awaiter(this, arguments, undefined, function* (schema12, { cwd, $refOptions }) {
+      (0, utils_1.log)("green", "dereferencer", "Dereferencing input schema:", cwd, schema12);
       const parser2 = new json_schema_ref_parser_1.$RefParser;
       const dereferencedPaths = new WeakMap;
-      const dereferencedSchema = yield parser2.dereference(cwd, schema13, Object.assign(Object.assign({}, $refOptions), { dereference: Object.assign(Object.assign({}, $refOptions.dereference), { onDereference($ref, schema14) {
-        dereferencedPaths.set(schema14, $ref);
+      const dereferencedSchema = yield parser2.dereference(cwd, schema12, Object.assign(Object.assign({}, $refOptions), { dereference: Object.assign(Object.assign({}, $refOptions.dereference), { onDereference($ref, schema13) {
+        dereferencedPaths.set(schema13, $ref);
       } }) }));
       return { dereferencedPaths, dereferencedSchema };
     });
@@ -145210,46 +145210,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", (schema13) => {
-    if (schema13.enum && schema13.tsEnumNames && schema13.enum.length !== schema13.tsEnumNames.length) {
+  rules.set("Enum members and tsEnumNames must be of the same length", (schema12) => {
+    if (schema12.enum && schema12.tsEnumNames && schema12.enum.length !== schema12.tsEnumNames.length) {
       return false;
     }
   });
-  rules.set("tsEnumNames must be an array of strings", (schema13) => {
-    if (schema13.tsEnumNames && schema13.tsEnumNames.some((_10) => typeof _10 !== "string")) {
+  rules.set("tsEnumNames must be an array of strings", (schema12) => {
+    if (schema12.tsEnumNames && schema12.tsEnumNames.some((_10) => typeof _10 !== "string")) {
       return false;
     }
   });
-  rules.set("When both maxItems and minItems are present, maxItems >= minItems", (schema13) => {
-    const { maxItems, minItems } = schema13;
+  rules.set("When both maxItems and minItems are present, maxItems >= minItems", (schema12) => {
+    const { maxItems, minItems } = schema12;
     if (typeof maxItems === "number" && typeof minItems === "number") {
       return maxItems >= minItems;
     }
   });
-  rules.set("When maxItems exists, maxItems >= 0", (schema13) => {
-    const { maxItems } = schema13;
+  rules.set("When maxItems exists, maxItems >= 0", (schema12) => {
+    const { maxItems } = schema12;
     if (typeof maxItems === "number") {
       return maxItems >= 0;
     }
   });
-  rules.set("When minItems exists, minItems >= 0", (schema13) => {
-    const { minItems } = schema13;
+  rules.set("When minItems exists, minItems >= 0", (schema12) => {
+    const { minItems } = schema12;
     if (typeof minItems === "number") {
       return minItems >= 0;
     }
   });
-  rules.set("deprecated must be a boolean", (schema13) => {
-    const typeOfDeprecated = typeof schema13.deprecated;
+  rules.set("deprecated must be a boolean", (schema12) => {
+    const typeOfDeprecated = typeof schema12.deprecated;
     return typeOfDeprecated === "boolean" || typeOfDeprecated === "undefined";
   });
-  function validate2(schema13, filename) {
+  function validate2(schema12, filename) {
     const errors5 = [];
     rules.forEach((rule, ruleName) => {
-      (0, utils_1.traverse)(schema13, (schema14, key2) => {
-        if (rule(schema14) === false) {
+      (0, utils_1.traverse)(schema12, (schema13, key2) => {
+        if (rule(schema13) === false) {
           errors5.push(`Error at key "${key2}" in file "${filename}": ${ruleName}`);
         }
-        return schema14;
+        return schema13;
       });
     });
     return errors5;
@@ -145263,25 +145263,25 @@ var require_linker = __commonJS((exports) => {
   exports.link = undefined;
   var JSONSchema_1 = require_JSONSchema();
   var lodash_1 = require_lodash8();
-  function link2(schema13, parent = null) {
-    if (!Array.isArray(schema13) && !(0, lodash_1.isPlainObject)(schema13)) {
-      return schema13;
+  function link2(schema12, parent = null) {
+    if (!Array.isArray(schema12) && !(0, lodash_1.isPlainObject)(schema12)) {
+      return schema12;
     }
-    if (schema13.hasOwnProperty(JSONSchema_1.Parent)) {
-      return schema13;
+    if (schema12.hasOwnProperty(JSONSchema_1.Parent)) {
+      return schema12;
     }
-    Object.defineProperty(schema13, JSONSchema_1.Parent, {
+    Object.defineProperty(schema12, JSONSchema_1.Parent, {
       enumerable: false,
       value: parent,
       writable: false
     });
-    if (Array.isArray(schema13)) {
-      schema13.forEach((child) => link2(child, schema13));
+    if (Array.isArray(schema12)) {
+      schema12.forEach((child) => link2(child, schema12));
     }
-    for (const key2 in schema13) {
-      link2(schema13[key2], schema13);
+    for (const key2 in schema12) {
+      link2(schema12[key2], schema12);
     }
-    return schema13;
+    return schema12;
   }
   exports.link = link2;
 });
@@ -145302,11 +145302,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(resolve16) {
-        resolve16(value);
+      return value instanceof P9 ? value : new P9(function(resolve13) {
+        resolve13(value);
       });
     }
-    return new (P9 || (P9 = Promise))(function(resolve16, reject) {
+    return new (P9 || (P9 = Promise))(function(resolve13, reject) {
       function fulfilled(value) {
         try {
           step(generator.next(value));
@@ -145322,7 +145322,7 @@ var require_src3 = __commonJS((exports) => {
         }
       }
       function step(result) {
-        result.done ? resolve16(result.value) : adopt(result.value).then(fulfilled, rejected);
+        result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
       }
       step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
@@ -145373,8 +145373,8 @@ var require_src3 = __commonJS((exports) => {
     unknownAny: true
   };
   function compileFromFile(filename, options8 = exports.DEFAULT_OPTIONS) {
-    const schema13 = parseAsJSONSchema(filename);
-    return compile(schema13, (0, utils_1.stripExtension)(filename), Object.assign({ cwd: (0, path_1.dirname)(filename) }, options8));
+    const schema12 = parseAsJSONSchema(filename);
+    return compile(schema12, (0, utils_1.stripExtension)(filename), Object.assign({ cwd: (0, path_1.dirname)(filename) }, options8));
   }
   exports.compileFromFile = compileFromFile;
   function parseAsJSONSchema(filename) {
@@ -145384,7 +145384,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* (schema13, name2, options8 = {}) {
+    return __awaiter(this, arguments, undefined, function* (schema12, name2, options8 = {}) {
       (0, optionValidator_1.validateOptions)(options8);
       const _options = (0, lodash_1.merge)({}, exports.DEFAULT_OPTIONS, options8);
       const start = Date.now();
@@ -145394,7 +145394,7 @@ var require_src3 = __commonJS((exports) => {
       if (!(0, lodash_1.endsWith)(_options.cwd, "/")) {
         _options.cwd += "/";
       }
-      const _schema = (0, lodash_1.cloneDeep)(schema13);
+      const _schema = (0, lodash_1.cloneDeep)(schema12);
       const { dereferencedPaths, dereferencedSchema } = yield (0, resolver_1.dereference)(_schema, _options);
       if (process.env.VERBOSE) {
         if ((0, util_1.isDeepStrictEqual)(_schema, dereferencedSchema)) {
@@ -146451,7 +146451,7 @@ var require_depd = __commonJS((exports, module) => {
    * Copyright(c) 2014-2018 Douglas Christopher Wilson
    * MIT Licensed
    */
-  var relative5 = __require("path").relative;
+  var relative4 = __require("path").relative;
   module.exports = depd;
   var basePath = process.cwd();
   function containsNamespace(str, namespace) {
@@ -146647,7 +146647,7 @@ var require_depd = __commonJS((exports, module) => {
     return formatted;
   }
   function formatLocation(callSite) {
-    return relative5(basePath, callSite[0]) + ":" + callSite[1] + ":" + callSite[2];
+    return relative4(basePath, callSite[0]) + ":" + callSite[1] + ":" + callSite[2];
   }
   function getStack() {
     var limit = Error.stackTraceLimit;
@@ -150643,7 +150643,7 @@ var require_dbcs_data = __commonJS((exports, module) => {
 // ../../node_modules/iconv-lite/encodings/index.js
 var require_encodings = __commonJS((exports, module) => {
   var mergeModules = require_merge_exports();
-  var modules2 = [
+  var modules = [
     require_internal(),
     require_utf32(),
     require_utf16(),
@@ -150654,8 +150654,8 @@ var require_encodings = __commonJS((exports, module) => {
     require_dbcs_codec(),
     require_dbcs_data()
   ];
-  for (i5 = 0;i5 < modules2.length; i5++) {
-    module = modules2[i5];
+  for (i5 = 0;i5 < modules.length; i5++) {
+    module = modules[i5];
     mergeModules(exports, module);
   }
   var module;
@@ -150984,11 +150984,11 @@ var require_raw_body = __commonJS((exports, module) => {
     if (done) {
       return readStream(stream, encoding, length, limit, wrap(done));
     }
-    return new Promise(function executor(resolve16, reject) {
+    return new Promise(function executor(resolve13, reject) {
       readStream(stream, encoding, length, limit, function onRead2(err, buf) {
         if (err)
           return reject(err);
-        resolve16(buf);
+        resolve13(buf);
       });
     });
   }
@@ -160792,7 +160792,7 @@ var require_mime_types = __commonJS((exports) => {
    * MIT Licensed
    */
   var db2 = require_db();
-  var extname3 = __require("path").extname;
+  var extname2 = __require("path").extname;
   var mimeScore = require_mimeScore();
   var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/;
   var TEXT_TYPE_REGEXP = /^text\//i;
@@ -160849,7 +160849,7 @@ var require_mime_types = __commonJS((exports) => {
     if (!path18 || typeof path18 !== "string") {
       return false;
     }
-    var extension2 = extname3("x." + path18).toLowerCase().slice(1);
+    var extension2 = extname2("x." + path18).toLowerCase().slice(1);
     if (!extension2) {
       return false;
     }
@@ -164109,16 +164109,16 @@ var require_view = __commonJS((exports, module) => {
   var debug = require_src4()("express:view");
   var path18 = __require("node:path");
   var fs28 = __require("node:fs");
-  var dirname21 = path18.dirname;
+  var dirname20 = path18.dirname;
   var basename6 = path18.basename;
-  var extname3 = path18.extname;
-  var join29 = path18.join;
-  var resolve16 = path18.resolve;
+  var extname2 = path18.extname;
+  var join27 = path18.join;
+  var resolve13 = path18.resolve;
   module.exports = View;
   function View(name2, options8) {
     var opts = options8 || {};
     this.defaultEngine = opts.defaultEngine;
-    this.ext = extname3(name2);
+    this.ext = extname2(name2);
     this.name = name2;
     this.root = opts.root;
     if (!this.ext && !this.defaultEngine) {
@@ -164147,8 +164147,8 @@ 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 = resolve16(root2, name2);
-      var dir = dirname21(loc);
+      var loc = resolve13(root2, name2);
+      var dir = dirname20(loc);
       var file2 = basename6(loc);
       path19 = this.resolve(dir, file2);
     }
@@ -164172,16 +164172,16 @@ var require_view = __commonJS((exports, module) => {
     });
     sync = false;
   };
-  View.prototype.resolve = function resolve17(dir, file2) {
+  View.prototype.resolve = function resolve14(dir, file2) {
     var ext = this.ext;
-    var path19 = join29(dir, file2);
-    var stat4 = tryStat(path19);
-    if (stat4 && stat4.isFile()) {
+    var path19 = join27(dir, file2);
+    var stat2 = tryStat(path19);
+    if (stat2 && stat2.isFile()) {
       return path19;
     }
-    path19 = join29(dir, basename6(file2, ext), "index" + ext);
-    stat4 = tryStat(path19);
-    if (stat4 && stat4.isFile()) {
+    path19 = join27(dir, basename6(file2, ext), "index" + ext);
+    stat2 = tryStat(path19);
+    if (stat2 && stat2.isFile()) {
       return path19;
     }
   };
@@ -164232,9 +164232,9 @@ var require_etag = __commonJS((exports, module) => {
     }
     return obj && typeof obj === "object" && "ctime" in obj && toString2.call(obj.ctime) === "[object Date]" && "mtime" in obj && toString2.call(obj.mtime) === "[object Date]" && "ino" in obj && typeof obj.ino === "number" && "size" in obj && typeof obj.size === "number";
   }
-  function stattag(stat4) {
-    var mtime = stat4.mtime.getTime().toString(16);
-    var size = stat4.size.toString(16);
+  function stattag(stat2) {
+    var mtime = stat2.mtime.getTime().toString(16);
+    var size = stat2.size.toString(16);
     return '"' + size + "-" + mtime + '"';
   }
 });
@@ -166331,7 +166331,7 @@ var require_application = __commonJS((exports, module) => {
   var compileETag = require_utils10().compileETag;
   var compileQueryParser = require_utils10().compileQueryParser;
   var compileTrust = require_utils10().compileTrust;
-  var resolve16 = __require("node:path").resolve;
+  var resolve13 = __require("node:path").resolve;
   var once9 = require_once();
   var Router = require_router();
   var slice = Array.prototype.slice;
@@ -166385,7 +166385,7 @@ var require_application = __commonJS((exports, module) => {
     this.mountpath = "/";
     this.locals.settings = this.settings;
     this.set("view", View);
-    this.set("views", resolve16("views"));
+    this.set("views", resolve13("views"));
     this.set("jsonp callback name", "callback");
     if (env4 === "production") {
       this.enable("view cache");
@@ -167873,11 +167873,11 @@ var require_send = __commonJS((exports, module) => {
   var statuses = require_statuses();
   var Stream2 = __require("stream");
   var util2 = __require("util");
-  var extname3 = path18.extname;
-  var join29 = path18.join;
+  var extname2 = path18.extname;
+  var join27 = path18.join;
   var normalize2 = path18.normalize;
-  var resolve16 = path18.resolve;
-  var sep2 = path18.sep;
+  var resolve13 = path18.resolve;
+  var sep = path18.sep;
   var BYTES_RANGE_REGEXP = /^ *bytes=/;
   var MAX_MAXAGE = 60 * 60 * 24 * 365 * 1000;
   var UP_PATH_REGEXP = /(?:^|[\\/])\.\.(?:[\\/]|$)/;
@@ -167905,7 +167905,7 @@ var require_send = __commonJS((exports, module) => {
     this._maxage = opts.maxAge || opts.maxage;
     this._maxage = typeof this._maxage === "string" ? ms9(this._maxage) : Number(this._maxage);
     this._maxage = !isNaN(this._maxage) ? Math.min(Math.max(0, this._maxage), MAX_MAXAGE) : 0;
-    this._root = opts.root ? resolve16(opts.root) : null;
+    this._root = opts.root ? resolve13(opts.root) : null;
   }
   util2.inherits(SendStream, Stream2);
   SendStream.prototype.error = function error48(status, err) {
@@ -168038,23 +168038,23 @@ var require_send = __commonJS((exports, module) => {
     var parts;
     if (root2 !== null) {
       if (path19) {
-        path19 = normalize2("." + sep2 + path19);
+        path19 = normalize2("." + sep + path19);
       }
       if (UP_PATH_REGEXP.test(path19)) {
         debug('malicious path "%s"', path19);
         this.error(403);
         return res;
       }
-      parts = path19.split(sep2);
-      path19 = normalize2(join29(root2, path19));
+      parts = path19.split(sep);
+      path19 = normalize2(join27(root2, path19));
     } else {
       if (UP_PATH_REGEXP.test(path19)) {
         debug('malicious path "%s"', path19);
         this.error(403);
         return res;
       }
-      parts = normalize2(path19).split(sep2);
-      path19 = resolve16(path19);
+      parts = normalize2(path19).split(sep);
+      path19 = resolve13(path19);
     }
     if (containsDotFile(parts)) {
       debug('%s dotfile "%s"', this._dotfiles, path19);
@@ -168077,8 +168077,8 @@ var require_send = __commonJS((exports, module) => {
     this.sendFile(path19);
     return res;
   };
-  SendStream.prototype.send = function send2(path19, stat4) {
-    var len = stat4.size;
+  SendStream.prototype.send = function send2(path19, stat2) {
+    var len = stat2.size;
     var options8 = this.options;
     var opts = {};
     var res = this.res;
@@ -168090,7 +168090,7 @@ var require_send = __commonJS((exports, module) => {
       return;
     }
     debug('pipe "%s"', path19);
-    this.setHeader(path19, stat4);
+    this.setHeader(path19, stat2);
     this.type(path19);
     if (this.isConditionalGET()) {
       if (this.isPreconditionFailure()) {
@@ -168147,19 +168147,19 @@ var require_send = __commonJS((exports, module) => {
     var i5 = 0;
     var self2 = this;
     debug('stat "%s"', path19);
-    fs28.stat(path19, function onstat(err, stat4) {
-      var pathEndsWithSep = path19[path19.length - 1] === sep2;
-      if (err && err.code === "ENOENT" && !extname3(path19) && !pathEndsWithSep) {
+    fs28.stat(path19, function onstat(err, stat2) {
+      var pathEndsWithSep = path19[path19.length - 1] === sep;
+      if (err && err.code === "ENOENT" && !extname2(path19) && !pathEndsWithSep) {
         return next(err);
       }
       if (err)
         return self2.onStatError(err);
-      if (stat4.isDirectory())
+      if (stat2.isDirectory())
         return self2.redirect(path19);
       if (pathEndsWithSep)
         return self2.error(404);
-      self2.emit("file", path19, stat4);
-      self2.send(path19, stat4);
+      self2.emit("file", path19, stat2);
+      self2.send(path19, stat2);
     });
     function next(err) {
       if (self2._extensions.length <= i5) {
@@ -168167,13 +168167,13 @@ var require_send = __commonJS((exports, module) => {
       }
       var p4 = path19 + "." + self2._extensions[i5++];
       debug('stat "%s"', p4);
-      fs28.stat(p4, function(err2, stat4) {
+      fs28.stat(p4, function(err2, stat2) {
         if (err2)
           return next(err2);
-        if (stat4.isDirectory())
+        if (stat2.isDirectory())
           return next();
-        self2.emit("file", p4, stat4);
-        self2.send(p4, stat4);
+        self2.emit("file", p4, stat2);
+        self2.send(p4, stat2);
       });
     }
   };
@@ -168186,15 +168186,15 @@ var require_send = __commonJS((exports, module) => {
           return self2.onStatError(err);
         return self2.error(404);
       }
-      var p4 = join29(path19, self2._index[i5]);
+      var p4 = join27(path19, self2._index[i5]);
       debug('stat "%s"', p4);
-      fs28.stat(p4, function(err2, stat4) {
+      fs28.stat(p4, function(err2, stat2) {
         if (err2)
           return next(err2);
-        if (stat4.isDirectory())
+        if (stat2.isDirectory())
           return next();
-        self2.emit("file", p4, stat4);
-        self2.send(p4, stat4);
+        self2.emit("file", p4, stat2);
+        self2.send(p4, stat2);
       });
     }
     next();
@@ -168221,14 +168221,14 @@ var require_send = __commonJS((exports, module) => {
     var res = this.res;
     if (res.getHeader("Content-Type"))
       return;
-    var ext = extname3(path19);
+    var ext = extname2(path19);
     var type2 = mime.contentType(ext) || "application/octet-stream";
     debug("content-type %s", type2);
     res.setHeader("Content-Type", type2);
   };
-  SendStream.prototype.setHeader = function setHeader(path19, stat4) {
+  SendStream.prototype.setHeader = function setHeader(path19, stat2) {
     var res = this.res;
-    this.emit("headers", res, path19, stat4);
+    this.emit("headers", res, path19, stat2);
     if (this._acceptRanges && !res.getHeader("Accept-Ranges")) {
       debug("accept ranges");
       res.setHeader("Accept-Ranges", "bytes");
@@ -168242,12 +168242,12 @@ var require_send = __commonJS((exports, module) => {
       res.setHeader("Cache-Control", cacheControl);
     }
     if (this._lastModified && !res.getHeader("Last-Modified")) {
-      var modified = stat4.mtime.toUTCString();
+      var modified = stat2.mtime.toUTCString();
       debug("modified %s", modified);
       res.setHeader("Last-Modified", modified);
     }
     if (this._etag && !res.getHeader("ETag")) {
-      var val = etag(stat4);
+      var val = etag(stat2);
       debug("etag %s", val);
       res.setHeader("ETag", val);
     }
@@ -168381,8 +168381,8 @@ var require_response = __commonJS((exports, module) => {
   var setCharset = require_utils10().setCharset;
   var cookie = require_cookie();
   var send = require_send();
-  var extname3 = path18.extname;
-  var resolve16 = path18.resolve;
+  var extname2 = path18.extname;
+  var resolve13 = path18.resolve;
   var vary = require_vary();
   var { Buffer: Buffer7 } = __require("node:buffer");
   var res = Object.create(http.ServerResponse.prototype);
@@ -168591,7 +168591,7 @@ var require_response = __commonJS((exports, module) => {
     }
     opts = Object.create(opts);
     opts.headers = headers;
-    var fullPath = !opts.root ? resolve16(path19) : path19;
+    var fullPath = !opts.root ? resolve13(path19) : path19;
     return this.sendFile(fullPath, opts, done);
   };
   res.contentType = res.type = function contentType(type) {
@@ -168622,7 +168622,7 @@ var require_response = __commonJS((exports, module) => {
   };
   res.attachment = function attachment(filename) {
     if (filename) {
-      this.type(extname3(filename));
+      this.type(extname2(filename));
     }
     this.set("Content-Disposition", contentDisposition(filename));
     return this;
@@ -168852,7 +168852,7 @@ var require_serve_static = __commonJS((exports, module) => {
   var encodeUrl = require_encodeurl();
   var escapeHtml = require_escape_html();
   var parseUrl = require_parseurl();
-  var resolve16 = __require("path").resolve;
+  var resolve13 = __require("path").resolve;
   var send = require_send();
   var url3 = __require("url");
   module.exports = serveStatic;
@@ -168871,7 +168871,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 = resolve16(root2);
+    opts.root = resolve13(root2);
     var onDirectory = redirect ? createRedirectDirectoryListener() : createNotFoundDirectoryListener();
     return function serveStatic2(req, res, next) {
       if (req.method !== "GET" && req.method !== "HEAD") {
@@ -169795,8 +169795,8 @@ var require_follow_redirects = __commonJS((exports, module) => {
     }
     return parsed;
   }
-  function resolveUrl(relative5, base) {
-    return useNativeURL ? new URL2(relative5, base) : parseUrl(url3.resolve(base, relative5));
+  function resolveUrl(relative4, base) {
+    return useNativeURL ? new URL2(relative4, base) : parseUrl(url3.resolve(base, relative4));
   }
   function validateUrl(input) {
     if (/^\[/.test(input.hostname) && !/^\[[:0-9a-f]+\]$/i.test(input.hostname)) {
@@ -172245,8 +172245,8 @@ var require_executor = __commonJS((exports, module) => {
     }
     resetBuffer() {
       this.buffer = new Waterfall;
-      this.buffer.chain(new Promise((resolve16) => {
-        this._triggerBuffer = resolve16;
+      this.buffer.chain(new Promise((resolve13) => {
+        this._triggerBuffer = resolve13;
       }));
       if (this.ready)
         this._triggerBuffer();
@@ -173266,7 +173266,7 @@ var require_storage = __commonJS((exports, module) => {
       throw e8;
     }
   };
-  var writeFileLinesAsync = (filename, lines, mode = DEFAULT_FILE_MODE) => new Promise((resolve16, reject) => {
+  var writeFileLinesAsync = (filename, lines, mode = DEFAULT_FILE_MODE) => new Promise((resolve13, reject) => {
     try {
       const stream = writeFileStream(filename, { mode });
       const readable2 = Readable6.from(lines);
@@ -173283,7 +173283,7 @@ var require_storage = __commonJS((exports, module) => {
           if (err)
             reject(err);
           else
-            resolve16();
+            resolve13();
         });
       });
       readable2.on("error", (err) => {
@@ -173454,7 +173454,7 @@ var require_persistence = __commonJS((exports, module) => {
       return { data: tdata, indexes };
     }
     treatRawStreamAsync(rawStream) {
-      return new Promise((resolve16, reject) => {
+      return new Promise((resolve13, reject) => {
         const dataById = {};
         const indexes = {};
         let corruptItems = 0;
@@ -173497,7 +173497,7 @@ var require_persistence = __commonJS((exports, module) => {
             }
           }
           const data = Object.values(dataById);
-          resolve16({ data, indexes });
+          resolve13({ data, indexes });
         });
         lineStream.on("error", function(err) {
           reject(err, null);
@@ -183030,7 +183030,7 @@ var require_mime_types2 = __commonJS((exports) => {
    * MIT Licensed
    */
   var db2 = require_db2();
-  var extname3 = __require("path").extname;
+  var extname2 = __require("path").extname;
   var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/;
   var TEXT_TYPE_REGEXP = /^text\//i;
   exports.charset = charset;
@@ -183085,7 +183085,7 @@ var require_mime_types2 = __commonJS((exports) => {
     if (!path18 || typeof path18 !== "string") {
       return false;
     }
-    var extension2 = extname3("x." + path18).toLowerCase().substr(1);
+    var extension2 = extname2("x." + path18).toLowerCase().substr(1);
     if (!extension2) {
       return false;
     }
@@ -193077,7 +193077,7 @@ var require_mime_types3 = __commonJS((exports) => {
    * MIT Licensed
    */
   var db2 = require_db3();
-  var extname3 = __require("path").extname;
+  var extname2 = __require("path").extname;
   var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/;
   var TEXT_TYPE_REGEXP = /^text\//i;
   exports.charset = charset;
@@ -193132,7 +193132,7 @@ var require_mime_types3 = __commonJS((exports) => {
     if (!path18 || typeof path18 !== "string") {
       return false;
     }
-    var extension2 = extname3("x." + path18).toLowerCase().substr(1);
+    var extension2 = extname2("x." + path18).toLowerCase().substr(1);
     if (!extension2) {
       return false;
     }
@@ -195655,7 +195655,7 @@ var require_websocket2 = __commonJS((exports, module) => {
   var http = __require("http");
   var net2 = __require("net");
   var tls = __require("tls");
-  var { randomBytes: randomBytes2, createHash: createHash2 } = __require("crypto");
+  var { randomBytes: randomBytes2, createHash } = __require("crypto");
   var { Duplex: Duplex4, Readable: Readable6 } = __require("stream");
   var { URL: URL2 } = __require("url");
   var PerMessageDeflate = require_permessage_deflate();
@@ -196187,7 +196187,7 @@ var require_websocket2 = __commonJS((exports, module) => {
         abortHandshake(websocket, socket, "Invalid Upgrade header");
         return;
       }
-      const digest = createHash2("sha1").update(key2 + GUID).digest("base64");
+      const digest = createHash("sha1").update(key2 + GUID).digest("base64");
       if (res.headers["sec-websocket-accept"] !== digest) {
         abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
         return;
@@ -196560,7 +196560,7 @@ var require_websocket_server = __commonJS((exports, module) => {
   var EventEmitter3 = __require("events");
   var http = __require("http");
   var { Duplex: Duplex4 } = __require("stream");
-  var { createHash: createHash2 } = __require("crypto");
+  var { createHash } = __require("crypto");
   var extension = require_extension();
   var PerMessageDeflate = require_permessage_deflate();
   var subprotocol = require_subprotocol();
@@ -196768,7 +196768,7 @@ var require_websocket_server = __commonJS((exports, module) => {
       }
       if (this._state > RUNNING)
         return abortHandshake(socket, 503);
-      const digest = createHash2("sha1").update(key2 + GUID).digest("base64");
+      const digest = createHash("sha1").update(key2 + GUID).digest("base64");
       const headers = [
         "HTTP/1.1 101 Switching Protocols",
         "Upgrade: websocket",
@@ -199108,13 +199108,13 @@ var require_broadcast_operator = __commonJS((exports) => {
       return true;
     }
     emitWithAck(ev2, ...args) {
-      return new Promise((resolve16, reject) => {
+      return new Promise((resolve13, reject) => {
         args.push((err, responses) => {
           if (err) {
             err.responses = responses;
             return reject(err);
           } else {
-            return resolve16(responses);
+            return resolve13(responses);
           }
         });
         this.emit(ev2, ...args);
@@ -199302,12 +199302,12 @@ var require_socket2 = __commonJS((exports) => {
     }
     emitWithAck(ev2, ...args) {
       const withErr = this.flags.timeout !== undefined;
-      return new Promise((resolve16, reject) => {
+      return new Promise((resolve13, reject) => {
         args.push((arg1, arg2) => {
           if (withErr) {
-            return arg1 ? reject(arg1) : resolve16(arg2);
+            return arg1 ? reject(arg1) : resolve13(arg2);
           } else {
-            return resolve16(arg1);
+            return resolve13(arg1);
           }
         });
         this.emit(ev2, ...args);
@@ -199762,13 +199762,13 @@ var require_namespace = __commonJS((exports) => {
       return true;
     }
     serverSideEmitWithAck(ev2, ...args) {
-      return new Promise((resolve16, reject) => {
+      return new Promise((resolve13, reject) => {
         args.push((err, responses) => {
           if (err) {
             err.responses = responses;
             return reject(err);
           } else {
-            return resolve16(responses);
+            return resolve13(responses);
           }
         });
         this.serverSideEmit(ev2, ...args);
@@ -201483,7 +201483,7 @@ var require_websocket4 = __commonJS((exports, module) => {
   var http = __require("http");
   var net2 = __require("net");
   var tls = __require("tls");
-  var { randomBytes: randomBytes2, createHash: createHash2 } = __require("crypto");
+  var { randomBytes: randomBytes2, createHash } = __require("crypto");
   var { Duplex: Duplex4, Readable: Readable6 } = __require("stream");
   var { URL: URL2 } = __require("url");
   var PerMessageDeflate = require_permessage_deflate2();
@@ -202015,7 +202015,7 @@ var require_websocket4 = __commonJS((exports, module) => {
         abortHandshake(websocket, socket, "Invalid Upgrade header");
         return;
       }
-      const digest = createHash2("sha1").update(key2 + GUID).digest("base64");
+      const digest = createHash("sha1").update(key2 + GUID).digest("base64");
       if (res.headers["sec-websocket-accept"] !== digest) {
         abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
         return;
@@ -202388,7 +202388,7 @@ var require_websocket_server2 = __commonJS((exports, module) => {
   var EventEmitter3 = __require("events");
   var http = __require("http");
   var { Duplex: Duplex4 } = __require("stream");
-  var { createHash: createHash2 } = __require("crypto");
+  var { createHash } = __require("crypto");
   var extension = require_extension2();
   var PerMessageDeflate = require_permessage_deflate2();
   var subprotocol = require_subprotocol2();
@@ -202596,7 +202596,7 @@ var require_websocket_server2 = __commonJS((exports, module) => {
       }
       if (this._state > RUNNING)
         return abortHandshake(socket, 503);
-      const digest = createHash2("sha1").update(key2 + GUID).digest("base64");
+      const digest = createHash("sha1").update(key2 + GUID).digest("base64");
       const headers = [
         "HTTP/1.1 101 Switching Protocols",
         "Upgrade: websocket",
@@ -203303,7 +203303,7 @@ var require_cluster_adapter = __commonJS((exports) => {
         return localSockets;
       }
       const requestId = randomId();
-      return new Promise((resolve16, reject) => {
+      return new Promise((resolve13, reject) => {
         const timeout3 = setTimeout(() => {
           const storedRequest2 = this.requests.get(requestId);
           if (storedRequest2) {
@@ -203313,7 +203313,7 @@ var require_cluster_adapter = __commonJS((exports) => {
         }, opts.flags.timeout || DEFAULT_TIMEOUT);
         const storedRequest = {
           type: MessageType.FETCH_SOCKETS,
-          resolve: resolve16,
+          resolve: resolve13,
           timeout: timeout3,
           current: 0,
           expected: expectedResponseCount,
@@ -203523,7 +203523,7 @@ var require_cluster_adapter = __commonJS((exports) => {
         return localSockets;
       }
       const requestId = randomId();
-      return new Promise((resolve16, reject) => {
+      return new Promise((resolve13, reject) => {
         const timeout3 = setTimeout(() => {
           const storedRequest2 = this.customRequests.get(requestId);
           if (storedRequest2) {
@@ -203533,7 +203533,7 @@ var require_cluster_adapter = __commonJS((exports) => {
         }, opts.flags.timeout || DEFAULT_TIMEOUT);
         const storedRequest = {
           type: MessageType.FETCH_SOCKETS,
-          resolve: resolve16,
+          resolve: resolve13,
           timeout: timeout3,
           missingUids: new Set([...this.nodesMap.keys()]),
           responses: localSockets
@@ -204262,13 +204262,13 @@ var require_dist4 = __commonJS((exports, module) => {
       this.engine.close();
       (0, uws_1.restoreAdapter)();
       if (this.httpServer) {
-        return new Promise((resolve16) => {
+        return new Promise((resolve13) => {
           this.httpServer.close((err) => {
             fn9 && fn9(err);
             if (err) {
               debug("server was not running");
             }
-            resolve16();
+            resolve13();
           });
         });
       } else {
@@ -213004,7 +213004,7 @@ var require_mime_types4 = __commonJS((exports) => {
    * MIT Licensed
    */
   var db2 = require_db4();
-  var extname3 = __require("path").extname;
+  var extname2 = __require("path").extname;
   var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/;
   var TEXT_TYPE_REGEXP = /^text\//i;
   exports.charset = charset;
@@ -213059,7 +213059,7 @@ var require_mime_types4 = __commonJS((exports) => {
     if (!path18 || typeof path18 !== "string") {
       return false;
     }
-    var extension2 = extname3("x." + path18).toLowerCase().substr(1);
+    var extension2 = extname2("x." + path18).toLowerCase().substr(1);
     if (!extension2) {
       return false;
     }
@@ -217391,8 +217391,8 @@ var require_mkdirp = __commonJS((exports, module) => {
           });
           break;
         default:
-          xfs.stat(p4, function(er22, stat4) {
-            if (er22 || !stat4.isDirectory())
+          xfs.stat(p4, function(er22, stat2) {
+            if (er22 || !stat2.isDirectory())
               cb2(er10, made);
             else
               cb2(null, made);
@@ -217423,13 +217423,13 @@ var require_mkdirp = __commonJS((exports, module) => {
           sync(p4, opts, made);
           break;
         default:
-          var stat4;
+          var stat2;
           try {
-            stat4 = xfs.statSync(p4);
+            stat2 = xfs.statSync(p4);
           } catch (err1) {
             throw err0;
           }
-          if (!stat4.isDirectory())
+          if (!stat2.isDirectory())
             throw err0;
           break;
       }
@@ -217632,7 +217632,7 @@ var require_buffer_list = __commonJS((exports, module) => {
       }
     }, {
       key: "join",
-      value: function join31(s5) {
+      value: function join29(s5) {
         if (this.length === 0)
           return "";
         var p4 = this.head;
@@ -218930,14 +218930,14 @@ var require_async_iterator = __commonJS((exports, module) => {
     };
   }
   function readAndResolve(iter) {
-    var resolve16 = iter[kLastResolve];
-    if (resolve16 !== null) {
+    var resolve13 = iter[kLastResolve];
+    if (resolve13 !== null) {
       var data = iter[kStream].read();
       if (data !== null) {
         iter[kLastPromise] = null;
         iter[kLastResolve] = null;
         iter[kLastReject] = null;
-        resolve16(createIterResult(data, false));
+        resolve13(createIterResult(data, false));
       }
     }
   }
@@ -218945,13 +218945,13 @@ var require_async_iterator = __commonJS((exports, module) => {
     process.nextTick(readAndResolve, iter);
   }
   function wrapForNext(lastPromise, iter) {
-    return function(resolve16, reject) {
+    return function(resolve13, reject) {
       lastPromise.then(function() {
         if (iter[kEnded]) {
-          resolve16(createIterResult(undefined, true));
+          resolve13(createIterResult(undefined, true));
           return;
         }
-        iter[kHandlePromise](resolve16, reject);
+        iter[kHandlePromise](resolve13, reject);
       }, reject);
     };
   }
@@ -218970,12 +218970,12 @@ var require_async_iterator = __commonJS((exports, module) => {
         return Promise.resolve(createIterResult(undefined, true));
       }
       if (this[kStream].destroyed) {
-        return new Promise(function(resolve16, reject) {
+        return new Promise(function(resolve13, reject) {
           process.nextTick(function() {
             if (_this[kError]) {
               reject(_this[kError]);
             } else {
-              resolve16(createIterResult(undefined, true));
+              resolve13(createIterResult(undefined, true));
             }
           });
         });
@@ -218998,13 +218998,13 @@ var require_async_iterator = __commonJS((exports, module) => {
     return this;
   }), _defineProperty(_Object$setPrototypeO, "return", function _return() {
     var _this2 = this;
-    return new Promise(function(resolve16, reject) {
+    return new Promise(function(resolve13, reject) {
       _this2[kStream].destroy(null, function(err) {
         if (err) {
           reject(err);
           return;
         }
-        resolve16(createIterResult(undefined, true));
+        resolve13(createIterResult(undefined, true));
       });
     });
   }), _Object$setPrototypeO), AsyncIteratorPrototype);
@@ -219026,15 +219026,15 @@ var require_async_iterator = __commonJS((exports, module) => {
       value: stream._readableState.endEmitted,
       writable: true
     }), _defineProperty(_Object$create, kHandlePromise, {
-      value: function value(resolve16, reject) {
+      value: function value(resolve13, reject) {
         var data = iterator[kStream].read();
         if (data) {
           iterator[kLastPromise] = null;
           iterator[kLastResolve] = null;
           iterator[kLastReject] = null;
-          resolve16(createIterResult(data, false));
+          resolve13(createIterResult(data, false));
         } else {
-          iterator[kLastResolve] = resolve16;
+          iterator[kLastResolve] = resolve13;
           iterator[kLastReject] = reject;
         }
       },
@@ -219053,12 +219053,12 @@ var require_async_iterator = __commonJS((exports, module) => {
         iterator[kError] = err;
         return;
       }
-      var resolve16 = iterator[kLastResolve];
-      if (resolve16 !== null) {
+      var resolve13 = iterator[kLastResolve];
+      if (resolve13 !== null) {
         iterator[kLastPromise] = null;
         iterator[kLastResolve] = null;
         iterator[kLastReject] = null;
-        resolve16(createIterResult(undefined, true));
+        resolve13(createIterResult(undefined, true));
       }
       iterator[kEnded] = true;
     });
@@ -219070,7 +219070,7 @@ var require_async_iterator = __commonJS((exports, module) => {
 
 // ../../node_modules/readable-stream/lib/internal/streams/from.js
 var require_from = __commonJS((exports, module) => {
-  function asyncGeneratorStep(gen, resolve16, reject, _next, _throw, key2, arg) {
+  function asyncGeneratorStep(gen, resolve13, reject, _next, _throw, key2, arg) {
     try {
       var info = gen[key2](arg);
       var value = info.value;
@@ -219079,7 +219079,7 @@ var require_from = __commonJS((exports, module) => {
       return;
     }
     if (info.done) {
-      resolve16(value);
+      resolve13(value);
     } else {
       Promise.resolve(value).then(_next, _throw);
     }
@@ -219087,13 +219087,13 @@ var require_from = __commonJS((exports, module) => {
   function _asyncToGenerator(fn9) {
     return function() {
       var self2 = this, args = arguments;
-      return new Promise(function(resolve16, reject) {
+      return new Promise(function(resolve13, reject) {
         var gen = fn9.apply(self2, args);
         function _next(value) {
-          asyncGeneratorStep(gen, resolve16, reject, _next, _throw, "next", value);
+          asyncGeneratorStep(gen, resolve13, reject, _next, _throw, "next", value);
         }
         function _throw(err) {
-          asyncGeneratorStep(gen, resolve16, reject, _next, _throw, "throw", err);
+          asyncGeneratorStep(gen, resolve13, reject, _next, _throw, "throw", err);
         }
         _next(undefined);
       });
@@ -221220,7 +221220,7 @@ var require_dist5 = __commonJS((exports, module) => {
     determineAgent: () => determineAgent
   });
   module.exports = __toCommonJS2(src_exports);
-  var import_promises26 = __require("node:fs/promises");
+  var import_promises22 = __require("node:fs/promises");
   var import_node_fs24 = __require("node:fs");
   var DEVIN_LOCAL_PATH = "/opt/.devin";
   var CURSOR2 = "cursor";
@@ -221278,7 +221278,7 @@ var require_dist5 = __commonJS((exports, module) => {
       return { isAgent: true, agent: { name: REPLIT } };
     }
     try {
-      await (0, import_promises26.access)(DEVIN_LOCAL_PATH, import_node_fs24.constants.F_OK);
+      await (0, import_promises22.access)(DEVIN_LOCAL_PATH, import_node_fs24.constants.F_OK);
       return { isAgent: true, agent: { name: DEVIN } };
     } catch (error48) {}
     return { isAgent: false, agent: undefined };
@@ -237049,7 +237049,7 @@ function normalizeBase44Env() {
 loadProjectEnvFiles();
 
 // src/cli/index.ts
-import { dirname as dirname26, join as join36 } from "node:path";
+import { dirname as dirname25, join as join33 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 
 // ../../node_modules/@clack/core/dist/index.mjs
@@ -238257,7 +238257,7 @@ var {
 } = import__.default;
 
 // src/cli/commands/agent-skills/pull.ts
-import { dirname as dirname11, join as join17 } from "node:path";
+import { dirname as dirname10, join as join15 } from "node:path";
 // ../../node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
 var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
@@ -247551,7 +247551,7 @@ async function deployAll(projectData, options) {
   await authConfigResource.push(authConfig);
   const skipConnectorSync = connectors.length === 0 && hasWorkspaceApiKeyAuth();
   const connectorResults = skipConnectorSync ? [] : (await pushConnectors(connectors)).results;
-  if ((options?.site ?? true) && project.site?.outputDirectory) {
+  if (project.site?.outputDirectory) {
     const outputDir = resolve3(project.root, project.site.outputDirectory);
     const { appUrl } = await deploySite(outputDir);
     return { appUrl, connectorResults };
@@ -254714,667 +254714,6 @@ function formatYaml(data, options = {}) {
   const replacer = stripEmpty ? stripEmptyReplacer : undefined;
   return $stringify(data, replacer, { indent: YAML_INDENT }).trimEnd();
 }
-// src/core/deployments/api.ts
-import { readFile as readFile2 } from "node:fs/promises";
-
-// src/core/deployments/schema.ts
-var GIT_HASH_PATTERN = /^[a-fA-F0-9]{7,64}$/;
-var CreateDeploymentResponseSchema = exports_external.object({
-  deployment_id: exports_external.string(),
-  asset_buckets: exports_external.array(exports_external.array(exports_external.string()))
-}).transform((data) => ({
-  deploymentId: data.deployment_id,
-  assetBuckets: data.asset_buckets
-}));
-var AssetUploadResponseSchema = exports_external.looseObject({
-  result: exports_external.looseObject({ jwt: exports_external.string().nullable().optional() }).nullable().optional()
-});
-var FinalizeDeploymentResponseSchema = exports_external.object({
-  deployment_id: exports_external.string()
-}).transform((data) => ({
-  deploymentId: data.deployment_id
-}));
-
-// src/core/deployments/api.ts
-var MODULE_CONTENT_TYPES = {
-  esm: "application/javascript+module",
-  sourcemap: "application/source-map",
-  wasm: "application/wasm",
-  text: "text/plain",
-  data: "application/octet-stream"
-};
-async function createDeployment(request) {
-  const appClient = getAppClient();
-  let response;
-  try {
-    response = await appClient.post("deployments", {
-      json: request,
-      timeout: 120000
-    });
-  } catch (error48) {
-    throw await ApiError.fromHttpError(error48, "creating deployment");
-  }
-  const result = CreateDeploymentResponseSchema.safeParse(await response.json());
-  if (!result.success) {
-    throw new SchemaValidationError("Invalid response from server", result.error);
-  }
-  return result.data;
-}
-async function uploadAssetBucket(deploymentId, formData) {
-  const appClient = getAppClient();
-  const response = await appClient.post(`deployments/${encodeURIComponent(deploymentId)}/assets`, {
-    searchParams: { base64: "true" },
-    body: formData,
-    timeout: 120000,
-    retry: 0
-  });
-  const parsed = AssetUploadResponseSchema.safeParse(await response.json());
-  const jwt3 = parsed.success ? parsed.data.result?.jwt : null;
-  return jwt3 || null;
-}
-async function finalizeDeployment(deploymentId, completionJwt, modules) {
-  const appClient = getAppClient();
-  const formData = new FormData;
-  formData.append("payload", JSON.stringify({ completion_jwt: completionJwt }));
-  for (const module of modules) {
-    const content = module.content !== undefined ? module.content : new Uint8Array(await readFile2(module.absolutePath));
-    formData.append(module.name, new File([content], module.name, {
-      type: MODULE_CONTENT_TYPES[module.type]
-    }));
-  }
-  let response;
-  try {
-    response = await appClient.post(`deployments/${encodeURIComponent(deploymentId)}/finalize`, { body: formData, timeout: 180000 });
-  } catch (error48) {
-    throw await ApiError.fromHttpError(error48, "finalizing deployment");
-  }
-  const result = FinalizeDeploymentResponseSchema.safeParse(await response.json());
-  if (!result.success) {
-    throw new SchemaValidationError("Invalid response from server", result.error);
-  }
-  return result.data;
-}
-// src/core/deployments/manifest.ts
-import { createHash } from "node:crypto";
-import { readdir as readdir2, readFile as readFile3, stat } from "node:fs/promises";
-import { extname, join as join15 } from "node:path";
-var MAX_ASSET_SIZE_BYTES = 25 * 1024 * 1024;
-var MAX_ASSET_COUNT = 1e5;
-var ASSETS_IGNORE_FILE = ".assetsignore";
-var ALWAYS_SKIPPED_FILES = new Set([
-  ASSETS_IGNORE_FILE,
-  "wrangler.json",
-  ".dev.vars"
-]);
-var MIME_TYPES = {
-  ".html": "text/html",
-  ".htm": "text/html",
-  ".css": "text/css",
-  ".js": "text/javascript",
-  ".mjs": "text/javascript",
-  ".json": "application/json",
-  ".map": "application/json",
-  ".txt": "text/plain",
-  ".xml": "application/xml",
-  ".svg": "image/svg+xml",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".avif": "image/avif",
-  ".ico": "image/x-icon",
-  ".woff": "font/woff",
-  ".woff2": "font/woff2",
-  ".ttf": "font/ttf",
-  ".otf": "font/otf",
-  ".eot": "application/vnd.ms-fontobject",
-  ".mp3": "audio/mpeg",
-  ".mp4": "video/mp4",
-  ".webm": "video/webm",
-  ".pdf": "application/pdf",
-  ".wasm": "application/wasm",
-  ".webmanifest": "application/manifest+json"
-};
-function getMimeType(filePath) {
-  return MIME_TYPES[extname(filePath).toLowerCase()] ?? "application/octet-stream";
-}
-function hashAsset(appId, content) {
-  return createHash("sha256").update(Buffer.from(appId, "utf8")).update(content).digest("hex").slice(0, 32);
-}
-function globToRegExp(glob) {
-  let source = "";
-  for (let i2 = 0;i2 < glob.length; i2++) {
-    const char = glob[i2];
-    if (char === "*") {
-      if (glob[i2 + 1] === "*") {
-        source += ".*";
-        i2++;
-      } else {
-        source += "[^/]*";
-      }
-    } else if (char === "?") {
-      source += "[^/]";
-    } else {
-      source += char.replace(/[.+^${}()|[\]\\]/g, "\\$&");
-    }
-  }
-  return new RegExp(`^${source}$`);
-}
-function createIgnoreMatcher(lines) {
-  const rules = lines.map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")).map((line) => {
-    const isDirOnly = line.endsWith("/");
-    let pattern = isDirOnly ? line.slice(0, -1) : line;
-    const anchored = pattern.includes("/");
-    pattern = pattern.replace(/^\//, "");
-    return { regex: globToRegExp(pattern), anchored, isDirOnly };
-  });
-  return (relativePath, isDirectory2) => {
-    const segments = relativePath.split("/");
-    return rules.some((rule) => {
-      if (rule.anchored) {
-        if (rule.isDirOnly ? isDirectory2 : true) {
-          if (rule.regex.test(relativePath))
-            return true;
-        }
-        return false;
-      }
-      const basename4 = segments[segments.length - 1];
-      if (rule.isDirOnly && !isDirectory2)
-        return false;
-      return rule.regex.test(basename4);
-    });
-  };
-}
-async function loadIgnoreMatcher(assetsDir) {
-  const ignorePath = join15(assetsDir, ASSETS_IGNORE_FILE);
-  if (!await pathExists(ignorePath)) {
-    return () => false;
-  }
-  const content = await readTextFile(ignorePath);
-  return createIgnoreMatcher(content.split(/\r?\n/));
-}
-async function buildAssetManifest(assetsDir, appId) {
-  const isIgnored = await loadIgnoreMatcher(assetsDir);
-  const manifest = {};
-  const filesByHash = new Map;
-  const relativeFilePaths = await collectFilePaths(assetsDir, "", isIgnored);
-  if (relativeFilePaths.length > MAX_ASSET_COUNT) {
-    throw new InvalidInputError(`Too many static assets: found ${relativeFilePaths.length}, the limit is ${MAX_ASSET_COUNT} files.`);
-  }
-  for (const relativePath of relativeFilePaths.sort()) {
-    const absolutePath = join15(assetsDir, ...relativePath.split("/"));
-    const { size } = await stat(absolutePath);
-    if (size > MAX_ASSET_SIZE_BYTES) {
-      throw new InvalidInputError(`Static asset "${relativePath}" is ${size} bytes, which exceeds the 25 MiB per-file limit.`);
-    }
-    const content = await readFile3(absolutePath);
-    const hash2 = hashAsset(appId, content);
-    manifest[`/${relativePath}`] = { hash: hash2, size };
-    if (!filesByHash.has(hash2)) {
-      filesByHash.set(hash2, {
-        absolutePath,
-        hash: hash2,
-        size,
-        contentType: getMimeType(absolutePath)
-      });
-    }
-  }
-  return { manifest, filesByHash };
-}
-async function collectFilePaths(dir, relativeDir, isIgnored) {
-  const entries = await readdir2(dir, { withFileTypes: true });
-  const results = [];
-  for (const entry of entries) {
-    const relativePath = relativeDir ? `${relativeDir}/${entry.name}` : entry.name;
-    if (entry.isDirectory()) {
-      if (isIgnored(relativePath, true))
-        continue;
-      results.push(...await collectFilePaths(join15(dir, entry.name), relativePath, isIgnored));
-      continue;
-    }
-    if (!entry.isFile())
-      continue;
-    if (ALWAYS_SKIPPED_FILES.has(entry.name))
-      continue;
-    if (isIgnored(relativePath, false))
-      continue;
-    results.push(relativePath);
-  }
-  return results;
-}
-
-// src/core/deployments/modules.ts
-import { stat as stat2 } from "node:fs/promises";
-import { relative as relative3, resolve as resolve4, sep } from "node:path";
-var MAX_TOTAL_MODULE_BYTES = 40 * 1024 * 1024;
-var MODULE_IGNORE = ["wrangler.json", ".dev.vars"];
-var RULE_TYPE_TO_MODULE_TYPE = {
-  ESModule: "esm",
-  CompiledWasm: "wasm",
-  Text: "text",
-  Data: "data"
-};
-function toPosix(path16) {
-  return path16.split(sep).join("/");
-}
-async function collectModules(config12) {
-  const entryPath = resolve4(config12.configDir, config12.main);
-  if (!await pathExists(entryPath)) {
-    throw new InvalidInputError(`Worker entry module does not exist: ${entryPath} (from "main" in ${config12.configPath})`, {
-      hints: [{ message: "Rebuild the project to regenerate the artifact" }]
-    });
-  }
-  const modulesByName = new Map;
-  const entryName = toPosix(relative3(config12.configDir, entryPath));
-  modulesByName.set(entryName, {
-    name: entryName,
-    absolutePath: entryPath,
-    size: 0,
-    type: "esm"
-  });
-  const ignore = [...MODULE_IGNORE];
-  if (config12.assetsDirectory?.startsWith(config12.configDir + sep)) {
-    ignore.push(`${toPosix(relative3(config12.configDir, config12.assetsDirectory))}/**`);
-  }
-  for (const rule of config12.rules) {
-    const type = RULE_TYPE_TO_MODULE_TYPE[rule.type];
-    if (!type) {
-      throw new InvalidInputError(`Unsupported module rule type "${rule.type}" in ${config12.configPath}. Supported: ${Object.keys(RULE_TYPE_TO_MODULE_TYPE).join(", ")}.`);
-    }
-    const matches = await globby(rule.globs, {
-      cwd: config12.configDir,
-      onlyFiles: true,
-      dot: true,
-      ignore
-    });
-    for (const match of matches.sort()) {
-      if (!modulesByName.has(match)) {
-        modulesByName.set(match, {
-          name: match,
-          absolutePath: resolve4(config12.configDir, match),
-          size: 0,
-          type
-        });
-      }
-    }
-  }
-  if (config12.uploadSourceMaps) {
-    const maps = await globby("**/*.map", {
-      cwd: config12.configDir,
-      onlyFiles: true,
-      dot: true,
-      ignore
-    });
-    for (const map2 of maps.sort()) {
-      addSourcemap(modulesByName, config12.configDir, map2);
-    }
-  } else {
-    for (const name2 of [...modulesByName.keys()]) {
-      const mapName = `${name2}.map`;
-      if (await pathExists(resolve4(config12.configDir, mapName))) {
-        addSourcemap(modulesByName, config12.configDir, mapName);
-      }
-    }
-  }
-  const modules = [...modulesByName.values()];
-  let totalBytes = 0;
-  for (const module of modules) {
-    module.size = (await stat2(module.absolutePath)).size;
-    totalBytes += module.size;
-  }
-  if (totalBytes > MAX_TOTAL_MODULE_BYTES) {
-    throw new InvalidInputError(`Worker modules total ${totalBytes} bytes, which exceeds the 40 MB limit for Base44 full-stack deploys.`);
-  }
-  return modules;
-}
-function addSourcemap(modulesByName, configDir, name2) {
-  if (modulesByName.has(name2))
-    return;
-  modulesByName.set(name2, {
-    name: name2,
-    absolutePath: resolve4(configDir, name2),
-    size: 0,
-    type: "sourcemap"
-  });
-}
-
-// src/core/deployments/upload.ts
-import { readFile as readFile4 } from "node:fs/promises";
-var BUCKET_CONCURRENCY = 3;
-var MAX_ATTEMPTS_PER_BUCKET = 3;
-var RETRY_BASE_DELAY_MS = 500;
-var MAX_RATE_LIMIT_WAITS = 10;
-var RATE_LIMIT_DELAY_MS = 15000;
-async function uploadAssetBuckets(deploymentId, buckets, filesByHash, onProgress) {
-  if (buckets.length === 0) {
-    return null;
-  }
-  const totalFiles = buckets.reduce((sum, bucket) => sum + bucket.length, 0);
-  let uploadedFiles = 0;
-  let completedBuckets = 0;
-  let completionJwt = null;
-  let nextBucket = 0;
-  const worker = async () => {
-    while (nextBucket < buckets.length) {
-      const bucket = buckets[nextBucket++];
-      const jwt3 = await uploadBucketWithRetry(deploymentId, bucket, filesByHash);
-      if (jwt3) {
-        completionJwt = jwt3;
-      }
-      uploadedFiles += bucket.length;
-      completedBuckets++;
-      onProgress?.({
-        uploadedFiles,
-        totalFiles,
-        completedBuckets,
-        totalBuckets: buckets.length
-      });
-    }
-  };
-  await Promise.all(Array.from({ length: Math.min(BUCKET_CONCURRENCY, buckets.length) }, worker));
-  if (!completionJwt) {
-    throw new ApiError("Asset upload finished but the server did not return a completion token.");
-  }
-  return completionJwt;
-}
-async function uploadBucketWithRetry(deploymentId, bucket, filesByHash) {
-  let lastError;
-  let rateLimitWaits = 0;
-  const formData = await buildBucketForm(bucket, filesByHash);
-  for (let attempt = 0;attempt < MAX_ATTEMPTS_PER_BUCKET; attempt++) {
-    if (attempt > 0) {
-      await sleep3(RETRY_BASE_DELAY_MS * 2 ** (attempt - 1));
-    }
-    try {
-      return await uploadAssetBucket(deploymentId, formData);
-    } catch (error48) {
-      if (error48 instanceof HTTPError && error48.response.status === 429 && rateLimitWaits < MAX_RATE_LIMIT_WAITS) {
-        rateLimitWaits++;
-        attempt--;
-        await sleep3(RATE_LIMIT_DELAY_MS);
-        continue;
-      }
-      lastError = error48;
-    }
-  }
-  if (lastError instanceof HTTPError && lastError.response.status === 409) {
-    throw new ApiError("This deploy's upload session has expired — rerun deploy. Already-uploaded assets are skipped on the next attempt.", { statusCode: 409, cause: lastError });
-  }
-  throw await ApiError.fromHttpError(lastError, "uploading static assets");
-}
-async function buildBucketForm(bucket, filesByHash) {
-  const formData = new FormData;
-  for (const hash2 of bucket) {
-    const file2 = filesByHash.get(hash2);
-    if (!file2) {
-      throw new InternalError(`Server requested upload of unknown asset hash: ${hash2}`);
-    }
-    const content = await readFile4(file2.absolutePath);
-    formData.append(hash2, new File([content.toString("base64")], hash2, { type: file2.contentType }));
-  }
-  return formData;
-}
-function sleep3(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
-}
-
-// src/core/deployments/wrangler-config.ts
-import { dirname as dirname10, join as join16, resolve as resolve5 } from "node:path";
-var WRANGLER_REDIRECT_PATH = join16(".wrangler", "deploy", "config.json");
-var RedirectConfigSchema = exports_external.looseObject({
-  configPath: exports_external.string().min(1)
-});
-var BindingArraySchema = exports_external.array(exports_external.unknown()).optional();
-var WranglerConfigSchema = exports_external.looseObject({
-  name: exports_external.string().optional(),
-  main: exports_external.string().min(1, "wrangler config is missing a 'main' entry module"),
-  no_bundle: exports_external.boolean().optional(),
-  rules: exports_external.array(exports_external.looseObject({ type: exports_external.string(), globs: exports_external.array(exports_external.string()) })).optional(),
-  assets: exports_external.looseObject({
-    directory: exports_external.string().optional(),
-    html_handling: exports_external.string().optional(),
-    not_found_handling: exports_external.string().optional(),
-    run_worker_first: exports_external.union([exports_external.boolean(), exports_external.array(exports_external.string())]).optional(),
-    headers: exports_external.string().optional(),
-    redirects: exports_external.string().optional()
-  }).optional(),
-  compatibility_date: exports_external.string().optional(),
-  compatibility_flags: exports_external.array(exports_external.string()).optional(),
-  vars: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
-  upload_source_maps: exports_external.boolean().optional(),
-  kv_namespaces: BindingArraySchema,
-  d1_databases: BindingArraySchema,
-  r2_buckets: BindingArraySchema,
-  durable_objects: exports_external.looseObject({ bindings: BindingArraySchema }).optional(),
-  services: BindingArraySchema,
-  queues: exports_external.looseObject({
-    producers: BindingArraySchema,
-    consumers: BindingArraySchema
-  }).optional(),
-  hyperdrive: BindingArraySchema,
-  analytics_engine_datasets: BindingArraySchema,
-  vectorize: BindingArraySchema
-});
-async function detectFullStackArtifact(projectRoot) {
-  const redirectPath = join16(projectRoot, WRANGLER_REDIRECT_PATH);
-  if (await pathExists(redirectPath)) {
-    return { source: "redirect", path: redirectPath };
-  }
-  for (const name2 of ["wrangler.jsonc", "wrangler.json"]) {
-    const configPath = join16(projectRoot, name2);
-    if (await pathExists(configPath)) {
-      return { source: "root-config", path: configPath };
-    }
-  }
-  const tomlPath = join16(projectRoot, "wrangler.toml");
-  if (await pathExists(tomlPath)) {
-    return { source: "toml", path: tomlPath };
-  }
-  return null;
-}
-async function resolveWranglerConfig(projectRoot) {
-  const artifact = await detectFullStackArtifact(projectRoot);
-  if (!artifact) {
-    throw new InvalidInputError("No full-stack build artifact found. Expected a .wrangler/deploy/config.json redirect file or a root wrangler.jsonc.", {
-      hints: [{ message: "Run your framework's build command first" }]
-    });
-  }
-  if (artifact.source === "toml") {
-    throw new InvalidInputError("wrangler.toml is not supported for Base44 full-stack deploys. Convert your config to wrangler.jsonc.");
-  }
-  const configPath = artifact.source === "redirect" ? await resolveRedirectedConfigPath(artifact.path) : artifact.path;
-  const parsed = await readJsonFile(configPath);
-  const result = WranglerConfigSchema.safeParse(parsed);
-  if (!result.success) {
-    throw new ConfigInvalidError(`Invalid wrangler config: ${exports_external.prettifyError(result.error)}`, configPath);
-  }
-  const config12 = result.data;
-  if (config12.no_bundle !== true) {
-    throw new InvalidInputError("This framework's output requires bundling; not yet supported. Base44 full-stack deploys only support pre-bundled Workers output (no_bundle: true).");
-  }
-  assertNoUnsupportedBindings(config12, configPath);
-  const configDir = dirname10(configPath);
-  const assetsDirectory = config12.assets?.directory ? resolve5(configDir, config12.assets.directory) : null;
-  return {
-    configPath,
-    configDir,
-    name: config12.name ?? null,
-    main: config12.main,
-    assetsDirectory,
-    assetsConfig: config12.assets ? toResolvedAssetsConfig(config12.assets) : null,
-    compatibilityDate: config12.compatibility_date ?? null,
-    compatibilityFlags: config12.compatibility_flags ?? [],
-    vars: config12.vars ?? {},
-    rules: (config12.rules ?? []).map((rule) => ({
-      type: rule.type,
-      globs: rule.globs
-    })),
-    uploadSourceMaps: config12.upload_source_maps ?? false
-  };
-}
-async function resolveRedirectedConfigPath(redirectPath) {
-  const parsed = await readJsonFile(redirectPath);
-  const result = RedirectConfigSchema.safeParse(parsed);
-  if (!result.success) {
-    throw new ConfigInvalidError(`Invalid deploy redirect file: ${exports_external.prettifyError(result.error)}`, redirectPath);
-  }
-  const configPath = resolve5(dirname10(redirectPath), result.data.configPath);
-  if (!await pathExists(configPath)) {
-    throw new ConfigInvalidError(`Wrangler config referenced by ${redirectPath} does not exist: ${configPath}`, redirectPath, {
-      hints: [{ message: "Rebuild the project to regenerate the artifact" }]
-    });
-  }
-  return configPath;
-}
-function toResolvedAssetsConfig(assets) {
-  return {
-    htmlHandling: assets.html_handling,
-    notFoundHandling: assets.not_found_handling,
-    runWorkerFirst: assets.run_worker_first,
-    headers: assets.headers,
-    redirects: assets.redirects
-  };
-}
-function assertNoUnsupportedBindings(config12, configPath) {
-  const bindingSources = {
-    kv_namespaces: config12.kv_namespaces,
-    d1_databases: config12.d1_databases,
-    r2_buckets: config12.r2_buckets,
-    "durable_objects.bindings": config12.durable_objects?.bindings,
-    services: config12.services,
-    "queues.producers": config12.queues?.producers,
-    "queues.consumers": config12.queues?.consumers,
-    hyperdrive: config12.hyperdrive,
-    analytics_engine_datasets: config12.analytics_engine_datasets,
-    vectorize: config12.vectorize
-  };
-  const used = Object.entries(bindingSources).filter(([, values]) => (values?.length ?? 0) > 0).map(([name2]) => name2);
-  if (used.length > 0) {
-    throw new InvalidInputError(`Unsupported bindings for Base44 full-stack deploys: ${used.join(", ")}. Remove them or file a feature request.`, {
-      hints: [{ message: `Edit the bindings in ${configPath}` }]
-    });
-  }
-}
-
-// src/core/deployments/deploy.ts
-async function resolveGitHash(projectRoot, explicit) {
-  const hash2 = explicit ?? await gitHead(projectRoot);
-  if (!hash2 || !GIT_HASH_PATTERN.test(hash2)) {
-    throw new InvalidInputError(explicit ? `'${explicit}' is not a git commit hash.` : "Full-stack deployments are addressed by the commit that produced the build, and no git commit was found.", {
-      hints: [
-        {
-          message: "Run the deploy from a git checkout, or pass the commit explicitly with --git-hash."
-        }
-      ]
-    });
-  }
-  return hash2;
-}
-async function gitHead(projectRoot) {
-  try {
-    const { stdout } = await execa("git", ["rev-parse", "HEAD"], {
-      cwd: projectRoot
-    });
-    return stdout.trim();
-  } catch {
-    return null;
-  }
-}
-async function deployFullStack(options) {
-  const { projectRoot, gitHash, progress } = options;
-  const config12 = await resolveWranglerConfig(projectRoot);
-  if (!config12.compatibilityFlags.includes("nodejs_compat")) {
-    progress?.onWarning?.("The wrangler config has no 'nodejs_compat' compatibility flag; Node.js built-ins will be unavailable at runtime. Enable it in your framework's Cloudflare adapter settings if your server code needs Node APIs.");
-  }
-  if (config12.vars && Object.keys(config12.vars).length > 0) {
-    progress?.onWarning?.("wrangler 'vars' are not supported and were ignored — a worker's environment comes from the app's secrets (base44 secrets set).");
-  }
-  const modules = await collectModules(config12);
-  let assets = { manifest: {}, filesByHash: new Map };
-  if (config12.assetsDirectory && await pathExists(config12.assetsDirectory)) {
-    assets = await buildAssetManifest(config12.assetsDirectory, getAppContext().id);
-  }
-  const created = await createDeployment({
-    git_hash: gitHash,
-    config: {
-      main: config12.main,
-      compatibility_date: config12.compatibilityDate,
-      compatibility_flags: config12.compatibilityFlags,
-      assets: buildAssetsConfig(config12.assetsConfig, progress)
-    },
-    asset_manifest: assets.manifest
-  });
-  const totalAssets = Object.keys(assets.manifest).length;
-  const newAssets = new Set(created.assetBuckets.flat()).size;
-  progress?.onAssets?.({ totalAssets, newAssets });
-  const completionJwt = await uploadAssetBuckets(created.deploymentId, created.assetBuckets, assets.filesByHash, progress?.onAssetUpload);
-  progress?.onWorker?.({ moduleCount: modules.length });
-  const finalized = await finalizeDeployment(created.deploymentId, completionJwt, modules);
-  return { deploymentId: finalized.deploymentId, gitHash };
-}
-function buildAssetsConfig(assetsConfig, progress) {
-  if (!assetsConfig)
-    return null;
-  if (assetsConfig.headers || assetsConfig.redirects) {
-    progress?.onWarning?.("_headers/_redirects files are not supported yet and were ignored for this deploy.");
-  }
-  let runWorkerFirst;
-  if (Array.isArray(assetsConfig.runWorkerFirst)) {
-    progress?.onWarning?.("'run_worker_first' route patterns are not supported yet and were ignored for this deploy.");
-  } else {
-    runWorkerFirst = assetsConfig.runWorkerFirst;
-  }
-  return {
-    html_handling: assetsConfig.htmlHandling,
-    not_found_handling: assetsConfig.notFoundHandling,
-    run_worker_first: runWorkerFirst
-  };
-}
-// src/core/deployments/static-site.ts
-var STATIC_WORKERS_ENV = "BASE44_STATIC_WORKERS";
-function staticWorkersEnabled(env2 = process.env) {
-  const value = env2[STATIC_WORKERS_ENV];
-  return value === "1" || value === "true";
-}
-var STUB_MODULE_NAME = "index.js";
-var STUB_SOURCE = `export default {
-  async fetch(request, env) {
-    return env.ASSETS.fetch(request);
-  },
-};
-`;
-var STATIC_COMPATIBILITY_DATE = "2026-01-01";
-async function deployStaticSite(options) {
-  const { outputDir, gitHash, progress } = options;
-  const assets = await buildAssetManifest(outputDir, getAppContext().id);
-  const created = await createDeployment({
-    git_hash: gitHash,
-    config: {
-      main: STUB_MODULE_NAME,
-      compatibility_date: STATIC_COMPATIBILITY_DATE,
-      compatibility_flags: [],
-      assets: { not_found_handling: "single-page-application" }
-    },
-    asset_manifest: assets.manifest
-  });
-  const totalAssets = Object.keys(assets.manifest).length;
-  const newAssets = new Set(created.assetBuckets.flat()).size;
-  progress?.onAssets?.({ totalAssets, newAssets });
-  const completionJwt = await uploadAssetBuckets(created.deploymentId, created.assetBuckets, assets.filesByHash, progress?.onAssetUpload);
-  const stubBytes = new TextEncoder().encode(STUB_SOURCE);
-  const modules = [
-    {
-      name: STUB_MODULE_NAME,
-      content: stubBytes,
-      size: stubBytes.byteLength,
-      type: "esm"
-    }
-  ];
-  progress?.onWorker?.({ moduleCount: modules.length });
-  const finalized = await finalizeDeployment(created.deploymentId, completionJwt, modules);
-  return { deploymentId: finalized.deploymentId, gitHash };
-}
 // src/core/utils/dependencies.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
 function verifyDenoInstalled(context) {
@@ -255463,7 +254802,7 @@ async function pullAction({
   runTask: runTask2
 }) {
   const { project: project2 } = await readProjectConfig();
-  const dir = join17(dirname11(project2.configPath), project2.agentSkillsDir);
+  const dir = join15(dirname10(project2.configPath), project2.agentSkillsDir);
   const remote = await runTask2("Fetching agent skills from Base44", () => fetchAgentSkills(), {
     successMessage: "Agent skills fetched successfully",
     errorMessage: "Failed to fetch agent skills"
@@ -255519,14 +254858,14 @@ function getAgentSkillsCommand() {
 }
 
 // src/cli/commands/agents/pull.ts
-import { dirname as dirname12, join as join18 } from "node:path";
+import { dirname as dirname11, join as join16 } from "node:path";
 async function pullAgentsAction({
   log,
   runTask: runTask2
 }) {
   const { project: project2 } = await readProjectConfig();
-  const configDir = dirname12(project2.configPath);
-  const agentsDir = join18(configDir, project2.agentsDir);
+  const configDir = dirname11(project2.configPath);
+  const agentsDir = join16(configDir, project2.agentsDir);
   const remoteAgents = await runTask2("Fetching agents from Base44", async () => {
     return await fetchAgents();
   }, {
@@ -255596,12 +254935,12 @@ function getAgentsCommand() {
 }
 
 // src/cli/commands/auth/password-login.ts
-import { dirname as dirname13, join as join19 } from "node:path";
+import { dirname as dirname12, join as join17 } from "node:path";
 async function passwordLoginAction({ log, runTask: runTask2 }, action) {
   const shouldEnable = action === "enable";
   const { project: project2 } = await readProjectConfig();
-  const configDir = dirname13(project2.configPath);
-  const authDir = join19(configDir, project2.authDir);
+  const configDir = dirname12(project2.configPath);
+  const authDir = join17(configDir, project2.authDir);
   const updated = await runTask2("Updating local auth config", async () => {
     const current = await readAuthConfig(authDir) ?? DEFAULT_AUTH_CONFIG;
     const merged = { ...current, enableUsernamePassword: shouldEnable };
@@ -255621,14 +254960,14 @@ function getPasswordLoginCommand() {
 }
 
 // src/cli/commands/auth/pull.ts
-import { dirname as dirname14, join as join20 } from "node:path";
+import { dirname as dirname13, join as join18 } from "node:path";
 async function pullAuthAction({
   log,
   runTask: runTask2
 }) {
   const { project: project2 } = await readProjectConfig();
-  const configDir = dirname14(project2.configPath);
-  const authDir = join20(configDir, project2.authDir);
+  const configDir = dirname13(project2.configPath);
+  const authDir = join18(configDir, project2.authDir);
   const remoteConfig = await runTask2("Fetching auth config from Base44", async () => {
     return await pullAuthConfig();
   }, {
@@ -255692,7 +255031,7 @@ function getAuthPushCommand() {
 }
 
 // src/cli/commands/auth/social-login.ts
-import { dirname as dirname15, join as join21, resolve as resolve6 } from "node:path";
+import { dirname as dirname14, join as join19, resolve as resolve4 } from "node:path";
 var PROVIDER_LABELS = {
   google: "Google",
   microsoft: "Microsoft",
@@ -255732,7 +255071,7 @@ async function socialLoginAction({ log, isNonInteractive, runTask: runTask2 }, p
   let clientSecret;
   if (useCustomOAuth && oauth && oauthCli && hasSecretOptions(options)) {
     if (options.envFile) {
-      const secrets = await parseEnvFile(resolve6(options.envFile));
+      const secrets = await parseEnvFile(resolve4(options.envFile));
       const value = secrets[oauthCli.envVar];
       if (!value) {
         throw new InvalidInputError(`Key "${oauthCli.envVar}" not found in ${options.envFile}.`);
@@ -255762,8 +255101,8 @@ async function socialLoginAction({ log, isNonInteractive, runTask: runTask2 }, p
     }
   }
   const { project: project2 } = await readProjectConfig();
-  const configDir = dirname15(project2.configPath);
-  const authDir = join21(configDir, project2.authDir);
+  const configDir = dirname14(project2.configPath);
+  const authDir = join19(configDir, project2.authDir);
   const { config: updated } = await runTask2("Updating local auth config", async () => updateSocialLoginConfig(authDir, provider, shouldEnable, useCustomOAuth && options.clientId ? { clientId: options.clientId } : undefined));
   if (clientSecret) {
     await runTask2("Saving client secret", async () => pushCustomOAuthSecret(provider, clientSecret));
@@ -255788,7 +255127,7 @@ function getSocialLoginCommand() {
 }
 
 // src/cli/commands/auth/sso.ts
-import { dirname as dirname16, join as join22, resolve as resolve7 } from "node:path";
+import { dirname as dirname15, join as join20, resolve as resolve5 } from "node:path";
 var SSOConfigFileSchema = exports_external.object({
   provider: exports_external.enum(Object.values(KNOWN_SSO_PROVIDERS)),
   clientId: exports_external.string(),
@@ -255804,7 +255143,7 @@ var SSOConfigFileSchema = exports_external.object({
   ssoName: exports_external.string().optional()
 });
 async function loadSSOConfigFile(filePath) {
-  const resolved = resolve7(filePath);
+  const resolved = resolve5(filePath);
   const raw2 = await readJsonFile(resolved);
   const result = SSOConfigFileSchema.safeParse(raw2);
   if (!result.success) {
@@ -255892,7 +255231,7 @@ async function ssoEnableAction({ isNonInteractive, runTask: runTask2 }, options)
   }
   let clientSecret;
   if (merged.envFile && !merged.clientSecret) {
-    const secrets2 = await parseEnvFile(resolve7(merged.envFile));
+    const secrets2 = await parseEnvFile(resolve5(merged.envFile));
     const value = secrets2.sso_client_secret;
     if (!value) {
       throw new InvalidInputError(`Key "sso_client_secret" not found in ${merged.envFile}.`);
@@ -255951,8 +255290,8 @@ async function ssoEnableAction({ isNonInteractive, runTask: runTask2 }, options)
     throw error48;
   }
   const { project: project2 } = await readProjectConfig();
-  const configDir = dirname16(project2.configPath);
-  const authDir = join22(configDir, project2.authDir);
+  const configDir = dirname15(project2.configPath);
+  const authDir = join20(configDir, project2.authDir);
   await runTask2("Updating local auth config", async () => updateSSOConfig(authDir, provider, true));
   await runTask2("Saving SSO credentials", async () => pushSSOSecrets(secrets));
   return {
@@ -255967,8 +255306,8 @@ async function ssoDisableAction({ log, runTask: runTask2 }, options) {
     throw new InvalidInputError("Configuration options cannot be used with disable. To disable SSO: base44 auth sso disable");
   }
   const { project: project2 } = await readProjectConfig();
-  const configDir = dirname16(project2.configPath);
-  const authDir = join22(configDir, project2.authDir);
+  const configDir = dirname15(project2.configPath);
+  const authDir = join20(configDir, project2.authDir);
   const updated = await runTask2("Updating local auth config", async () => updateSSOConfig(authDir, null, false));
   await runTask2("Removing SSO credentials", async () => deleteSSOSecrets());
   if (!hasAnyLoginMethod(updated)) {
@@ -256530,19 +255869,19 @@ var baseOpen = async (options) => {
   }
   const subprocess = childProcess3.spawn(command2, cliArguments, childProcessOptions);
   if (options.wait) {
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve6, reject) => {
       subprocess.once("error", reject);
       subprocess.once("close", (exitCode) => {
         if (!options.allowNonzeroExitCode && exitCode !== 0) {
           reject(new Error(`Exited with code ${exitCode}`));
           return;
         }
-        resolve8(subprocess);
+        resolve6(subprocess);
       });
     });
   }
   if (isFallbackAttempt) {
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve6, reject) => {
       subprocess.once("error", reject);
       subprocess.once("spawn", () => {
         subprocess.once("close", (exitCode) => {
@@ -256552,17 +255891,17 @@ var baseOpen = async (options) => {
             return;
           }
           subprocess.unref();
-          resolve8(subprocess);
+          resolve6(subprocess);
         });
       });
     });
   }
   subprocess.unref();
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve6, reject) => {
     subprocess.once("error", reject);
     subprocess.once("spawn", () => {
       subprocess.off("error", reject);
-      resolve8(subprocess);
+      resolve6(subprocess);
     });
   });
 };
@@ -256825,13 +256164,13 @@ function getConnectorsListAvailableCommand() {
 }
 
 // src/cli/commands/connectors/pull.ts
-import { dirname as dirname17, join as join23, resolve as resolve8 } from "node:path";
+import { dirname as dirname16, join as join21, resolve as resolve6 } from "node:path";
 async function resolveConnectorsDir(options) {
   if (!getAppContext().projectRoot) {
-    return resolve8(options.dir ?? "connectors");
+    return resolve6(options.dir ?? "connectors");
   }
   const { project: project2 } = await readProjectConfig();
-  return join23(dirname17(project2.configPath), project2.connectorsDir);
+  return join21(dirname16(project2.configPath), project2.connectorsDir);
 }
 async function pullConnectorsAction({ log, runTask: runTask2, jsonMode }, options) {
   const connectorsDir = await resolveConnectorsDir(options);
@@ -256872,10 +256211,10 @@ function getConnectorsPullCommand() {
 }
 
 // src/cli/commands/connectors/push.ts
-import { resolve as resolve9 } from "node:path";
+import { resolve as resolve7 } from "node:path";
 async function readConnectorsToPush(options) {
   if (!getAppContext().projectRoot) {
-    return readAllConnectors(resolve9(options.dir ?? "connectors"));
+    return readAllConnectors(resolve7(options.dir ?? "connectors"));
   }
   const { connectors } = await readProjectConfig();
   return connectors;
@@ -257239,11 +256578,11 @@ function getListCommand() {
 }
 
 // src/cli/commands/functions/pull.ts
-import { dirname as dirname18, join as join24 } from "node:path";
+import { dirname as dirname17, join as join22 } from "node:path";
 async function pullFunctionsAction({ log, runTask: runTask2 }, name2) {
   const { project: project2, functions } = await readProjectConfig();
-  const configDir = dirname18(project2.configPath);
-  const functionsDir = join24(configDir, project2.functionsDir);
+  const configDir = dirname17(project2.configPath);
+  const functionsDir = join22(configDir, project2.functionsDir);
   const pluginFunctionNames = new Set(functions.filter((fn) => fn.source.type === "plugin").map((fn) => fn.name));
   const remoteFunctions = await runTask2("Fetching functions from Base44", async () => {
     const { functions: functions2 } = await listDeployedFunctions();
@@ -257301,12 +256640,53 @@ function getFunctionsCommand() {
   return new Command("functions").description("Manage backend functions").addCommand(getDeployCommand()).addCommand(getDeleteCommand()).addCommand(getListCommand()).addCommand(getPullCommand());
 }
 
+// src/cli/commands/project/site-build.ts
+async function runSiteBuild({ runTask: runTask2 }, { root, buildCommand, appId }) {
+  if (!buildCommand) {
+    throw new ConfigNotFoundError("No site build command found.", {
+      hints: [
+        {
+          message: `Add 'site.buildCommand' to your config.jsonc (e.g., "site": { "buildCommand": "npm run build" })`
+        }
+      ]
+    });
+  }
+  await runTask2("Building site...", () => execa({
+    cwd: root,
+    shell: true,
+    env: { VITE_BASE44_APP_ID: appId }
+  })`${buildCommand}`, {
+    successMessage: "Site built successfully",
+    errorMessage: "Build failed"
+  });
+}
+
+// src/cli/commands/project/build.ts
+async function buildAction(ctx) {
+  const { app } = ctx;
+  if (!app?.projectRoot) {
+    throw new ConfigInvalidError("base44 build requires a linked local project. Run it from a project with base44/.app.jsonc.");
+  }
+  const { project: project2 } = await readProjectConfig(app.projectRoot);
+  await runSiteBuild(ctx, {
+    root: project2.root,
+    buildCommand: project2.site?.buildCommand,
+    appId: app.id
+  });
+  return {
+    outroMessage: `Site built with app id ${theme.styles.bold(app.id)}`
+  };
+}
+function getBuildCommand() {
+  return new Base44Command("build").description("Build the site with the Base44 app id injected").action(buildAction);
+}
+
 // src/cli/commands/project/create.ts
-import { basename as basename4, resolve as resolve10 } from "node:path";
+import { basename as basename4, resolve as resolve8 } from "node:path";
 var import_kebabCase = __toESM(require_kebabCase(), 1);
 
 // src/cli/commands/project/scaffold-shared.ts
-import { join as join25 } from "node:path";
+import { join as join23 } from "node:path";
 var DEFAULT_TEMPLATE_ID = "backend-only";
 async function getTemplateById(templateId) {
   const templates = await listTemplates();
@@ -257323,7 +256703,7 @@ async function completeProjectSetup({
   projectId,
   name: name2,
   resolvedPath,
-  deploy: deploy6,
+  deploy: deploy5,
   skills,
   isInteractive
 }, { runTask: runTask2 }) {
@@ -257337,7 +256717,7 @@ async function completeProjectSetup({
       });
       shouldPushEntities = !Ct(result) && result;
     } else {
-      shouldPushEntities = !!deploy6;
+      shouldPushEntities = !!deploy5;
     }
     if (shouldPushEntities) {
       await runTask2(`Pushing ${entities.length} data models to Base44...`, async () => {
@@ -257357,7 +256737,7 @@ async function completeProjectSetup({
       });
       shouldDeploy = !Ct(result) && result;
     } else {
-      shouldDeploy = !!deploy6;
+      shouldDeploy = !!deploy5;
     }
     if (shouldDeploy && installCommand && buildCommand && outputDirectory) {
       const { appUrl } = await runTask2("Installing dependencies...", async (updateMessage) => {
@@ -257365,7 +256745,7 @@ async function completeProjectSetup({
         updateMessage("Building project...");
         await execa({ cwd: resolvedPath, shell: true })`${buildCommand}`;
         updateMessage("Deploying site...");
-        return await deploySite(join25(resolvedPath, outputDirectory));
+        return await deploySite(join23(resolvedPath, outputDirectory));
       }, {
         successMessage: theme.colors.base44Orange("Site deployed successfully"),
         errorMessage: "Failed to deploy site"
@@ -257494,7 +256874,7 @@ async function createInteractive(options, ctx) {
   }, ctx);
 }
 async function createNonInteractive(options, ctx) {
-  ctx.log.info(`Creating a new project at ${resolve10(options.path)}`);
+  ctx.log.info(`Creating a new project at ${resolve8(options.path)}`);
   const template2 = await getTemplateById(options.template ?? DEFAULT_TEMPLATE_ID);
   return await executeCreate({
     template: template2,
@@ -257511,14 +256891,14 @@ async function executeCreate({
   name: rawName,
   description,
   projectPath,
-  deploy: deploy6,
+  deploy: deploy5,
   skills,
   workspaceId: flagWorkspaceId,
   isInteractive
 }, ctx) {
   const { log, runTask: runTask2 } = ctx;
   const name2 = rawName.trim();
-  const resolvedPath = resolve10(projectPath);
+  const resolvedPath = resolve8(projectPath);
   const organizationId = await resolveWorkspaceId(ctx, flagWorkspaceId, isInteractive);
   const { projectId } = await runTask2("Setting up your project...", async () => {
     return await createProjectFiles({
@@ -257533,7 +256913,7 @@ async function executeCreate({
     errorMessage: "Failed to create project"
   });
   setAppContext({ id: projectId, projectRoot: resolvedPath });
-  const summary = await completeProjectSetup({ projectId, name: name2, resolvedPath, deploy: deploy6, skills, isInteractive }, ctx);
+  const summary = await completeProjectSetup({ projectId, name: name2, resolvedPath, deploy: deploy5, skills, isInteractive }, ctx);
   printProjectSummary(summary, log);
   return { outroMessage: "Your project is set up and ready to use" };
 }
@@ -257569,24 +256949,17 @@ Examples:
 }
 
 // src/cli/commands/project/deploy.ts
-import { resolve as resolve11 } from "node:path";
-async function deployAction(ctx, options = {}) {
-  const { isNonInteractive, log } = ctx;
+async function deployAction({ isNonInteractive, log }, options = {}) {
   if (isNonInteractive && !options.yes) {
     throw new InvalidInputError("--yes is required in non-interactive mode");
   }
-  if (options.build && options.prebuilt) {
-    throw new InvalidInputError("--build and --prebuilt cannot be combined.");
-  }
   const projectData = await readProjectConfig(options.projectRoot);
-  const { project: project2, entities, functions, agents, connectors, authConfig } = projectData;
-  let fullStackArtifact = await detectFullStackArtifact(project2.root);
-  const isFullStackCandidate = fullStackArtifact !== null || Boolean(project2.site?.buildCommand);
-  if (!hasResourcesToDeploy(projectData) && !isFullStackCandidate) {
+  if (!hasResourcesToDeploy(projectData)) {
     return {
       outroMessage: "No resources found to deploy"
     };
   }
+  const { project: project2, entities, functions, agents, connectors, authConfig } = projectData;
   const summaryLines = [];
   if (entities.length > 0) {
     summaryLines.push(`  - ${entities.length} ${entities.length === 1 ? "entity" : "entities"}`);
@@ -257606,9 +256979,7 @@ async function deployAction(ctx, options = {}) {
   if (project2.visibility) {
     summaryLines.push(`  - Visibility: ${project2.visibility}`);
   }
-  if (fullStackArtifact) {
-    summaryLines.push("  - Full-stack app");
-  } else if (project2.site?.outputDirectory) {
+  if (project2.site?.outputDirectory) {
     summaryLines.push(`  - Site from ${project2.site.outputDirectory}`);
   }
   if (!options.yes) {
@@ -257629,7 +257000,6 @@ ${summaryLines.join(`
   let functionCompleted = 0;
   const functionTotal = functions.length;
   const result = await deployAll(projectData, {
-    site: false,
     onVisibilitySet: (level) => {
       log.success(`App visibility set to ${level}`);
     },
@@ -257642,20 +257012,6 @@ ${summaryLines.join(`
       formatDeployResult(r, log);
     }
   });
-  await buildSiteIfNeeded(ctx, projectData, options, fullStackArtifact);
-  fullStackArtifact = await detectFullStackArtifact(project2.root);
-  let appUrl;
-  let fullStackResult;
-  if (fullStackArtifact) {
-    fullStackResult = await runFullStackDeploy(ctx, project2.root, options);
-  } else if (project2.site?.outputDirectory) {
-    const outputDir = resolve11(project2.root, project2.site.outputDirectory);
-    if (staticWorkersEnabled()) {
-      fullStackResult = await runFullStackDeploy(ctx, project2.root, options, outputDir);
-    } else {
-      ({ appUrl } = await deploySite(outputDir));
-    }
-  }
   const connectorResults = result.connectorResults ?? [];
   await handleOAuthConnectors(connectorResults, isNonInteractive, options, log);
   const stripeResult = connectorResults.find((r) => r.type === "stripe");
@@ -257663,83 +257019,13 @@ ${summaryLines.join(`
     printStripeResult(stripeResult, log);
   }
   log.message(`${theme.styles.header("Dashboard")}: ${theme.colors.links(getDashboardUrl())}`);
-  if (appUrl) {
-    log.message(`${theme.styles.header("App URL")}: ${theme.colors.links(appUrl)}`);
-  }
-  if (fullStackResult) {
-    printFullStackSummary(fullStackResult, log);
-  }
-  return {
-    outroMessage: "App deployed successfully",
-    stdout: ctx.jsonMode && fullStackResult ? `${JSON.stringify({
-      deploymentId: fullStackResult.deploymentId,
-      gitHash: fullStackResult.gitHash
-    }, null, 2)}
-` : undefined
-  };
-}
-async function buildSiteIfNeeded({ runTask: runTask2 }, { project: project2 }, options, fullStackArtifact) {
-  const site2 = project2.site;
-  if (!site2?.buildCommand || options.prebuilt)
-    return;
-  const artifactPresent = fullStackArtifact !== null || (site2.outputDirectory ? await pathExists(resolve11(project2.root, site2.outputDirectory)) : false);
-  if (artifactPresent && !options.build)
-    return;
-  const { installCommand, buildCommand } = site2;
-  await runTask2(installCommand ? "Installing dependencies..." : "Building project...", async (updateMessage) => {
-    if (installCommand) {
-      await execa({ cwd: project2.root, shell: true })`${installCommand}`;
-      updateMessage("Building project...");
-    }
-    await execa({ cwd: project2.root, shell: true })`${buildCommand}`;
-  }, {
-    successMessage: "Project built successfully",
-    errorMessage: "Failed to build project"
-  });
-}
-async function runFullStackDeploy({ runTask: runTask2, log }, projectRoot, options, staticOutputDir) {
-  const gitHash = await resolveGitHash(projectRoot, options.gitHash);
-  const progressLines = [];
-  const warnings = [];
-  const deployment = await runTask2(staticOutputDir ? "Deploying site to Workers..." : "Deploying full-stack app...", async (updateMessage) => {
-    const progress = {
-      onWarning: (message) => {
-        warnings.push(message);
-      },
-      onAssets: ({ totalAssets, newAssets }) => {
-        const line = `Found ${totalAssets} static assets (${newAssets} new)`;
-        progressLines.push(line);
-        updateMessage(line);
-      },
-      onAssetUpload: ({ uploadedFiles, totalFiles }) => {
-        updateMessage(`Uploaded ${uploadedFiles} of ${totalFiles} assets`);
-      },
-      onWorker: ({ moduleCount }) => {
-        updateMessage(`Deploying worker (${moduleCount} modules)…`);
-      }
-    };
-    return staticOutputDir ? await deployStaticSite({
-      outputDir: staticOutputDir,
-      gitHash,
-      progress
-    }) : await deployFullStack({ projectRoot, gitHash, progress });
-  }, {
-    successMessage: theme.colors.base44Orange(staticOutputDir ? "Site deployed to Workers" : "Full-stack app deployed"),
-    errorMessage: staticOutputDir ? "Site deploy failed" : "Full-stack deploy failed"
-  });
-  for (const line of progressLines) {
-    log.message(theme.styles.dim(line));
+  if (result.appUrl) {
+    log.message(`${theme.styles.header("App URL")}: ${theme.colors.links(result.appUrl)}`);
   }
-  for (const warning of warnings) {
-    log.warn(warning);
-  }
-  return deployment;
-}
-function printFullStackSummary(deployment, log) {
-  log.message(`${theme.styles.header("Deployment")}: ${deployment.deploymentId} ${theme.styles.dim(`(commit ${deployment.gitHash.slice(0, 12)})`)}`);
+  return { outroMessage: "App deployed successfully" };
 }
 function getDeployCommand2() {
-  return new Base44Command("deploy").description("Deploy all project resources (entities, functions, agents, connectors, and site)").option("-y, --yes", "Skip confirmation prompt").option("--git-hash <hash>", "Commit the full-stack build came from (defaults to the checkout's HEAD)").option("--build", "Run the configured install/build commands before deploying, even when a build artifact already exists").option("--prebuilt", "Skip the build step and deploy the existing artifact").action(deployAction);
+  return new Base44Command("deploy").description("Deploy all project resources (entities, functions, agents, connectors, and site)").option("-y, --yes", "Skip confirmation prompt").action(deployAction);
 }
 async function handleOAuthConnectors(connectorResults, isNonInteractive, options, log) {
   const needsOAuth = filterPendingOAuth(connectorResults);
@@ -258017,7 +257303,7 @@ async function followLogs(functionNames, options, availableFunctionNames, jsonMo
     for (const entry of fresh)
       writeFollowLine(entry, jsonMode);
     first = false;
-    await new Promise((resolve12) => setTimeout(resolve12, 2000));
+    await new Promise((resolve9) => setTimeout(resolve9, 2000));
   }
 }
 function formatLogs(entries, env3) {
@@ -258131,7 +257417,7 @@ function getLogsCommand() {
 }
 
 // src/cli/commands/project/scaffold.ts
-import { basename as basename5, resolve as resolve12 } from "node:path";
+import { basename as basename5, resolve as resolve9 } from "node:path";
 function resolveAppId(options) {
   const appId = options.appId;
   if (!appId) {
@@ -258147,7 +257433,7 @@ function resolveAppId(options) {
 async function scaffoldAction(ctx, name2, options, command2) {
   const { log, runTask: runTask2 } = ctx;
   const appId = resolveAppId(command2.optsWithGlobals());
-  const resolvedPath = resolve12("./");
+  const resolvedPath = resolve9("./");
   const projectName = (name2 ?? basename5(resolvedPath)).trim();
   const template2 = await getTemplateById("backend-only");
   log.info(`Scaffolding project at ${resolvedPath}`);
@@ -258313,7 +257599,7 @@ function withSandboxAuthHint(error48) {
     cause: error48
   });
 }
-async function callTool(appId, tool, payload, schema13, context, timeout2 = 60000) {
+async function callTool(appId, tool, payload, schema12, context, timeout2 = 60000) {
   const client = getSandboxClient(appId);
   let response;
   try {
@@ -258321,7 +257607,7 @@ async function callTool(appId, tool, payload, schema13, context, timeout2 = 6000
   } catch (error48) {
     throw withSandboxAuthHint(await ApiError.fromHttpError(error48, context));
   }
-  const result = schema13.safeParse(await response.json());
+  const result = schema12.safeParse(await response.json());
   if (!result.success) {
     throw new SchemaValidationError("Invalid response from server", result.error);
   }
@@ -258330,7 +257616,7 @@ async function callTool(appId, tool, payload, schema13, context, timeout2 = 6000
 function listDirectory(appId, params) {
   return callTool(appId, "list_directory", { ...params }, ListDirectoryResponseSchema, "listing directory");
 }
-function readFile5(appId, params) {
+function readFile2(appId, params) {
   return callTool(appId, "read_file", { ...params }, ReadFileResponseSchema, "reading file");
 }
 function writeFile2(appId, params) {
@@ -258460,7 +257746,7 @@ async function readFileAction({ runTask: runTask2 }, paths, options) {
   const { id: appId } = getAppContext();
   const offset = parsePositiveInt(options.offset, "--offset");
   const limit = parsePositiveInt(options.limit, "--limit");
-  const result = await runTask2("Reading file", () => readFile5(appId, { paths, offset, limit }));
+  const result = await runTask2("Reading file", () => readFile2(appId, { paths, offset, limit }));
   return { outroMessage: "Read file", stdout: toJsonStdout(result) };
 }
 function getSandboxReadFileCommand() {
@@ -258544,7 +257830,7 @@ function getSecretsListCommand() {
 }
 
 // src/cli/commands/secrets/set.ts
-import { resolve as resolve13 } from "node:path";
+import { resolve as resolve10 } from "node:path";
 function parseEntries(entries) {
   const secrets = {};
   for (const entry of entries) {
@@ -258575,7 +257861,7 @@ async function setSecretsAction({ log, runTask: runTask2 }, entries, options) {
   validateInput(entries, options);
   let secrets;
   if (options.envFile) {
-    secrets = await parseEnvFile(resolve13(options.envFile));
+    secrets = await parseEnvFile(resolve10(options.envFile));
     if (Object.keys(secrets).length === 0) {
       throw new InvalidInputError("The env file contains no valid KEY=VALUE entries.");
     }
@@ -258604,7 +257890,7 @@ function getSecretsCommand() {
 }
 
 // src/cli/commands/site/deploy.ts
-import { resolve as resolve14 } from "node:path";
+import { resolve as resolve11 } from "node:path";
 async function deployAction2({ isNonInteractive, runTask: runTask2 }, options) {
   if (isNonInteractive && !options.yes) {
     throw new InvalidInputError("--yes is required in non-interactive mode");
@@ -258619,7 +257905,7 @@ async function deployAction2({ isNonInteractive, runTask: runTask2 }, options) {
       ]
     });
   }
-  const outputDir = resolve14(project2.root, project2.site.outputDirectory);
+  const outputDir = resolve11(project2.root, project2.site.outputDirectory);
   if (!options.yes) {
     const shouldDeploy = await Re({
       message: `Deploy site from ${project2.site.outputDirectory}?`
@@ -258715,9 +258001,9 @@ async function generateContent(input) {
 `);
 }
 async function compileEntity(entity2) {
-  const { name: name2, source: _source, ...schema13 } = entity2;
+  const { name: name2, source: _source, ...schema12 } = entity2;
   const jsonSchema = {
-    ...schema13,
+    ...schema12,
     title: name2,
     additionalProperties: false
   };
@@ -258744,10 +258030,10 @@ function toPascalCase(name2) {
   return name2.split(/[-_\s]+/).map((w8) => w8.charAt(0).toUpperCase() + w8.slice(1)).join("");
 }
 // src/core/types/update-project.ts
-import { join as join28 } from "node:path";
+import { join as join26 } from "node:path";
 var TYPES_INCLUDE_PATH = `${PROJECT_SUBDIR}/${TYPES_OUTPUT_SUBDIR}/*.d.ts`;
 async function updateProjectConfig(projectRoot) {
-  const tsconfigPath = join28(projectRoot, "tsconfig.json");
+  const tsconfigPath = join26(projectRoot, "tsconfig.json");
   if (!await pathExists(tsconfigPath)) {
     return false;
   }
@@ -258982,7 +258268,7 @@ function createDevLogger(label2, labelColor = theme.styles.dim) {
 // src/cli/dev/dev-server/main.ts
 var import_cors = __toESM(require_lib4(), 1);
 var import_express6 = __toESM(require_express(), 1);
-import { dirname as dirname24, join as join35 } from "node:path";
+import { dirname as dirname23, join as join31 } from "node:path";
 
 // ../../node_modules/get-port/index.js
 import net from "node:net";
@@ -259009,14 +258295,14 @@ var getLocalHosts = () => {
   }
   return results;
 };
-var checkAvailablePort = (options8) => new Promise((resolve16, reject) => {
+var checkAvailablePort = (options8) => new Promise((resolve13, reject) => {
   const server = net.createServer();
   server.unref();
   server.on("error", reject);
   server.listen(options8, () => {
     const { port } = server.address();
     server.close(() => {
-      resolve16(port);
+      resolve13(port);
     });
   });
 });
@@ -259117,7 +258403,7 @@ var $setGracefulCleanup = tmp.setGracefulCleanup;
 
 // src/cli/dev/dev-server/function-manager.ts
 import { spawn as spawn2 } from "node:child_process";
-import { dirname as dirname21, join as join29 } from "node:path";
+import { dirname as dirname20, join as join27 } from "node:path";
 import { pathToFileURL } from "node:url";
 
 // src/cli/dev/dev-server/base-function-manager.ts
@@ -259222,7 +258508,7 @@ class FunctionManager extends BaseFunctionManager {
   }
   spawnFunction(func, port) {
     this.logger.log(`Spawning function "${func.name}" on port ${port}`);
-    const importMapPath = join29(dirname21(this.wrapperPath), "import-map.json");
+    const importMapPath = join27(dirname20(this.wrapperPath), "import-map.json");
     const process23 = spawn2("deno", ["run", "--allow-all", "--import-map", importMapPath, this.wrapperPath], {
       env: {
         ...globalThis.process.env,
@@ -259261,7 +258547,7 @@ class FunctionManager extends BaseFunctionManager {
     });
   }
   waitForReady(name2, runningFunc) {
-    return new Promise((resolve16, reject) => {
+    return new Promise((resolve13, reject) => {
       runningFunc.process.on("exit", (code2) => {
         if (!runningFunc.ready) {
           clearTimeout(timeout3);
@@ -259284,7 +258570,7 @@ class FunctionManager extends BaseFunctionManager {
           runningFunc.ready = true;
           clearTimeout(timeout3);
           runningFunc.process.stdout?.off("data", onData);
-          resolve16(runningFunc.port);
+          resolve13(runningFunc.port);
         }
       };
       runningFunc.process.stdout?.on("data", onData);
@@ -259296,7 +258582,7 @@ class FunctionManager extends BaseFunctionManager {
 import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { isBuiltin } from "node:module";
 import { homedir as homedir3 } from "node:os";
-import { join as join30 } from "node:path";
+import { join as join28 } from "node:path";
 import { pathToFileURL as pathToFileURL6 } from "node:url";
 var depsPromise;
 function loadDeps() {
@@ -259417,9 +258703,9 @@ export default {
 };
 `;
 function ensureBundlerConfig() {
-  const dir = join30(homedir3(), ".base44", "function-bundler");
+  const dir = join28(homedir3(), ".base44", "function-bundler");
   mkdirSync2(dir, { recursive: true });
-  const configPath = join30(dir, "deno.json");
+  const configPath = join28(dir, "deno.json");
   writeFileSync2(configPath, `${JSON.stringify({ nodeModulesDir: "auto" }, null, 2)}
 `);
   return configPath;
@@ -260007,22 +259293,22 @@ class Database {
     this.schemas.clear();
   }
   validate(entityName, record2, partial2 = false) {
-    const schema13 = this.schemas.get(this.normalizeName(entityName));
-    if (!schema13) {
+    const schema12 = this.schemas.get(this.normalizeName(entityName));
+    if (!schema12) {
       throw new Error(`Entity "${entityName}" not found`);
     }
-    return this.validator.validate(record2, schema13, partial2);
+    return this.validator.validate(record2, schema12, partial2);
   }
   prepareRecord(entityName, record2, partial2 = false) {
-    const schema13 = this.schemas.get(this.normalizeName(entityName));
-    if (!schema13) {
+    const schema12 = this.schemas.get(this.normalizeName(entityName));
+    if (!schema12) {
       throw new Error(`Entity "${entityName}" not found`);
     }
-    const filteredRecord = this.validator.filterFields(record2, schema13);
+    const filteredRecord = this.validator.filterFields(record2, schema12);
     if (partial2) {
       return filteredRecord;
     }
-    return this.validator.applyDefaults(filteredRecord, schema13);
+    return this.validator.applyDefaults(filteredRecord, schema12);
   }
   normalizeName(entityName) {
     return entityName.toLowerCase();
@@ -260316,13 +259602,13 @@ function checkRLS(rule, record2, user) {
     return false;
   return evaluateCondition(rule, record2, user);
 }
-function applyFLS(record2, schema13, user, operation) {
+function applyFLS(record2, schema12, user, operation) {
   if (Array.isArray(record2)) {
-    return record2.map((r5) => applyFLS(r5, schema13, user, operation));
+    return record2.map((r5) => applyFLS(r5, schema12, user, operation));
   }
   const result = {};
   for (const [key2, value] of Object.entries(record2)) {
-    const rule = schema13.properties[key2]?.rls?.[operation];
+    const rule = schema12.properties[key2]?.rls?.[operation];
     if (rule === undefined || checkRLS(rule, record2, user)) {
       result[key2] = value;
     }
@@ -260550,14 +259836,14 @@ async function createEntityRoutes(db2, logger2, broadcast) {
         res.status(404).json({ error: `Entity "${entityName}" not found` });
         return;
       }
-      const schema13 = db2.getSchema(entityName);
-      if (!schema13) {
+      const schema12 = db2.getSchema(entityName);
+      if (!schema12) {
         res.status(404).json({ error: `Schema for "${entityName}" not found` });
         return;
       }
       const currentUserResult = await resolveCurrentUser(db2, req);
       const currentUser = currentUserResult.ok ? currentUserResult.user : undefined;
-      await handler(req, res, collection, schema13, currentUser);
+      await handler(req, res, collection, schema12, currentUser);
     };
   }
   function emit(appId, entityName, type, data) {
@@ -260575,19 +259861,19 @@ async function createEntityRoutes(db2, logger2, broadcast) {
     }
     broadcast(appId, entityName, createData(data));
   }
-  function prepareCreateRecord(entityName, body, schema13, currentUser, now) {
+  function prepareCreateRecord(entityName, body, schema12, currentUser, now) {
     const { _id, ...recordBody } = body;
     const ownerFields = {
       created_by: currentUser?.email,
       created_by_id: currentUser?.id
     };
-    if (!checkRLS(schema13.rls?.create, {
+    if (!checkRLS(schema12.rls?.create, {
       ...recordBody,
       ...ownerFields
     }, currentUser)) {
       return;
     }
-    const filteredBody = applyFLS(db2.prepareRecord(entityName, recordBody), schema13, currentUser, "write");
+    const filteredBody = applyFLS(db2.prepareRecord(entityName, recordBody), schema12, currentUser, "write");
     db2.validate(entityName, filteredBody);
     return {
       ...filteredBody,
@@ -260599,7 +259885,7 @@ async function createEntityRoutes(db2, logger2, broadcast) {
   }
   const userRouter = createUserRouter(db2, logger2);
   router.use("/User", userRouter);
-  router.get("/:entityName/:id", withCollection(async (req, res, collection, schema13, currentUser) => {
+  router.get("/:entityName/:id", withCollection(async (req, res, collection, schema12, currentUser) => {
     const { entityName, id: id2 } = req.params;
     try {
       const doc2 = await collection.findOneAsync({ id: id2 });
@@ -260607,27 +259893,27 @@ async function createEntityRoutes(db2, logger2, broadcast) {
         res.status(404).json({ error: `Record with id "${id2}" not found` });
         return;
       }
-      if (!checkRLS(schema13.rls?.read, doc2, currentUser)) {
+      if (!checkRLS(schema12.rls?.read, doc2, currentUser)) {
         res.status(404).json({
           message: `Entity ${entityName} with ID ${id2} not found`
         });
         return;
       }
-      const result = applyFLS(stripInternalFields(doc2), schema13, currentUser, "read");
+      const result = applyFLS(stripInternalFields(doc2), schema12, currentUser, "read");
       res.json(result);
     } catch (error48) {
       logger2.error(`Error in GET /${entityName}/${id2}:`, error48);
       res.status(500).json({ error: "Internal server error" });
     }
   }));
-  router.get("/:entityName", withCollection(async (req, res, collection, schema13, currentUser) => {
+  router.get("/:entityName", withCollection(async (req, res, collection, schema12, currentUser) => {
     const { entityName } = req.params;
     try {
       let results = stripInternalFields(await queryEntity(collection, req.query));
-      if (schema13.rls?.read !== undefined && schema13.rls.read !== true) {
-        results = results.filter((doc2) => checkRLS(schema13.rls.read, doc2, currentUser));
+      if (schema12.rls?.read !== undefined && schema12.rls.read !== true) {
+        results = results.filter((doc2) => checkRLS(schema12.rls.read, doc2, currentUser));
       }
-      results = results.map((doc2) => applyFLS(doc2, schema13, currentUser, "read"));
+      results = results.map((doc2) => applyFLS(doc2, schema12, currentUser, "read"));
       res.json(results);
     } catch (error48) {
       if (error48 instanceof InvalidInputError) {
@@ -260638,16 +259924,16 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       }
     }
   }));
-  router.post("/:entityName", parseBody, withCollection(async (req, res, collection, schema13, currentUser) => {
+  router.post("/:entityName", parseBody, withCollection(async (req, res, collection, schema12, currentUser) => {
     const { appId, entityName } = req.params;
     try {
       const now = new Date().toISOString();
-      const record2 = prepareCreateRecord(entityName, req.body, schema13, currentUser, now);
+      const record2 = prepareCreateRecord(entityName, req.body, schema12, currentUser, now);
       if (!record2) {
         res.status(403).json({ error: "Permission denied" });
         return;
       }
-      const inserted = applyFLS(stripInternalFields(await collection.insertAsync(record2)), schema13, currentUser, "read");
+      const inserted = applyFLS(stripInternalFields(await collection.insertAsync(record2)), schema12, currentUser, "read");
       emit(appId, entityName, "create", inserted);
       res.status(201).json(inserted);
     } catch (error48) {
@@ -260659,7 +259945,7 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       res.status(500).json({ error: "Internal server error" });
     }
   }));
-  router.post("/:entityName/bulk", parseBody, withCollection(async (req, res, collection, schema13, currentUser) => {
+  router.post("/:entityName/bulk", parseBody, withCollection(async (req, res, collection, schema12, currentUser) => {
     const { appId, entityName } = req.params;
     if (!Array.isArray(req.body)) {
       res.status(400).json({ error: "Request body must be an array" });
@@ -260669,14 +259955,14 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       const now = new Date().toISOString();
       const records = [];
       for (const body of req.body) {
-        const record2 = prepareCreateRecord(entityName, body, schema13, currentUser, now);
+        const record2 = prepareCreateRecord(entityName, body, schema12, currentUser, now);
         if (!record2) {
           res.status(403).json({ error: "Permission denied" });
           return;
         }
         records.push(record2);
       }
-      const inserted = applyFLS(stripInternalFields(await collection.insertAsync(records)), schema13, currentUser, "read");
+      const inserted = applyFLS(stripInternalFields(await collection.insertAsync(records)), schema12, currentUser, "read");
       emit(appId, entityName, "create", inserted);
       res.status(201).json(inserted);
     } catch (error48) {
@@ -260688,24 +259974,24 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       res.status(500).json({ error: "Internal server error" });
     }
   }));
-  router.put("/:entityName/:id", parseBody, withCollection(async (req, res, collection, schema13, currentUser) => {
+  router.put("/:entityName/:id", parseBody, withCollection(async (req, res, collection, schema12, currentUser) => {
     const { appId, entityName, id: id2 } = req.params;
     const { id: _id, created_date: _created_date, ...body } = req.body;
     try {
-      if (schema13.rls?.update !== undefined) {
+      if (schema12.rls?.update !== undefined) {
         const existing = await collection.findOneAsync({ id: id2 });
         if (!existing) {
           res.status(404).json({ error: `Record with id "${id2}" not found` });
           return;
         }
-        if (!checkRLS(schema13.rls.update, existing, currentUser)) {
+        if (!checkRLS(schema12.rls.update, existing, currentUser)) {
           res.status(404).json({
             message: `Entity ${entityName} with ID ${id2} not found`
           });
           return;
         }
       }
-      const filteredBody = applyFLS(db2.prepareRecord(entityName, body, true), schema13, currentUser, "write");
+      const filteredBody = applyFLS(db2.prepareRecord(entityName, body, true), schema12, currentUser, "write");
       db2.validate(entityName, filteredBody, true);
       const updateData = {
         ...filteredBody,
@@ -260716,7 +260002,7 @@ async function createEntityRoutes(db2, logger2, broadcast) {
         res.status(404).json({ error: `Record with id "${id2}" not found` });
         return;
       }
-      const updated = applyFLS(stripInternalFields(result.affectedDocuments), schema13, currentUser, "read");
+      const updated = applyFLS(stripInternalFields(result.affectedDocuments), schema12, currentUser, "read");
       emit(appId, entityName, "update", updated);
       res.json(updated);
     } catch (error48) {
@@ -260728,7 +260014,7 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       res.status(500).json({ error: "Internal server error" });
     }
   }));
-  router.delete("/:entityName/:id", withCollection(async (req, res, collection, schema13, currentUser) => {
+  router.delete("/:entityName/:id", withCollection(async (req, res, collection, schema12, currentUser) => {
     const { appId, entityName, id: id2 } = req.params;
     try {
       const doc2 = await collection.findOneAsync({ id: id2 });
@@ -260736,7 +260022,7 @@ async function createEntityRoutes(db2, logger2, broadcast) {
         res.status(404).json({ error: `Record with id "${id2}" not found` });
         return;
       }
-      if (!checkRLS(schema13.rls?.delete, doc2, currentUser)) {
+      if (!checkRLS(schema12.rls?.delete, doc2, currentUser)) {
         res.status(404).json({
           message: `Entity ${entityName} with ID ${id2} not found`
         });
@@ -260750,11 +260036,11 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       res.status(500).json({ error: "Internal server error" });
     }
   }));
-  router.delete("/:entityName", parseBody, withCollection(async (req, res, collection, schema13, currentUser) => {
+  router.delete("/:entityName", parseBody, withCollection(async (req, res, collection, schema12, currentUser) => {
     const { entityName } = req.params;
     try {
       const query = req.body || {};
-      const rlsDelete = schema13?.rls?.delete;
+      const rlsDelete = schema12?.rls?.delete;
       if (rlsDelete !== undefined && rlsDelete !== true) {
         if (rlsDelete === false && currentUser?.is_service !== true) {
           res.status(403).json({ error: "Permission denied" });
@@ -260781,11 +260067,11 @@ async function createEntityRoutes(db2, logger2, broadcast) {
 // src/cli/dev/dev-server/routes/integrations.ts
 var import_express5 = __toESM(require_express(), 1);
 var import_multer = __toESM(require_multer(), 1);
-import { createHash as createHash2, randomUUID as randomUUID4 } from "node:crypto";
+import { createHash, randomUUID as randomUUID4 } from "node:crypto";
 import fs28 from "node:fs";
 import path18 from "node:path";
 function createFileToken(fileUri) {
-  return createHash2("sha256").update(fileUri).digest("hex");
+  return createHash("sha256").update(fileUri).digest("hex");
 }
 function createIntegrationRoutes(mediaFilesDir, baseUrl, remoteProxy, logger2) {
   const router = import_express5.Router({ mergeParams: true });
@@ -260808,12 +260094,12 @@ function createIntegrationRoutes(mediaFilesDir, baseUrl, remoteProxy, logger2) {
       cb2(null, `${randomUUID4()}${ext}`);
     }
   });
-  const upload2 = import_multer.default({ storage, limits: { fileSize: MAX_FILE_SIZE } });
+  const upload = import_multer.default({ storage, limits: { fileSize: MAX_FILE_SIZE } });
   const privateUpload = import_multer.default({
     storage: privateStorage,
     limits: { fileSize: MAX_FILE_SIZE }
   });
-  router.post("/Core/UploadFile", upload2.single("file"), (req, res) => {
+  router.post("/Core/UploadFile", upload.single("file"), (req, res) => {
     if (!req.file) {
       res.status(400).json({ error: "No file uploaded" });
       return;
@@ -260870,16 +260156,16 @@ function createCustomIntegrationRoutes(remoteProxy, logger2) {
 
 // src/cli/dev/dev-server/watcher.ts
 import { EventEmitter as EventEmitter4 } from "node:events";
-import { relative as relative7 } from "node:path";
+import { relative as relative6 } from "node:path";
 
 // ../../node_modules/chokidar/index.js
 import { EventEmitter as EventEmitter3 } from "node:events";
 import { stat as statcb, Stats } from "node:fs";
-import { readdir as readdir4, stat as stat6 } from "node:fs/promises";
+import { readdir as readdir3, stat as stat4 } from "node:fs/promises";
 import * as sp3 from "node:path";
 
 // ../../node_modules/readdirp/index.js
-import { lstat as lstat2, readdir as readdir3, realpath, stat as stat4 } from "node:fs/promises";
+import { lstat as lstat2, readdir as readdir2, realpath, stat as stat2 } from "node:fs/promises";
 import { join as pjoin, relative as prelative, resolve as presolve, sep as psep } from "node:path";
 import { Readable as Readable6 } from "node:stream";
 var EntryTypes = {
@@ -260961,7 +260247,7 @@ class ReaddirpStream extends Readable6 {
     const { root: root2, type } = opts;
     this._fileFilter = normalizeFilter(opts.fileFilter);
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
-    const statMethod = opts.lstat ? lstat2 : stat4;
+    const statMethod = opts.lstat ? lstat2 : stat2;
     if (wantBigintFsStats) {
       this._stat = (path19) => statMethod(path19, { bigint: true });
     } else {
@@ -261032,7 +260318,7 @@ class ReaddirpStream extends Readable6 {
   async _exploreDir(path19, depth) {
     let files;
     try {
-      files = await readdir3(path19, this._rdOptions);
+      files = await readdir2(path19, this._rdOptions);
     } catch (error48) {
       this._onError(error48);
     }
@@ -261114,7 +260400,7 @@ function readdirp(root2, options8 = {}) {
 
 // ../../node_modules/chokidar/handler.js
 import { watch as fs_watch, unwatchFile, watchFile } from "node:fs";
-import { realpath as fsrealpath, lstat as lstat3, open as open2, stat as stat5 } from "node:fs/promises";
+import { realpath as fsrealpath, lstat as lstat3, open as open2, stat as stat3 } from "node:fs/promises";
 import { type as osType } from "node:os";
 import * as sp2 from "node:path";
 var STR_DATA = "data";
@@ -261140,7 +260426,7 @@ var EVENTS = {
 };
 var EV = EVENTS;
 var THROTTLE_MODE_WATCH = "watch";
-var statMethods = { lstat: lstat3, stat: stat5 };
+var statMethods = { lstat: lstat3, stat: stat3 };
 var KEY_LISTENERS = "listeners";
 var KEY_ERR = "errHandlers";
 var KEY_RAW = "rawEmitters";
@@ -261600,9 +260886,9 @@ class NodeFsHandler {
     if (this.fsw.closed) {
       return;
     }
-    const dirname23 = sp2.dirname(file2);
+    const dirname22 = sp2.dirname(file2);
     const basename7 = sp2.basename(file2);
-    const parent = this.fsw._getWatchedDir(dirname23);
+    const parent = this.fsw._getWatchedDir(dirname22);
     let prevStats = stats;
     if (parent.has(basename7))
       return;
@@ -261611,7 +260897,7 @@ class NodeFsHandler {
         return;
       if (!newStats || newStats.mtimeMs === 0) {
         try {
-          const newStats2 = await stat5(file2);
+          const newStats2 = await stat3(file2);
           if (this.fsw.closed)
             return;
           const at13 = newStats2.atimeMs;
@@ -261629,7 +260915,7 @@ class NodeFsHandler {
             prevStats = newStats2;
           }
         } catch (error48) {
-          this.fsw._remove(dirname23, basename7);
+          this.fsw._remove(dirname22, basename7);
         }
       } else if (parent.has(basename7)) {
         const at13 = newStats.atimeMs;
@@ -261718,7 +261004,7 @@ class NodeFsHandler {
         this._addToNodeFs(path19, initialAdd, wh2, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
-    return new Promise((resolve17, reject) => {
+    return new Promise((resolve14, reject) => {
       if (!stream)
         return reject();
       stream.once(STR_END, () => {
@@ -261727,7 +261013,7 @@ class NodeFsHandler {
           return;
         }
         const wasThrottled = throttler ? throttler.clear() : false;
-        resolve17(undefined);
+        resolve14(undefined);
         previous.getChildren().filter((item) => {
           return item !== directory && !current.has(item);
         }).forEach((item) => {
@@ -261852,11 +261138,11 @@ function createPattern(matcher) {
       if (matcher.path === string4)
         return true;
       if (matcher.recursive) {
-        const relative7 = sp3.relative(matcher.path, string4);
-        if (!relative7) {
+        const relative6 = sp3.relative(matcher.path, string4);
+        if (!relative6) {
           return false;
         }
-        return !relative7.startsWith("..") && !sp3.isAbsolute(relative7);
+        return !relative6.startsWith("..") && !sp3.isAbsolute(relative6);
       }
       return false;
     };
@@ -261959,7 +261245,7 @@ class DirEntry {
       return;
     const dir = this.path;
     try {
-      await readdir4(dir);
+      await readdir3(dir);
     } catch (err) {
       if (this._removeWatcher) {
         this._removeWatcher(sp3.dirname(dir), sp3.basename(dir));
@@ -262283,7 +261569,7 @@ class FSWatcher extends EventEmitter3 {
       const fullPath = opts.cwd ? sp3.join(opts.cwd, path19) : path19;
       let stats2;
       try {
-        stats2 = await stat6(fullPath);
+        stats2 = await stat4(fullPath);
       } catch (err) {}
       if (!stats2 || this.closed)
         return;
@@ -262387,8 +261673,8 @@ class FSWatcher extends EventEmitter3 {
     }
     return this._userIgnored(path19, stats);
   }
-  _isntIgnored(path19, stat7) {
-    return !this._isIgnored(path19, stat7);
+  _isntIgnored(path19, stat5) {
+    return !this._isIgnored(path19, stat5);
   }
   _getWatchHelpers(path19) {
     return new WatchHelper(path19, this.options.followSymlinks, this);
@@ -262555,7 +261841,7 @@ class WatchBase44 extends EventEmitter4 {
       ignoreInitial: true
     });
     watcher.on("all", import_debounce.default(async (_event, path19) => {
-      this.emit("change", name2, relative7(targetPath, path19));
+      this.emit("change", name2, relative6(targetPath, path19));
     }, WATCH_DEBOUNCE_MS));
     watcher.on("error", (err) => {
       this.logger.error(`Watch handler failed for ${targetPath}`, err);
@@ -262644,7 +261930,7 @@ async function createDevServer(options8) {
     }
     remoteProxy(req, res, next);
   });
-  const server = await new Promise((resolve18, reject) => {
+  const server = await new Promise((resolve15, reject) => {
     const s5 = app.listen(port, "127.0.0.1", (err) => {
       if (err) {
         if ("code" in err && err.code === "EADDRINUSE") {
@@ -262653,7 +261939,7 @@ async function createDevServer(options8) {
           reject(err);
         }
       } else {
-        resolve18(s5);
+        resolve15(s5);
       }
     });
   });
@@ -262662,8 +261948,8 @@ async function createDevServer(options8) {
     broadcastEntityEvent(io6, appId, entityName, event);
   };
   const base44ConfigWatcher = new WatchBase44({
-    functions: join35(dirname24(project2.configPath), project2.functionsDir),
-    entities: join35(dirname24(project2.configPath), project2.entitiesDir)
+    functions: join31(dirname23(project2.configPath), project2.functionsDir),
+    entities: join31(dirname23(project2.configPath), project2.entitiesDir)
   }, devLogger);
   base44ConfigWatcher.on("change", async (name2) => {
     try {
@@ -262703,13 +261989,13 @@ async function createDevServer(options8) {
     if (!server.listening) {
       return;
     }
-    await new Promise((resolve18, reject) => {
+    await new Promise((resolve15, reject) => {
       server.close((error48) => {
         if (error48) {
           reject(error48);
           return;
         }
-        resolve18();
+        resolve15();
       });
     });
   };
@@ -262780,15 +262066,15 @@ class ServeRunner {
       return;
     }
     this.stopping = true;
-    const exited = new Promise((resolve18) => child.once("exit", () => resolve18()));
+    const exited = new Promise((resolve15) => child.once("exit", () => resolve15()));
     if (process23.platform === "win32" && child.pid) {
       const taskkill = spawn3("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
         stdio: "ignore",
         windowsHide: true
       });
-      await new Promise((resolve18) => {
-        taskkill.once("exit", () => resolve18());
-        taskkill.once("error", () => resolve18());
+      await new Promise((resolve15) => {
+        taskkill.once("exit", () => resolve15());
+        taskkill.once("error", () => resolve15());
       });
     } else if (child.pid) {
       try {
@@ -262958,13 +262244,13 @@ async function runScript(options8) {
 }
 // src/cli/commands/exec.ts
 function readStdin2() {
-  return new Promise((resolve18, reject) => {
+  return new Promise((resolve15, reject) => {
     let data = "";
     process.stdin.setEncoding("utf-8");
     process.stdin.on("data", (chunk) => {
       data += chunk;
     });
-    process.stdin.on("end", () => resolve18(data));
+    process.stdin.on("end", () => resolve15(data));
     process.stdin.on("error", reject);
   });
 }
@@ -263035,7 +262321,7 @@ Examples:
 }
 
 // src/cli/commands/project/eject.ts
-import { resolve as resolve18 } from "node:path";
+import { resolve as resolve15 } from "node:path";
 var import_kebabCase2 = __toESM(require_kebabCase(), 1);
 async function eject(ctx, options8, command2) {
   const { log, runTask: runTask2, isNonInteractive } = ctx;
@@ -263099,7 +262385,7 @@ async function eject(ctx, options8, command2) {
     Ne("Operation cancelled.");
     throw new CLIExitError(0);
   }
-  const resolvedPath = resolve18(selectedPath);
+  const resolvedPath = resolve15(selectedPath);
   await runTask2("Downloading your project's code...", async (updateMessage) => {
     await createProjectFilesForExistingProject({
       projectId,
@@ -263161,6 +262447,7 @@ function createProgram(context) {
   program2.addCommand(getCreateCommand());
   program2.addCommand(getScaffoldCommand());
   program2.addCommand(getDashboardCommand());
+  program2.addCommand(getBuildCommand());
   program2.addCommand(getDeployCommand2());
   program2.addCommand(getVisibilityCommand());
   program2.addCommand(getLinkCommand());
@@ -263187,7 +262474,7 @@ var import_detect_agent = __toESM(require_dist5(), 1);
 import { release, type } from "node:os";
 
 // ../../node_modules/posthog-node/dist/extensions/error-tracking/modifiers/module.node.mjs
-import { dirname as dirname25, posix, sep as sep2 } from "path";
+import { dirname as dirname24, posix, sep } from "path";
 function createModulerModifier() {
   const getModuleFromFileName = createGetModuleFromFilename();
   return async (frames) => {
@@ -263196,7 +262483,7 @@ function createModulerModifier() {
     return frames;
   };
 }
-function createGetModuleFromFilename(basePath = process.argv[1] ? dirname25(process.argv[1]) : process.cwd(), isWindows5 = sep2 === "\\") {
+function createGetModuleFromFilename(basePath = process.argv[1] ? dirname24(process.argv[1]) : process.cwd(), isWindows5 = sep === "\\") {
   const normalizedBase = isWindows5 ? normalizeWindowsPath2(basePath) : basePath;
   return (filename) => {
     if (!filename)
@@ -265474,14 +264761,14 @@ async function addSourceContext(frames) {
   return frames;
 }
 function getContextLinesFromFile(path19, ranges, output) {
-  return new Promise((resolve19) => {
+  return new Promise((resolve16) => {
     const stream = createReadStream2(path19);
     const lineReaded = createInterface2({
       input: stream
     });
     function destroyStreamAndResolve() {
       stream.destroy();
-      resolve19();
+      resolve16();
     }
     let lineNumber = 0;
     let currentRangeIndex = 0;
@@ -266593,15 +265880,15 @@ class PostHogBackendClient extends PostHogCoreStateless {
       return true;
     if (this.featureFlagsPoller === undefined)
       return false;
-    return new Promise((resolve19) => {
+    return new Promise((resolve16) => {
       const timeout3 = setTimeout(() => {
         cleanup();
-        resolve19(false);
+        resolve16(false);
       }, timeoutMs);
       const cleanup = this._events.on("localEvaluationFlagsLoaded", (count2) => {
         clearTimeout(timeout3);
         cleanup();
-        resolve19(count2 > 0);
+        resolve16(count2 > 0);
       });
     });
   }
@@ -267385,9 +266672,9 @@ function addCommandInfoToErrorReporter(program2, errorReporter) {
   });
 }
 // src/cli/index.ts
-var __dirname4 = dirname26(fileURLToPath6(import.meta.url));
+var __dirname4 = dirname25(fileURLToPath6(import.meta.url));
 async function runCLI(options8) {
-  ensureNpmAssets(join36(__dirname4, "../assets"));
+  ensureNpmAssets(join33(__dirname4, "../assets"));
   const errorReporter = new ErrorReporter;
   errorReporter.registerProcessErrorHandlers();
   const jsonMode = process.argv.includes("--json");
@@ -267426,4 +266713,4 @@ export {
   CLIExitError
 };
 
-//# debugId=FFEEAB2F2B84F55664756E2164756E21
+//# debugId=3CB9814E7E611A3164756E2164756E21