@base44-preview/cli 0.1.1-pr.555.f184656 → 0.1.1-pr.557.14ada15

package/dist/cli/index.js

@@ -12980,10 +12980,10 @@ var require_ejs = __commonJS((exports) => {
   exports.localsName = _DEFAULT_LOCALS_NAME;
   exports.promiseImpl = new Function("return this;")().Promise;
   exports.resolveInclude = function(name2, filename, isDir) {
-    var dirname11 = path11.dirname;
+    var dirname9 = path11.dirname;
     var extname = path11.extname;
     var resolve2 = path11.resolve;
-    var includePath = resolve2(isDir ? filename : dirname11(filename), name2);
+    var includePath = resolve2(isDir ? filename : dirname9(filename), name2);
     var ext = extname(name2);
     if (!ext) {
       includePath += ".ejs";
@@ -13361,10 +13361,10 @@ var require_ejs = __commonJS((exports) => {
       };
       if (opts.filename && typeof Object.defineProperty === "function") {
         var filename = opts.filename;
-        var basename5 = path11.basename(filename, path11.extname(filename));
+        var basename4 = path11.basename(filename, path11.extname(filename));
         try {
           Object.defineProperty(returnedFn, "name", {
-            value: basename5,
+            value: basename4,
             writable: false,
             enumerable: false,
             configurable: true
@@ -13718,12 +13718,12 @@ var require_schema = __commonJS((exports, module) => {
   var common = require_common3();
   var YAMLException = require_exception();
   var Type = require_type();
-  function compileList(schema8, name2, result) {
+  function compileList(schema7, name2, result) {
     var exclude = [];
-    schema8.include.forEach(function(includedSchema) {
+    schema7.include.forEach(function(includedSchema) {
       result = compileList(includedSchema, name2, result);
     });
-    schema8[name2].forEach(function(currentType) {
+    schema7[name2].forEach(function(currentType) {
       result.forEach(function(previousType, previousIndex) {
         if (previousType.tag === currentType.tag && previousType.kind === currentType.kind) {
           exclude.push(previousIndex);
@@ -13780,8 +13780,8 @@ var require_schema = __commonJS((exports, module) => {
     }
     schemas3 = common.toArray(schemas3);
     types = common.toArray(types);
-    if (!schemas3.every(function(schema8) {
-      return schema8 instanceof Schema;
+    if (!schemas3.every(function(schema7) {
+      return schema7 instanceof Schema;
     })) {
       throw new YAMLException("Specified list of super schemas (or a single Schema object) contains a non-Schema object.");
     }
@@ -15802,7 +15802,7 @@ var require_dumper = __commonJS((exports, module) => {
     "Off",
     "OFF"
   ];
-  function compileStyleMap(schema8, map2) {
+  function compileStyleMap(schema7, map2) {
     var result, keys, index, length, tag, style, type;
     if (map2 === null)
       return {};
@@ -15814,7 +15814,7 @@ var require_dumper = __commonJS((exports, module) => {
       if (tag.slice(0, 2) === "!!") {
         tag = "tag:yaml.org,2002:" + tag.slice(2);
       }
-      type = schema8.compiledTypeMap["fallback"][tag];
+      type = schema7.compiledTypeMap["fallback"][tag];
       if (type && _hasOwnProperty.call(type.styleAliases, style)) {
         style = type.styleAliases[style];
       }
@@ -23001,7 +23001,7 @@ var require_createNode = __commonJS((exports) => {
     if (value instanceof String || value instanceof Number || value instanceof Boolean || typeof BigInt !== "undefined" && value instanceof BigInt) {
       value = value.valueOf();
     }
-    const { aliasDuplicateObjects, onAnchor, onTagObj, schema: schema11, sourceObjects } = ctx;
+    const { aliasDuplicateObjects, onAnchor, onTagObj, schema: schema10, sourceObjects } = ctx;
     let ref = undefined;
     if (aliasDuplicateObjects && value && typeof value === "object") {
       ref = sourceObjects.get(value);
@@ -23015,7 +23015,7 @@ var require_createNode = __commonJS((exports) => {
     }
     if (tagName?.startsWith("!!"))
       tagName = defaultTagPrefix + tagName.slice(2);
-    let tagObj = findTagObject(value, tagName, schema11.tags);
+    let tagObj = findTagObject(value, tagName, schema10.tags);
     if (!tagObj) {
       if (value && typeof value.toJSON === "function") {
         value = value.toJSON();
@@ -23026,7 +23026,7 @@ var require_createNode = __commonJS((exports) => {
           ref.node = node2;
         return node2;
       }
-      tagObj = value instanceof Map ? schema11[identity3.MAP] : (Symbol.iterator in Object(value)) ? schema11[identity3.SEQ] : schema11[identity3.MAP];
+      tagObj = value instanceof Map ? schema10[identity3.MAP] : (Symbol.iterator in Object(value)) ? schema10[identity3.SEQ] : schema10[identity3.MAP];
     }
     if (onTagObj) {
       onTagObj(tagObj);
@@ -23049,7 +23049,7 @@ var require_Collection = __commonJS((exports) => {
   var createNode = require_createNode();
   var identity3 = require_identity();
   var Node2 = require_Node();
-  function collectionFromPath(schema11, path16, value) {
+  function collectionFromPath(schema10, path16, value) {
     let v = value;
     for (let i2 = path16.length - 1;i2 >= 0; --i2) {
       const k2 = path16[i2];
@@ -23067,27 +23067,27 @@ var require_Collection = __commonJS((exports) => {
       onAnchor: () => {
         throw new Error("This should not happen, please report a bug.");
       },
-      schema: schema11,
+      schema: schema10,
       sourceObjects: new Map
     });
   }
   var isEmptyPath = (path16) => path16 == null || typeof path16 === "object" && !!path16[Symbol.iterator]().next().done;
 
   class Collection extends Node2.NodeBase {
-    constructor(type, schema11) {
+    constructor(type, schema10) {
       super(type);
       Object.defineProperty(this, "schema", {
-        value: schema11,
+        value: schema10,
         configurable: true,
         enumerable: false,
         writable: true
       });
     }
-    clone(schema11) {
+    clone(schema10) {
       const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
-      if (schema11)
-        copy.schema = schema11;
-      copy.items = copy.items.map((it3) => identity3.isNode(it3) || identity3.isPair(it3) ? it3.clone(schema11) : it3);
+      if (schema10)
+        copy.schema = schema10;
+      copy.items = copy.items.map((it3) => identity3.isNode(it3) || identity3.isPair(it3) ? it3.clone(schema10) : it3);
       if (this.range)
         copy.range = this.range.slice();
       return copy;
@@ -24019,12 +24019,12 @@ var require_Pair = __commonJS((exports) => {
       this.key = key;
       this.value = value;
     }
-    clone(schema11) {
+    clone(schema10) {
       let { key, value } = this;
       if (identity3.isNode(key))
-        key = key.clone(schema11);
+        key = key.clone(schema10);
       if (identity3.isNode(value))
-        value = value.clone(schema11);
+        value = value.clone(schema10);
       return new Pair(key, value);
     }
     toJSON(_2, ctx) {
@@ -24209,13 +24209,13 @@ var require_YAMLMap = __commonJS((exports) => {
     static get tagName() {
       return "tag:yaml.org,2002:map";
     }
-    constructor(schema11) {
-      super(identity3.MAP, schema11);
+    constructor(schema10) {
+      super(identity3.MAP, schema10);
       this.items = [];
     }
-    static from(schema11, obj, ctx) {
+    static from(schema10, obj, ctx) {
       const { keepUndefined, replacer } = ctx;
-      const map2 = new this(schema11);
+      const map2 = new this(schema10);
       const add = (key, value) => {
         if (typeof replacer === "function")
           value = replacer.call(obj, key, value);
@@ -24231,8 +24231,8 @@ var require_YAMLMap = __commonJS((exports) => {
         for (const key of Object.keys(obj))
           add(key, obj[key]);
       }
-      if (typeof schema11.sortMapEntries === "function") {
-        map2.items.sort(schema11.sortMapEntries);
+      if (typeof schema10.sortMapEntries === "function") {
+        map2.items.sort(schema10.sortMapEntries);
       }
       return map2;
     }
@@ -24325,7 +24325,7 @@ var require_map2 = __commonJS((exports) => {
         onError("Expected a mapping for this tag");
       return map3;
     },
-    createNode: (schema11, obj, ctx) => YAMLMap.YAMLMap.from(schema11, obj, ctx)
+    createNode: (schema10, obj, ctx) => YAMLMap.YAMLMap.from(schema10, obj, ctx)
   };
   exports.map = map2;
 });
@@ -24343,8 +24343,8 @@ var require_YAMLSeq = __commonJS((exports) => {
     static get tagName() {
       return "tag:yaml.org,2002:seq";
     }
-    constructor(schema11) {
-      super(identity3.SEQ, schema11);
+    constructor(schema10) {
+      super(identity3.SEQ, schema10);
       this.items = [];
     }
     add(value) {
@@ -24398,9 +24398,9 @@ var require_YAMLSeq = __commonJS((exports) => {
         onComment
       });
     }
-    static from(schema11, obj, ctx) {
+    static from(schema10, obj, ctx) {
       const { replacer } = ctx;
-      const seq = new this(schema11);
+      const seq = new this(schema10);
       if (obj && Symbol.iterator in Object(obj)) {
         let i2 = 0;
         for (let it3 of obj) {
@@ -24437,7 +24437,7 @@ var require_seq2 = __commonJS((exports) => {
         onError("Expected a sequence for this tag");
       return seq2;
     },
-    createNode: (schema11, obj, ctx) => YAMLSeq.YAMLSeq.from(schema11, obj, ctx)
+    createNode: (schema10, obj, ctx) => YAMLSeq.YAMLSeq.from(schema10, obj, ctx)
   };
   exports.seq = seq;
 });
@@ -24612,7 +24612,7 @@ var require_schema2 = __commonJS((exports) => {
   var bool = require_bool2();
   var float = require_float2();
   var int2 = require_int2();
-  var schema11 = [
+  var schema10 = [
     map2.map,
     seq.seq,
     string4.string,
@@ -24625,7 +24625,7 @@ var require_schema2 = __commonJS((exports) => {
     float.floatExp,
     float.float
   ];
-  exports.schema = schema11;
+  exports.schema = schema10;
 });
 
 // ../../node_modules/yaml/dist/schema/json/schema.js
@@ -24688,8 +24688,8 @@ var require_schema3 = __commonJS((exports) => {
       return str;
     }
   };
-  var schema11 = [map2.map, seq.seq].concat(jsonScalars, jsonError);
-  exports.schema = schema11;
+  var schema10 = [map2.map, seq.seq].concat(jsonScalars, jsonError);
+  exports.schema = schema10;
 });
 
 // ../../node_modules/yaml/dist/schema/yaml-1.1/binary.js
@@ -24779,9 +24779,9 @@ ${cn.comment}` : item.comment;
       onError("Expected a sequence for this tag");
     return seq;
   }
-  function createPairs(schema11, iterable, ctx) {
+  function createPairs(schema10, iterable, ctx) {
     const { replacer } = ctx;
-    const pairs2 = new YAMLSeq.YAMLSeq(schema11);
+    const pairs2 = new YAMLSeq.YAMLSeq(schema10);
     pairs2.tag = "tag:yaml.org,2002:pairs";
     let i2 = 0;
     if (iterable && Symbol.iterator in Object(iterable))
@@ -24860,8 +24860,8 @@ var require_omap2 = __commonJS((exports) => {
       }
       return map2;
     }
-    static from(schema11, iterable, ctx) {
-      const pairs$1 = pairs.createPairs(schema11, iterable, ctx);
+    static from(schema10, iterable, ctx) {
+      const pairs$1 = pairs.createPairs(schema10, iterable, ctx);
       const omap2 = new this;
       omap2.items = pairs$1.items;
       return omap2;
@@ -24888,7 +24888,7 @@ var require_omap2 = __commonJS((exports) => {
       }
       return Object.assign(new YAMLOMap, pairs$1);
     },
-    createNode: (schema11, iterable, ctx) => YAMLOMap.from(schema11, iterable, ctx)
+    createNode: (schema10, iterable, ctx) => YAMLOMap.from(schema10, iterable, ctx)
   };
   exports.YAMLOMap = YAMLOMap;
   exports.omap = omap;
@@ -25052,8 +25052,8 @@ var require_set2 = __commonJS((exports) => {
   var YAMLMap = require_YAMLMap();
 
   class YAMLSet extends YAMLMap.YAMLMap {
-    constructor(schema11) {
-      super(schema11);
+    constructor(schema10) {
+      super(schema10);
       this.tag = YAMLSet.tag;
     }
     add(key) {
@@ -25093,9 +25093,9 @@ var require_set2 = __commonJS((exports) => {
       else
         throw new Error("Set items must all have null values");
     }
-    static from(schema11, iterable, ctx) {
+    static from(schema10, iterable, ctx) {
       const { replacer } = ctx;
-      const set3 = new this(schema11);
+      const set3 = new this(schema10);
       if (iterable && Symbol.iterator in Object(iterable))
         for (let value of iterable) {
           if (typeof replacer === "function")
@@ -25112,7 +25112,7 @@ var require_set2 = __commonJS((exports) => {
     nodeClass: YAMLSet,
     default: false,
     tag: "tag:yaml.org,2002:set",
-    createNode: (schema11, iterable, ctx) => YAMLSet.from(schema11, iterable, ctx),
+    createNode: (schema10, iterable, ctx) => YAMLSet.from(schema10, iterable, ctx),
     resolve(map2, onError) {
       if (identity3.isMap(map2)) {
         if (map2.hasAllNullValues(true))
@@ -25225,7 +25225,7 @@ var require_schema4 = __commonJS((exports) => {
   var pairs = require_pairs2();
   var set2 = require_set2();
   var timestamp = require_timestamp2();
-  var schema11 = [
+  var schema10 = [
     map2.map,
     seq.seq,
     string4.string,
@@ -25248,7 +25248,7 @@ var require_schema4 = __commonJS((exports) => {
     timestamp.floatTime,
     timestamp.timestamp
   ];
-  exports.schema = schema11;
+  exports.schema = schema10;
 });
 
 // ../../node_modules/yaml/dist/schema/tags.js
@@ -25260,7 +25260,7 @@ var require_tags = __commonJS((exports) => {
   var bool = require_bool2();
   var float = require_float2();
   var int2 = require_int2();
-  var schema11 = require_schema2();
+  var schema10 = require_schema2();
   var schema$1 = require_schema3();
   var binary = require_binary2();
   var merge3 = require_merge3();
@@ -25270,7 +25270,7 @@ var require_tags = __commonJS((exports) => {
   var set2 = require_set2();
   var timestamp = require_timestamp2();
   var schemas3 = new Map([
-    ["core", schema11.schema],
+    ["core", schema10.schema],
     ["failsafe", [map2.map, seq.seq, string4.string]],
     ["json", schema$1.schema],
     ["yaml11", schema$2.schema],
@@ -25352,9 +25352,9 @@ var require_Schema = __commonJS((exports) => {
   var sortMapEntriesByKey = (a2, b) => a2.key < b.key ? -1 : a2.key > b.key ? 1 : 0;
 
   class Schema {
-    constructor({ compat: compat2, customTags, merge: merge3, resolveKnownTags, schema: schema11, sortMapEntries, toStringDefaults }) {
+    constructor({ compat: compat2, customTags, merge: merge3, resolveKnownTags, schema: schema10, sortMapEntries, toStringDefaults }) {
       this.compat = Array.isArray(compat2) ? tags.getTags(compat2, "compat") : compat2 ? tags.getTags(null, compat2) : null;
-      this.name = typeof schema11 === "string" && schema11 || "core";
+      this.name = typeof schema10 === "string" && schema10 || "core";
       this.knownTags = resolveKnownTags ? tags.coreKnownTags : {};
       this.tags = tags.getTags(customTags, this.name, merge3);
       this.toStringOptions = toStringDefaults ?? null;
@@ -26846,11 +26846,11 @@ var require_compose_scalar = __commonJS((exports) => {
       scalar.comment = comment;
     return scalar;
   }
-  function findScalarTagByName(schema11, value, tagName, tagToken, onError) {
+  function findScalarTagByName(schema10, value, tagName, tagToken, onError) {
     if (tagName === "!")
-      return schema11[identity3.SCALAR];
+      return schema10[identity3.SCALAR];
     const matchWithTest = [];
-    for (const tag of schema11.tags) {
+    for (const tag of schema10.tags) {
       if (!tag.collection && tag.tag === tagName) {
         if (tag.default && tag.test)
           matchWithTest.push(tag);
@@ -26861,18 +26861,18 @@ var require_compose_scalar = __commonJS((exports) => {
     for (const tag of matchWithTest)
       if (tag.test?.test(value))
         return tag;
-    const kt3 = schema11.knownTags[tagName];
+    const kt3 = schema10.knownTags[tagName];
     if (kt3 && !kt3.collection) {
-      schema11.tags.push(Object.assign({}, kt3, { default: false, test: undefined }));
+      schema10.tags.push(Object.assign({}, kt3, { default: false, test: undefined }));
       return kt3;
     }
     onError(tagToken, "TAG_RESOLVE_FAILED", `Unresolved tag: ${tagName}`, tagName !== "tag:yaml.org,2002:str");
-    return schema11[identity3.SCALAR];
+    return schema10[identity3.SCALAR];
   }
-  function findScalarTagByTest({ atKey, directives, schema: schema11 }, value, token, onError) {
-    const tag = schema11.tags.find((tag2) => (tag2.default === true || atKey && tag2.default === "key") && tag2.test?.test(value)) || schema11[identity3.SCALAR];
-    if (schema11.compat) {
-      const compat2 = schema11.compat.find((tag2) => tag2.default && tag2.test?.test(value)) ?? schema11[identity3.SCALAR];
+  function findScalarTagByTest({ atKey, directives, schema: schema10 }, value, token, onError) {
+    const tag = schema10.tags.find((tag2) => (tag2.default === true || atKey && tag2.default === "key") && tag2.test?.test(value)) || schema10[identity3.SCALAR];
+    if (schema10.compat) {
+      const compat2 = schema10.compat.find((tag2) => tag2.default && tag2.test?.test(value)) ?? schema10[identity3.SCALAR];
       if (tag.tag !== compat2.tag) {
         const ts = directives.tagString(tag.tag);
         const cs = directives.tagString(compat2.tag);
@@ -31158,7 +31158,7 @@ function cleanDoc(doc2) {
   return mapDoc(doc2, (currentDoc) => cleanDocFn(currentDoc));
 }
 function replaceEndOfLine(doc2, replacement = literalline) {
-  return mapDoc(doc2, (currentDoc) => typeof currentDoc === "string" ? join23(replacement, currentDoc.split(`
+  return mapDoc(doc2, (currentDoc) => typeof currentDoc === "string" ? join22(replacement, currentDoc.split(`
 `)) : currentDoc);
 }
 function canBreakFn(doc2) {
@@ -31238,7 +31238,7 @@ function indentIfBreak(contents, options) {
     negate: options.negate
   };
 }
-function join23(separator, docs) {
+function join22(separator, docs) {
   assertDoc(separator);
   assertDocArray(docs);
   const parts = [];
@@ -31949,7 +31949,7 @@ var init_doc = __esm(() => {
   MODE_FLAT = Symbol("MODE_FLAT");
   DOC_FILL_PRINTED_LENGTH = Symbol("DOC_FILL_PRINTED_LENGTH");
   builders = {
-    join: join23,
+    join: join22,
     line,
     softline,
     hardline,
@@ -119560,11 +119560,11 @@ function chooseDescription(descriptions, printWidth) {
   return firstWidth > printWidth && firstWidth > secondWidth ? secondDescription : firstDescription;
 }
 function createSchema(SchemaConstructor, parameters) {
-  const schema11 = new SchemaConstructor(parameters);
-  const subSchema = Object.create(schema11);
+  const schema10 = new SchemaConstructor(parameters);
+  const subSchema = Object.create(schema10);
   for (const handlerKey of HANDLER_KEYS) {
     if (handlerKey in parameters) {
-      subSchema[handlerKey] = normalizeHandler(parameters[handlerKey], schema11, Schema2.prototype[handlerKey].length);
+      subSchema[handlerKey] = normalizeHandler(parameters[handlerKey], schema10, Schema2.prototype[handlerKey].length);
     }
   }
   return subSchema;
@@ -119821,8 +119821,8 @@ async function loadEditorconfigInternal(file2, { shouldCache }) {
   const directory = path52.dirname(file2);
   const root2 = await findProjectRoot2(directory, { shouldCache });
   const editorConfig = await import_editorconfig.default.parse(file2, { root: root2 });
-  const config13 = editorconfig_to_prettier_default(editorConfig);
-  return config13;
+  const config12 = editorconfig_to_prettier_default(editorConfig);
+  return config12;
 }
 function loadEditorconfig(file2, { shouldCache }) {
   file2 = path52.resolve(file2);
@@ -121812,18 +121812,18 @@ async function loadConfig(configFile) {
   if (!load2) {
     throw new Error(`No loader specified for extension "${extension || "noExt"}"`);
   }
-  let config13 = await load2(configFile);
-  if (!config13) {
+  let config12 = await load2(configFile);
+  if (!config12) {
     return;
   }
-  if (typeof config13 === "string") {
-    config13 = await load_external_config_default(config13, configFile);
+  if (typeof config12 === "string") {
+    config12 = await load_external_config_default(config12, configFile);
   }
-  if (typeof config13 !== "object") {
-    throw new TypeError(`Config is only allowed to be an object, but received ${typeof config13} in "${configFile}"`);
+  if (typeof config12 !== "object") {
+    throw new TypeError(`Config is only allowed to be an object, but received ${typeof config12} in "${configFile}"`);
   }
-  delete config13.$schema;
-  return config13;
+  delete config12.$schema;
+  return config12;
 }
 function clearPrettierConfigCache() {
   loadCache.clear();
@@ -121873,8 +121873,8 @@ async function loadPrettierConfig2(file2, options8) {
     return;
   }
   configFile = toPath3(configFile);
-  const config13 = await loadPrettierConfig(configFile, { shouldCache });
-  return { config: config13, configFile };
+  const config12 = await loadPrettierConfig(configFile, { shouldCache });
+  return { config: config12, configFile };
 }
 async function resolveConfig(fileUrlOrPath, options8) {
   options8 = { useCache: true, ...options8 };
@@ -121901,8 +121901,8 @@ async function resolveConfigFile(fileUrlOrPath) {
   return result ?? null;
 }
 function mergeOverrides(configResult, filePath) {
-  const { config: config13, configFile } = configResult || {};
-  const { overrides, ...options8 } = config13 || {};
+  const { config: config12, configFile } = configResult || {};
+  const { overrides, ...options8 } = config12 || {};
   if (filePath && overrides) {
     const relativeFilePath = path102.relative(path102.dirname(configFile), filePath);
     for (const override of overrides) {
@@ -122718,12 +122718,12 @@ function getLanguageByFileName(languages2, file2) {
   if (!file2) {
     return;
   }
-  const basename7 = getFileBasename(file2).toLowerCase();
+  const basename6 = getFileBasename(file2).toLowerCase();
   return languages2.find(({
     filenames
-  }) => filenames?.some((name2) => name2.toLowerCase() === basename7)) ?? languages2.find(({
+  }) => filenames?.some((name2) => name2.toLowerCase() === basename6)) ?? languages2.find(({
     extensions
-  }) => extensions?.some((extension) => basename7.endsWith(extension)));
+  }) => extensions?.some((extension) => basename6.endsWith(extension)));
 }
 function getLanguageByLanguageName(languages2, languageName) {
   if (!languageName) {
@@ -122904,9 +122904,9 @@ function optionInfoToSchema(optionInfo, {
       throw new Error(`Unexpected type ${optionInfo.type}`);
   }
   if (optionInfo.exception) {
-    parameters.validate = (value, schema11, utils3) => optionInfo.exception(value) || schema11.validate(value, utils3);
+    parameters.validate = (value, schema10, utils3) => optionInfo.exception(value) || schema10.validate(value, utils3);
   } else {
-    parameters.validate = (value, schema11, utils3) => value === undefined || schema11.validate(value, utils3);
+    parameters.validate = (value, schema10, utils3) => value === undefined || schema10.validate(value, utils3);
   }
   if (optionInfo.redirect) {
     handlers.redirect = (value) => !value ? undefined : {
@@ -122921,7 +122921,7 @@ function optionInfoToSchema(optionInfo, {
   }
   if (isCLI && !optionInfo.array) {
     const originalPreprocess = parameters.preprocess || ((x10) => x10);
-    parameters.preprocess = (value, schema11, utils3) => schema11.preprocess(originalPreprocess(Array.isArray(value) ? method_at_default2(0, value, -1) : value), utils3);
+    parameters.preprocess = (value, schema10, utils3) => schema10.preprocess(originalPreprocess(Array.isArray(value) ? method_at_default2(0, value, -1) : value), utils3);
   }
   return optionInfo.array ? ArraySchema.create({
     ...isCLI ? {
@@ -124011,16 +124011,16 @@ async function getFileInfo(file2, options8 = {}) {
   };
 }
 async function getParser(file2, options8) {
-  let config13;
+  let config12;
   if (options8.resolveConfig !== false) {
-    config13 = await resolveConfig(file2, {
+    config12 = await resolveConfig(file2, {
       editorconfig: false
     });
   }
-  if (config13?.parser) {
-    return config13.parser;
+  if (config12?.parser) {
+    return config12.parser;
   }
-  let plugins = options8.plugins ?? config13?.plugins ?? [];
+  let plugins = options8.plugins ?? config12?.plugins ?? [];
   plugins = (await Promise.all([load_builtin_plugins_default(), load_plugins_default(plugins)])).flat();
   return infer_parser_default({ plugins }, { physicalFile: file2 });
 }
@@ -124498,9 +124498,9 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc,
     };
     applyNormalization();
     for (const key2 of Object.keys(this._utils.schemas)) {
-      const schema11 = this._utils.schemas[key2];
+      const schema10 = this._utils.schemas[key2];
       if (!(key2 in newOptions)) {
-        const defaultResult = normalizeDefaultResult(schema11.default(this._utils));
+        const defaultResult = normalizeDefaultResult(schema10.default(this._utils));
         if ("value" in defaultResult) {
           restOptionsArray.push({ [key2]: defaultResult.value });
         }
@@ -124511,13 +124511,13 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc,
       if (!(key2 in newOptions)) {
         continue;
       }
-      const schema11 = this._utils.schemas[key2];
+      const schema10 = this._utils.schemas[key2];
       const value = newOptions[key2];
-      const newValue = schema11.postprocess(value, this._utils);
+      const newValue = schema10.postprocess(value, this._utils);
       if (newValue === VALUE_UNCHANGED) {
         continue;
       }
-      this._applyValidation(newValue, key2, schema11);
+      this._applyValidation(newValue, key2, schema10);
       newOptions[key2] = newValue;
     }
     this._applyPostprocess(newOptions);
@@ -124528,14 +124528,14 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc,
     const transferredOptionsArray = [];
     const { knownKeys, unknownKeys } = this._partitionOptionKeys(options8);
     for (const key2 of knownKeys) {
-      const schema11 = this._utils.schemas[key2];
-      const value = schema11.preprocess(options8[key2], this._utils);
-      this._applyValidation(value, key2, schema11);
+      const schema10 = this._utils.schemas[key2];
+      const value = schema10.preprocess(options8[key2], this._utils);
+      this._applyValidation(value, key2, schema10);
       const appendTransferredOptions = ({ from, to: to5 }) => {
         transferredOptionsArray.push(typeof to5 === "string" ? { [to5]: from } : { [to5.key]: to5.value });
       };
       const warnDeprecated = ({ value: currentValue, redirectTo }) => {
-        const deprecatedResult = normalizeDeprecatedResult(schema11.deprecated(currentValue, this._utils), value, true);
+        const deprecatedResult = normalizeDeprecatedResult(schema10.deprecated(currentValue, this._utils), value, true);
         if (deprecatedResult === false) {
           return;
         }
@@ -124553,13 +124553,13 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc,
           }
         }
       };
-      const forwardResult = normalizeForwardResult(schema11.forward(value, this._utils), value);
+      const forwardResult = normalizeForwardResult(schema10.forward(value, this._utils), value);
       forwardResult.forEach(appendTransferredOptions);
-      const redirectResult = normalizeRedirectResult(schema11.redirect(value, this._utils), value);
+      const redirectResult = normalizeRedirectResult(schema10.redirect(value, this._utils), value);
       redirectResult.redirect.forEach(appendTransferredOptions);
       if ("remain" in redirectResult) {
         const remainingValue = redirectResult.remain;
-        newOptions[key2] = key2 in newOptions ? schema11.overlap(newOptions[key2], remainingValue, this._utils) : remainingValue;
+        newOptions[key2] = key2 in newOptions ? schema10.overlap(newOptions[key2], remainingValue, this._utils) : remainingValue;
         warnDeprecated({ value: remainingValue });
       }
       for (const { from, to: to5 } of redirectResult.redirect) {
@@ -124587,8 +124587,8 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc,
     const [knownKeys, unknownKeys] = partition(Object.keys(options8).filter((key2) => !this._identifyMissing(key2, options8)), (key2) => (key2 in this._utils.schemas));
     return { knownKeys, unknownKeys };
   }
-  _applyValidation(value, key2, schema11) {
-    const validateResult = normalizeValidateResult(schema11.validate(value, this._utils), value);
+  _applyValidation(value, key2, schema10) {
+    const validateResult = normalizeValidateResult(schema10.validate(value, this._utils), value);
     if (validateResult !== true) {
       throw this._invalidHandler(key2, validateResult.value, this._utils);
     }
@@ -124630,8 +124630,8 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc,
       for (const key2 of unknownKeys) {
         const value = postprocessed.override[key2];
         this._applyUnknownHandler(key2, value, options8, (knownResultKey, knownResultValue) => {
-          const schema11 = this._utils.schemas[knownResultKey];
-          this._applyValidation(knownResultValue, knownResultKey, schema11);
+          const schema10 = this._utils.schemas[knownResultKey];
+          this._applyValidation(knownResultValue, knownResultKey, schema10);
           options8[knownResultKey] = knownResultValue;
         });
       }
@@ -127945,8 +127945,8 @@ var init_prettier = __esm(() => {
       }
       exports.endsWithSlashGlobStar = endsWithSlashGlobStar;
       function isAffectDepthOfReadingPattern(pattern) {
-        const basename7 = path152.basename(pattern);
-        return endsWithSlashGlobStar(pattern) || isStaticPattern(basename7);
+        const basename6 = path152.basename(pattern);
+        return endsWithSlashGlobStar(pattern) || isStaticPattern(basename6);
       }
       exports.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
       function expandPatternsWithBraceExpansion(patterns) {
@@ -136863,7 +136863,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" ? join25(replacement, currentDoc.split(`
+      return mapDoc2(doc2, (currentDoc) => typeof currentDoc === "string" ? join24(replacement, currentDoc.split(`
 `)) : currentDoc);
     }
     function canBreakFn2(doc2) {
@@ -136949,7 +136949,7 @@ Expected it to be ${EXPECTED_TYPE_VALUES}.`;
         negate: options8.negate
       };
     }
-    function join25(separator, docs) {
+    function join24(separator, docs) {
       assertDoc2(separator);
       assertDocArray2(docs);
       const parts = [];
@@ -137614,7 +137614,7 @@ Expected it to be ${EXPECTED_TYPE_VALUES}.`;
       }
     }
     var builders2 = {
-      join: join25,
+      join: join24,
       line: line3,
       softline: softline2,
       hardline: hardline4,
@@ -138344,23 +138344,23 @@ var require_JSONSchema = __commonJS((exports) => {
   exports.Parent = Symbol("Parent");
   exports.Types = Symbol("Types");
   exports.Intersection = Symbol("Intersection");
-  exports.getRootSchema = (0, lodash_1.memoize)((schema11) => {
-    const parent = schema11[exports.Parent];
+  exports.getRootSchema = (0, lodash_1.memoize)((schema10) => {
+    const parent = schema10[exports.Parent];
     if (!parent) {
-      return schema11;
+      return schema10;
     }
     return (0, exports.getRootSchema)(parent);
   });
-  function isBoolean(schema11) {
-    return schema11 === true || schema11 === false;
+  function isBoolean(schema10) {
+    return schema10 === true || schema10 === false;
   }
   exports.isBoolean = isBoolean;
-  function isPrimitive(schema11) {
-    return !(0, lodash_1.isPlainObject)(schema11);
+  function isPrimitive(schema10) {
+    return !(0, lodash_1.isPlainObject)(schema10);
   }
   exports.isPrimitive = isPrimitive;
-  function isCompound(schema11) {
-    return Array.isArray(schema11.type) || "anyOf" in schema11 || "oneOf" in schema11;
+  function isCompound(schema10) {
+    return Array.isArray(schema10.type) || "anyOf" in schema10 || "oneOf" in schema10;
   }
   exports.isCompound = isCompound;
 });
@@ -138587,9 +138587,9 @@ var require_type2 = __commonJS((exports, module) => {
 var require_schema5 = __commonJS((exports, module) => {
   var YAMLException = require_exception2();
   var Type = require_type2();
-  function compileList(schema11, name2) {
+  function compileList(schema10, name2) {
     var result = [];
-    schema11[name2].forEach(function(currentType) {
+    schema10[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) {
@@ -140534,7 +140534,7 @@ var require_dumper2 = __commonJS((exports, module) => {
     "OFF"
   ];
   var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;
-  function compileStyleMap(schema11, map2) {
+  function compileStyleMap(schema10, map2) {
     var result, keys, index, length, tag, style, type;
     if (map2 === null)
       return {};
@@ -140546,7 +140546,7 @@ var require_dumper2 = __commonJS((exports, module) => {
       if (tag.slice(0, 2) === "!!") {
         tag = "tag:yaml.org,2002:" + tag.slice(2);
       }
-      type = schema11.compiledTypeMap["fallback"][tag];
+      type = schema10.compiledTypeMap["fallback"][tag];
       if (type && _hasOwnProperty.call(type.styleAliases, style)) {
         style = type.styleAliases[style];
       }
@@ -141205,11 +141205,11 @@ var require_utils7 = __commonJS((exports) => {
   function traverseArray(arr, callback, processed) {
     arr.forEach((s5, k9) => traverse(s5, callback, processed, k9.toString()));
   }
-  function traverseIntersection(schema11, callback, processed) {
-    if (typeof schema11 !== "object" || !schema11) {
+  function traverseIntersection(schema10, callback, processed) {
+    if (typeof schema10 !== "object" || !schema10) {
       return;
     }
-    const r5 = schema11;
+    const r5 = schema10;
     const intersection2 = r5[JSONSchema_1.Intersection];
     if (!intersection2) {
       return;
@@ -141218,60 +141218,60 @@ var require_utils7 = __commonJS((exports) => {
       traverseArray(intersection2.allOf, callback, processed);
     }
   }
-  function traverse(schema11, callback, processed = new Set, key2) {
-    if (processed.has(schema11)) {
+  function traverse(schema10, callback, processed = new Set, key2) {
+    if (processed.has(schema10)) {
       return;
     }
-    processed.add(schema11);
-    callback(schema11, key2 !== null && key2 !== undefined ? key2 : null);
-    if (schema11.anyOf) {
-      traverseArray(schema11.anyOf, callback, processed);
+    processed.add(schema10);
+    callback(schema10, key2 !== null && key2 !== undefined ? key2 : null);
+    if (schema10.anyOf) {
+      traverseArray(schema10.anyOf, callback, processed);
     }
-    if (schema11.allOf) {
-      traverseArray(schema11.allOf, callback, processed);
+    if (schema10.allOf) {
+      traverseArray(schema10.allOf, callback, processed);
     }
-    if (schema11.oneOf) {
-      traverseArray(schema11.oneOf, callback, processed);
+    if (schema10.oneOf) {
+      traverseArray(schema10.oneOf, callback, processed);
     }
-    if (schema11.properties) {
-      traverseObjectKeys(schema11.properties, callback, processed);
+    if (schema10.properties) {
+      traverseObjectKeys(schema10.properties, callback, processed);
     }
-    if (schema11.patternProperties) {
-      traverseObjectKeys(schema11.patternProperties, callback, processed);
+    if (schema10.patternProperties) {
+      traverseObjectKeys(schema10.patternProperties, callback, processed);
     }
-    if (schema11.additionalProperties && typeof schema11.additionalProperties === "object") {
-      traverse(schema11.additionalProperties, callback, processed);
+    if (schema10.additionalProperties && typeof schema10.additionalProperties === "object") {
+      traverse(schema10.additionalProperties, callback, processed);
     }
-    if (schema11.items) {
-      const { items } = schema11;
+    if (schema10.items) {
+      const { items } = schema10;
       if (Array.isArray(items)) {
         traverseArray(items, callback, processed);
       } else {
         traverse(items, callback, processed);
       }
     }
-    if (schema11.additionalItems && typeof schema11.additionalItems === "object") {
-      traverse(schema11.additionalItems, callback, processed);
+    if (schema10.additionalItems && typeof schema10.additionalItems === "object") {
+      traverse(schema10.additionalItems, callback, processed);
     }
-    if (schema11.dependencies) {
-      if (Array.isArray(schema11.dependencies)) {
-        traverseArray(schema11.dependencies, callback, processed);
+    if (schema10.dependencies) {
+      if (Array.isArray(schema10.dependencies)) {
+        traverseArray(schema10.dependencies, callback, processed);
       } else {
-        traverseObjectKeys(schema11.dependencies, callback, processed);
+        traverseObjectKeys(schema10.dependencies, callback, processed);
       }
     }
-    if (schema11.definitions) {
-      traverseObjectKeys(schema11.definitions, callback, processed);
+    if (schema10.definitions) {
+      traverseObjectKeys(schema10.definitions, callback, processed);
     }
-    if (schema11.$defs) {
-      traverseObjectKeys(schema11.$defs, callback, processed);
+    if (schema10.$defs) {
+      traverseObjectKeys(schema10.$defs, callback, processed);
     }
-    if (schema11.not) {
-      traverse(schema11.not, callback, processed);
+    if (schema10.not) {
+      traverse(schema10.not, callback, processed);
     }
-    traverseIntersection(schema11, callback, processed);
-    Object.keys(schema11).filter((key3) => !BLACKLISTED_KEYS.has(key3)).forEach((key3) => {
-      const child = schema11[key3];
+    traverseIntersection(schema10, callback, processed);
+    Object.keys(schema10).filter((key3) => !BLACKLISTED_KEYS.has(key3)).forEach((key3) => {
+      const child = schema10[key3];
       if (child && typeof child === "object") {
         traverseObjectKeys(child, callback, processed);
       }
@@ -141353,14 +141353,14 @@ var require_utils7 = __commonJS((exports) => {
         return (_g2 = color()) === null || _g2 === undefined ? undefined : _g2.whiteBright.bgYellow;
     }
   }
-  function escapeBlockComment(schema11) {
+  function escapeBlockComment(schema10) {
     const replacer = "* /";
-    if (schema11 === null || typeof schema11 !== "object") {
+    if (schema10 === null || typeof schema10 !== "object") {
       return;
     }
-    for (const key2 of Object.keys(schema11)) {
-      if (key2 === "description" && typeof schema11[key2] === "string") {
-        schema11[key2] = schema11[key2].replace(/\*\//g, replacer);
+    for (const key2 of Object.keys(schema10)) {
+      if (key2 === "description" && typeof schema10[key2] === "string") {
+        schema10[key2] = schema10[key2].replace(/\*\//g, replacer);
       }
     }
   }
@@ -141372,45 +141372,45 @@ var require_utils7 = __commonJS((exports) => {
     return path_1.posix.join(path_1.posix.normalize(outputPath), ...filePathRel);
   }
   exports.pathTransform = pathTransform;
-  function maybeStripDefault(schema11) {
-    if (!("default" in schema11)) {
-      return schema11;
+  function maybeStripDefault(schema10) {
+    if (!("default" in schema10)) {
+      return schema10;
     }
-    switch (schema11.type) {
+    switch (schema10.type) {
       case "array":
-        if (Array.isArray(schema11.default)) {
-          return schema11;
+        if (Array.isArray(schema10.default)) {
+          return schema10;
         }
         break;
       case "boolean":
-        if (typeof schema11.default === "boolean") {
-          return schema11;
+        if (typeof schema10.default === "boolean") {
+          return schema10;
         }
         break;
       case "integer":
       case "number":
-        if (typeof schema11.default === "number") {
-          return schema11;
+        if (typeof schema10.default === "number") {
+          return schema10;
         }
         break;
       case "string":
-        if (typeof schema11.default === "string") {
-          return schema11;
+        if (typeof schema10.default === "string") {
+          return schema10;
         }
         break;
       case "null":
-        if (schema11.default === null) {
-          return schema11;
+        if (schema10.default === null) {
+          return schema10;
         }
         break;
       case "object":
-        if ((0, lodash_1.isPlainObject)(schema11.default)) {
-          return schema11;
+        if ((0, lodash_1.isPlainObject)(schema10.default)) {
+          return schema10;
         }
         break;
     }
-    delete schema11.default;
-    return schema11;
+    delete schema10.default;
+    return schema10;
   }
   exports.maybeStripDefault = maybeStripDefault;
   function appendToDescription(existingDescription, ...values) {
@@ -141424,11 +141424,11 @@ ${values.join(`
 `);
   }
   exports.appendToDescription = appendToDescription;
-  function isSchemaLike(schema11) {
-    if (!(0, lodash_1.isPlainObject)(schema11)) {
+  function isSchemaLike(schema10) {
+    if (!(0, lodash_1.isPlainObject)(schema10)) {
       return false;
     }
-    const parent = schema11[JSONSchema_1.Parent];
+    const parent = schema10[JSONSchema_1.Parent];
     if (parent === null) {
       return true;
     }
@@ -141445,7 +141445,7 @@ ${values.join(`
       "properties",
       "required"
     ];
-    if (JSON_SCHEMA_KEYWORDS.some((_10) => parent[_10] === schema11)) {
+    if (JSON_SCHEMA_KEYWORDS.some((_10) => parent[_10] === schema10)) {
       return false;
     }
     return true;
@@ -141743,13 +141743,13 @@ var require_typesOfSchema = __commonJS((exports) => {
   exports.typesOfSchema = undefined;
   var lodash_1 = require_lodash8();
   var JSONSchema_1 = require_JSONSchema();
-  function typesOfSchema(schema11) {
-    if (schema11.tsType) {
+  function typesOfSchema(schema10) {
+    if (schema10.tsType) {
       return new Set(["CUSTOM_TYPE"]);
     }
     const matchedTypes = new Set;
     for (const [schemaType, f7] of Object.entries(matchers)) {
-      if (f7(schema11)) {
+      if (f7(schema10)) {
         matchedTypes.add(schemaType);
       }
     }
@@ -141760,26 +141760,26 @@ var require_typesOfSchema = __commonJS((exports) => {
   }
   exports.typesOfSchema = typesOfSchema;
   var matchers = {
-    ALL_OF(schema11) {
-      return "allOf" in schema11;
+    ALL_OF(schema10) {
+      return "allOf" in schema10;
     },
-    ANY(schema11) {
-      if (Object.keys(schema11).length === 0) {
+    ANY(schema10) {
+      if (Object.keys(schema10).length === 0) {
         return true;
       }
-      return schema11.type === "any";
+      return schema10.type === "any";
     },
-    ANY_OF(schema11) {
-      return "anyOf" in schema11;
+    ANY_OF(schema10) {
+      return "anyOf" in schema10;
     },
-    BOOLEAN(schema11) {
-      if ("enum" in schema11) {
+    BOOLEAN(schema10) {
+      if ("enum" in schema10) {
         return false;
       }
-      if (schema11.type === "boolean") {
+      if (schema10.type === "boolean") {
         return true;
       }
-      if (!(0, JSONSchema_1.isCompound)(schema11) && typeof schema11.default === "boolean") {
+      if (!(0, JSONSchema_1.isCompound)(schema10) && typeof schema10.default === "boolean") {
         return true;
       }
       return false;
@@ -141787,74 +141787,74 @@ var require_typesOfSchema = __commonJS((exports) => {
     CUSTOM_TYPE() {
       return false;
     },
-    NAMED_ENUM(schema11) {
-      return "enum" in schema11 && "tsEnumNames" in schema11;
+    NAMED_ENUM(schema10) {
+      return "enum" in schema10 && "tsEnumNames" in schema10;
     },
-    NAMED_SCHEMA(schema11) {
-      return "$id" in schema11 && (("patternProperties" in schema11) || ("properties" in schema11));
+    NAMED_SCHEMA(schema10) {
+      return "$id" in schema10 && (("patternProperties" in schema10) || ("properties" in schema10));
     },
-    NEVER(schema11) {
-      return schema11 === false;
+    NEVER(schema10) {
+      return schema10 === false;
     },
-    NULL(schema11) {
-      return schema11.type === "null";
+    NULL(schema10) {
+      return schema10.type === "null";
     },
-    NUMBER(schema11) {
-      if ("enum" in schema11) {
+    NUMBER(schema10) {
+      if ("enum" in schema10) {
         return false;
       }
-      if (schema11.type === "integer" || schema11.type === "number") {
+      if (schema10.type === "integer" || schema10.type === "number") {
         return true;
       }
-      if (!(0, JSONSchema_1.isCompound)(schema11) && typeof schema11.default === "number") {
+      if (!(0, JSONSchema_1.isCompound)(schema10) && typeof schema10.default === "number") {
         return true;
       }
       return false;
     },
-    OBJECT(schema11) {
-      return schema11.type === "object" && !(0, lodash_1.isPlainObject)(schema11.additionalProperties) && !schema11.allOf && !schema11.anyOf && !schema11.oneOf && !schema11.patternProperties && !schema11.properties && !schema11.required;
+    OBJECT(schema10) {
+      return schema10.type === "object" && !(0, lodash_1.isPlainObject)(schema10.additionalProperties) && !schema10.allOf && !schema10.anyOf && !schema10.oneOf && !schema10.patternProperties && !schema10.properties && !schema10.required;
     },
-    ONE_OF(schema11) {
-      return "oneOf" in schema11;
+    ONE_OF(schema10) {
+      return "oneOf" in schema10;
     },
-    REFERENCE(schema11) {
-      return "$ref" in schema11;
+    REFERENCE(schema10) {
+      return "$ref" in schema10;
     },
-    STRING(schema11) {
-      if ("enum" in schema11) {
+    STRING(schema10) {
+      if ("enum" in schema10) {
         return false;
       }
-      if (schema11.type === "string") {
+      if (schema10.type === "string") {
         return true;
       }
-      if (!(0, JSONSchema_1.isCompound)(schema11) && typeof schema11.default === "string") {
+      if (!(0, JSONSchema_1.isCompound)(schema10) && typeof schema10.default === "string") {
         return true;
       }
       return false;
     },
-    TYPED_ARRAY(schema11) {
-      if (schema11.type && schema11.type !== "array") {
+    TYPED_ARRAY(schema10) {
+      if (schema10.type && schema10.type !== "array") {
         return false;
       }
-      return "items" in schema11;
+      return "items" in schema10;
     },
-    UNION(schema11) {
-      return Array.isArray(schema11.type);
+    UNION(schema10) {
+      return Array.isArray(schema10.type);
     },
-    UNNAMED_ENUM(schema11) {
-      if ("tsEnumNames" in schema11) {
+    UNNAMED_ENUM(schema10) {
+      if ("tsEnumNames" in schema10) {
         return false;
       }
-      if (schema11.type && schema11.type !== "boolean" && schema11.type !== "integer" && schema11.type !== "number" && schema11.type !== "string") {
+      if (schema10.type && schema10.type !== "boolean" && schema10.type !== "integer" && schema10.type !== "number" && schema10.type !== "string") {
         return false;
       }
-      return "enum" in schema11;
+      return "enum" in schema10;
     },
     UNNAMED_SCHEMA() {
       return false;
     },
-    UNTYPED_ARRAY(schema11) {
-      return schema11.type === "array" && !("items" in schema11);
+    UNTYPED_ARRAY(schema10) {
+      return schema10.type === "array" && !("items" in schema10);
     }
   };
 });
@@ -141865,10 +141865,10 @@ var require_applySchemaTyping = __commonJS((exports) => {
   exports.applySchemaTyping = undefined;
   var JSONSchema_1 = require_JSONSchema();
   var typesOfSchema_1 = require_typesOfSchema();
-  function applySchemaTyping(schema11) {
+  function applySchemaTyping(schema10) {
     var _a7;
-    const types = (0, typesOfSchema_1.typesOfSchema)(schema11);
-    Object.defineProperty(schema11, JSONSchema_1.Types, {
+    const types = (0, typesOfSchema_1.typesOfSchema)(schema10);
+    Object.defineProperty(schema10, JSONSchema_1.Types, {
       enumerable: false,
       value: types,
       writable: false
@@ -141877,23 +141877,23 @@ var require_applySchemaTyping = __commonJS((exports) => {
       return;
     }
     const intersection2 = {
-      [JSONSchema_1.Parent]: schema11,
+      [JSONSchema_1.Parent]: schema10,
       [JSONSchema_1.Types]: new Set(["ALL_OF"]),
-      $id: schema11.$id,
-      description: schema11.description,
-      name: schema11.name,
-      title: schema11.title,
-      allOf: (_a7 = schema11.allOf) !== null && _a7 !== undefined ? _a7 : [],
+      $id: schema10.$id,
+      description: schema10.description,
+      name: schema10.name,
+      title: schema10.title,
+      allOf: (_a7 = schema10.allOf) !== null && _a7 !== undefined ? _a7 : [],
       required: [],
       additionalProperties: false
     };
     types.delete("ALL_OF");
-    delete schema11.allOf;
-    delete schema11.$id;
-    delete schema11.description;
-    delete schema11.name;
-    delete schema11.title;
-    Object.defineProperty(schema11, JSONSchema_1.Intersection, {
+    delete schema10.allOf;
+    delete schema10.$id;
+    delete schema10.description;
+    delete schema10.name;
+    delete schema10.title;
+    Object.defineProperty(schema10, JSONSchema_1.Intersection, {
       enumerable: false,
       value: intersection2,
       writable: false
@@ -141911,186 +141911,186 @@ var require_normalizer = __commonJS((exports) => {
   var applySchemaTyping_1 = require_applySchemaTyping();
   var util_1 = __require("util");
   var rules = new Map;
-  function hasType(schema11, type) {
-    return schema11.type === type || Array.isArray(schema11.type) && schema11.type.includes(type);
+  function hasType(schema10, type) {
+    return schema10.type === type || Array.isArray(schema10.type) && schema10.type.includes(type);
   }
-  function isObjectType(schema11) {
-    return schema11.properties !== undefined || hasType(schema11, "object") || hasType(schema11, "any");
+  function isObjectType(schema10) {
+    return schema10.properties !== undefined || hasType(schema10, "object") || hasType(schema10, "any");
   }
-  function isArrayType(schema11) {
-    return schema11.items !== undefined || hasType(schema11, "array") || hasType(schema11, "any");
+  function isArrayType(schema10) {
+    return schema10.items !== undefined || hasType(schema10, "array") || hasType(schema10, "any");
   }
-  function isEnumTypeWithoutTsEnumNames(schema11) {
-    return schema11.type === "string" && schema11.enum !== undefined && schema11.tsEnumNames === undefined;
+  function isEnumTypeWithoutTsEnumNames(schema10) {
+    return schema10.type === "string" && schema10.enum !== undefined && schema10.tsEnumNames === undefined;
   }
-  rules.set('Remove `type=["null"]` if `enum=[null]`', (schema11) => {
-    if (Array.isArray(schema11.enum) && schema11.enum.some((e8) => e8 === null) && Array.isArray(schema11.type) && schema11.type.includes("null")) {
-      schema11.type = schema11.type.filter((type) => type !== "null");
+  rules.set('Remove `type=["null"]` if `enum=[null]`', (schema10) => {
+    if (Array.isArray(schema10.enum) && schema10.enum.some((e8) => e8 === null) && Array.isArray(schema10.type) && schema10.type.includes("null")) {
+      schema10.type = schema10.type.filter((type) => type !== "null");
     }
   });
-  rules.set("Destructure unary types", (schema11) => {
-    if (schema11.type && Array.isArray(schema11.type) && schema11.type.length === 1) {
-      schema11.type = schema11.type[0];
+  rules.set("Destructure unary types", (schema10) => {
+    if (schema10.type && Array.isArray(schema10.type) && schema10.type.length === 1) {
+      schema10.type = schema10.type[0];
     }
   });
-  rules.set("Add empty `required` property if none is defined", (schema11) => {
-    if (isObjectType(schema11) && !("required" in schema11)) {
-      schema11.required = [];
+  rules.set("Add empty `required` property if none is defined", (schema10) => {
+    if (isObjectType(schema10) && !("required" in schema10)) {
+      schema10.required = [];
     }
   });
-  rules.set("Transform `required`=false to `required`=[]", (schema11) => {
-    if (schema11.required === false) {
-      schema11.required = [];
+  rules.set("Transform `required`=false to `required`=[]", (schema10) => {
+    if (schema10.required === false) {
+      schema10.required = [];
     }
   });
-  rules.set("Default additionalProperties", (schema11, _10, options8) => {
-    if (isObjectType(schema11) && !("additionalProperties" in schema11) && schema11.patternProperties === undefined) {
-      schema11.additionalProperties = options8.additionalProperties;
+  rules.set("Default additionalProperties", (schema10, _10, options8) => {
+    if (isObjectType(schema10) && !("additionalProperties" in schema10) && schema10.patternProperties === undefined) {
+      schema10.additionalProperties = options8.additionalProperties;
     }
   });
-  rules.set("Transform id to $id", (schema11, fileName) => {
-    if (!(0, utils_1.isSchemaLike)(schema11)) {
+  rules.set("Transform id to $id", (schema10, fileName) => {
+    if (!(0, utils_1.isSchemaLike)(schema10)) {
       return;
     }
-    if (schema11.id && schema11.$id && schema11.id !== schema11.$id) {
-      throw ReferenceError(`Schema must define either id or $id, not both. Given id=${schema11.id}, $id=${schema11.$id} in ${fileName}`);
+    if (schema10.id && schema10.$id && schema10.id !== schema10.$id) {
+      throw ReferenceError(`Schema must define either id or $id, not both. Given id=${schema10.id}, $id=${schema10.$id} in ${fileName}`);
     }
-    if (schema11.id) {
-      schema11.$id = schema11.id;
-      delete schema11.id;
+    if (schema10.id) {
+      schema10.$id = schema10.id;
+      delete schema10.id;
     }
   });
-  rules.set("Add an $id to anything that needs it", (schema11, fileName, _options, _key, dereferencedPaths) => {
-    if (!(0, utils_1.isSchemaLike)(schema11)) {
+  rules.set("Add an $id to anything that needs it", (schema10, fileName, _options, _key, dereferencedPaths) => {
+    if (!(0, utils_1.isSchemaLike)(schema10)) {
       return;
     }
-    if (!schema11.$id && !schema11[JSONSchema_1.Parent]) {
-      schema11.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(fileName));
+    if (!schema10.$id && !schema10[JSONSchema_1.Parent]) {
+      schema10.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(fileName));
       return;
     }
-    if (!isArrayType(schema11) && !isObjectType(schema11)) {
+    if (!isArrayType(schema10) && !isObjectType(schema10)) {
       return;
     }
-    const dereferencedName = dereferencedPaths.get(schema11);
-    if (!schema11.$id && !schema11.title && dereferencedName) {
-      schema11.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(dereferencedName));
+    const dereferencedName = dereferencedPaths.get(schema10);
+    if (!schema10.$id && !schema10.title && dereferencedName) {
+      schema10.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(dereferencedName));
     }
     if (dereferencedName) {
-      dereferencedPaths.delete(schema11);
+      dereferencedPaths.delete(schema10);
     }
   });
-  rules.set("Escape closing JSDoc comment", (schema11) => {
-    (0, utils_1.escapeBlockComment)(schema11);
+  rules.set("Escape closing JSDoc comment", (schema10) => {
+    (0, utils_1.escapeBlockComment)(schema10);
   });
-  rules.set("Add JSDoc comments for minItems and maxItems", (schema11) => {
-    if (!isArrayType(schema11)) {
+  rules.set("Add JSDoc comments for minItems and maxItems", (schema10) => {
+    if (!isArrayType(schema10)) {
       return;
     }
     const commentsToAppend = [
-      "minItems" in schema11 ? `@minItems ${schema11.minItems}` : "",
-      "maxItems" in schema11 ? `@maxItems ${schema11.maxItems}` : ""
+      "minItems" in schema10 ? `@minItems ${schema10.minItems}` : "",
+      "maxItems" in schema10 ? `@maxItems ${schema10.maxItems}` : ""
     ].filter(Boolean);
     if (commentsToAppend.length) {
-      schema11.description = (0, utils_1.appendToDescription)(schema11.description, ...commentsToAppend);
+      schema10.description = (0, utils_1.appendToDescription)(schema10.description, ...commentsToAppend);
     }
   });
-  rules.set("Optionally remove maxItems and minItems", (schema11, _fileName, options8) => {
-    if (!isArrayType(schema11)) {
+  rules.set("Optionally remove maxItems and minItems", (schema10, _fileName, options8) => {
+    if (!isArrayType(schema10)) {
       return;
     }
-    if ("minItems" in schema11 && options8.ignoreMinAndMaxItems) {
-      delete schema11.minItems;
+    if ("minItems" in schema10 && options8.ignoreMinAndMaxItems) {
+      delete schema10.minItems;
     }
-    if ("maxItems" in schema11 && (options8.ignoreMinAndMaxItems || options8.maxItems === -1)) {
-      delete schema11.maxItems;
+    if ("maxItems" in schema10 && (options8.ignoreMinAndMaxItems || options8.maxItems === -1)) {
+      delete schema10.maxItems;
     }
   });
-  rules.set("Normalize schema.minItems", (schema11, _fileName, options8) => {
+  rules.set("Normalize schema.minItems", (schema10, _fileName, options8) => {
     if (options8.ignoreMinAndMaxItems) {
       return;
     }
-    if (!isArrayType(schema11)) {
+    if (!isArrayType(schema10)) {
       return;
     }
-    const { minItems } = schema11;
-    schema11.minItems = typeof minItems === "number" ? minItems : 0;
+    const { minItems } = schema10;
+    schema10.minItems = typeof minItems === "number" ? minItems : 0;
   });
-  rules.set("Remove maxItems if it is big enough to likely cause OOMs", (schema11, _fileName, options8) => {
+  rules.set("Remove maxItems if it is big enough to likely cause OOMs", (schema10, _fileName, options8) => {
     if (options8.ignoreMinAndMaxItems || options8.maxItems === -1) {
       return;
     }
-    if (!isArrayType(schema11)) {
+    if (!isArrayType(schema10)) {
       return;
     }
-    const { maxItems, minItems } = schema11;
+    const { maxItems, minItems } = schema10;
     if (maxItems !== undefined && maxItems - minItems > options8.maxItems) {
-      delete schema11.maxItems;
+      delete schema10.maxItems;
     }
   });
-  rules.set("Normalize schema.items", (schema11, _fileName, options8) => {
+  rules.set("Normalize schema.items", (schema10, _fileName, options8) => {
     if (options8.ignoreMinAndMaxItems) {
       return;
     }
-    const { maxItems, minItems } = schema11;
+    const { maxItems, minItems } = schema10;
     const hasMaxItems = typeof maxItems === "number" && maxItems >= 0;
     const hasMinItems = typeof minItems === "number" && minItems > 0;
-    if (schema11.items && !Array.isArray(schema11.items) && (hasMaxItems || hasMinItems)) {
-      const items = schema11.items;
+    if (schema10.items && !Array.isArray(schema10.items) && (hasMaxItems || hasMinItems)) {
+      const items = schema10.items;
       const newItems = Array(maxItems || minItems || 0).fill(items);
       if (!hasMaxItems) {
-        schema11.additionalItems = items;
+        schema10.additionalItems = items;
       }
-      schema11.items = newItems;
+      schema10.items = newItems;
     }
-    if (Array.isArray(schema11.items) && hasMaxItems && maxItems < schema11.items.length) {
-      schema11.items = schema11.items.slice(0, maxItems);
+    if (Array.isArray(schema10.items) && hasMaxItems && maxItems < schema10.items.length) {
+      schema10.items = schema10.items.slice(0, maxItems);
     }
-    return schema11;
+    return schema10;
   });
-  rules.set("Remove extends, if it is empty", (schema11) => {
-    if (!schema11.hasOwnProperty("extends")) {
+  rules.set("Remove extends, if it is empty", (schema10) => {
+    if (!schema10.hasOwnProperty("extends")) {
       return;
     }
-    if (schema11.extends == null || Array.isArray(schema11.extends) && schema11.extends.length === 0) {
-      delete schema11.extends;
+    if (schema10.extends == null || Array.isArray(schema10.extends) && schema10.extends.length === 0) {
+      delete schema10.extends;
     }
   });
-  rules.set("Make extends always an array, if it is defined", (schema11) => {
-    if (schema11.extends == null) {
+  rules.set("Make extends always an array, if it is defined", (schema10) => {
+    if (schema10.extends == null) {
       return;
     }
-    if (!Array.isArray(schema11.extends)) {
-      schema11.extends = [schema11.extends];
+    if (!Array.isArray(schema10.extends)) {
+      schema10.extends = [schema10.extends];
     }
   });
-  rules.set("Transform definitions to $defs", (schema11, fileName) => {
-    if (schema11.definitions && schema11.$defs && !(0, util_1.isDeepStrictEqual)(schema11.definitions, schema11.$defs)) {
-      throw ReferenceError(`Schema must define either definitions or $defs, not both. Given id=${schema11.id} in ${fileName}`);
+  rules.set("Transform definitions to $defs", (schema10, fileName) => {
+    if (schema10.definitions && schema10.$defs && !(0, util_1.isDeepStrictEqual)(schema10.definitions, schema10.$defs)) {
+      throw ReferenceError(`Schema must define either definitions or $defs, not both. Given id=${schema10.id} in ${fileName}`);
     }
-    if (schema11.definitions) {
-      schema11.$defs = schema11.definitions;
-      delete schema11.definitions;
+    if (schema10.definitions) {
+      schema10.$defs = schema10.definitions;
+      delete schema10.definitions;
     }
   });
-  rules.set("Transform const to singleton enum", (schema11) => {
-    if (schema11.const !== undefined) {
-      schema11.enum = [schema11.const];
-      delete schema11.const;
+  rules.set("Transform const to singleton enum", (schema10) => {
+    if (schema10.const !== undefined) {
+      schema10.enum = [schema10.const];
+      delete schema10.const;
     }
   });
-  rules.set("Add tsEnumNames to enum types", (schema11, _10, options8) => {
+  rules.set("Add tsEnumNames to enum types", (schema10, _10, options8) => {
     var _a7;
-    if (isEnumTypeWithoutTsEnumNames(schema11) && options8.inferStringEnumKeysFromValues) {
-      schema11.tsEnumNames = (_a7 = schema11.enum) === null || _a7 === undefined ? undefined : _a7.map(String);
+    if (isEnumTypeWithoutTsEnumNames(schema10) && options8.inferStringEnumKeysFromValues) {
+      schema10.tsEnumNames = (_a7 = schema10.enum) === null || _a7 === undefined ? undefined : _a7.map(String);
     }
   });
-  rules.set("Pre-calculate schema types and intersections", (schema11) => {
-    if (schema11 !== null && typeof schema11 === "object") {
-      (0, applySchemaTyping_1.applySchemaTyping)(schema11);
+  rules.set("Pre-calculate schema types and intersections", (schema10) => {
+    if (schema10 !== null && typeof schema10 === "object") {
+      (0, applySchemaTyping_1.applySchemaTyping)(schema10);
     }
   });
   function normalize2(rootSchema, dereferencedPaths, filename, options8) {
-    rules.forEach((rule) => (0, utils_1.traverse)(rootSchema, (schema11, key2) => rule(schema11, filename, options8, key2, dereferencedPaths)));
+    rules.forEach((rule) => (0, utils_1.traverse)(rootSchema, (schema10, key2) => rule(schema10, filename, options8, key2, dereferencedPaths)));
     return rootSchema;
   }
   exports.normalize = normalize2;
@@ -142172,37 +142172,37 @@ var require_parser2 = __commonJS((exports) => {
   var AST_1 = require_AST();
   var JSONSchema_1 = require_JSONSchema();
   var utils_1 = require_utils7();
-  function parse11(schema11, options8, keyName, processed = new Map, usedNames = new Set) {
-    if ((0, JSONSchema_1.isPrimitive)(schema11)) {
-      if ((0, JSONSchema_1.isBoolean)(schema11)) {
-        return parseBooleanSchema(schema11, keyName, options8);
+  function parse11(schema10, options8, keyName, processed = new Map, usedNames = new Set) {
+    if ((0, JSONSchema_1.isPrimitive)(schema10)) {
+      if ((0, JSONSchema_1.isBoolean)(schema10)) {
+        return parseBooleanSchema(schema10, keyName, options8);
       }
-      return parseLiteral(schema11, keyName);
+      return parseLiteral(schema10, keyName);
     }
-    const intersection2 = schema11[JSONSchema_1.Intersection];
-    const types = schema11[JSONSchema_1.Types];
+    const intersection2 = schema10[JSONSchema_1.Intersection];
+    const types = schema10[JSONSchema_1.Types];
     if (intersection2) {
       const ast = parseAsTypeWithCache(intersection2, "ALL_OF", options8, keyName, processed, usedNames);
       types.forEach((type) => {
-        ast.params.push(parseAsTypeWithCache(schema11, type, options8, keyName, processed, usedNames));
+        ast.params.push(parseAsTypeWithCache(schema10, type, options8, keyName, processed, usedNames));
       });
-      (0, utils_1.log)("blue", "parser", "Types:", [...types], "Input:", schema11, "Output:", ast);
+      (0, utils_1.log)("blue", "parser", "Types:", [...types], "Input:", schema10, "Output:", ast);
       return ast;
     }
     if (types.size === 1) {
       const type = [...types][0];
-      const ast = parseAsTypeWithCache(schema11, type, options8, keyName, processed, usedNames);
-      (0, utils_1.log)("blue", "parser", "Type:", type, "Input:", schema11, "Output:", ast);
+      const ast = parseAsTypeWithCache(schema10, type, options8, keyName, processed, usedNames);
+      (0, utils_1.log)("blue", "parser", "Type:", type, "Input:", schema10, "Output:", ast);
       return ast;
     }
     throw new ReferenceError("Expected intersection schema. Please file an issue on GitHub.");
   }
   exports.parse = parse11;
-  function parseAsTypeWithCache(schema11, type, options8, keyName, processed = new Map, usedNames = new Set) {
-    let cachedTypeMap = processed.get(schema11);
+  function parseAsTypeWithCache(schema10, type, options8, keyName, processed = new Map, usedNames = new Set) {
+    let cachedTypeMap = processed.get(schema10);
     if (!cachedTypeMap) {
       cachedTypeMap = new Map;
-      processed.set(schema11, cachedTypeMap);
+      processed.set(schema10, cachedTypeMap);
     }
     const cachedAST = cachedTypeMap.get(type);
     if (cachedAST) {
@@ -142210,10 +142210,10 @@ var require_parser2 = __commonJS((exports) => {
     }
     const ast = {};
     cachedTypeMap.set(type, ast);
-    return Object.assign(ast, parseNonLiteral(schema11, type, options8, keyName, processed, usedNames));
+    return Object.assign(ast, parseNonLiteral(schema10, type, options8, keyName, processed, usedNames));
   }
-  function parseBooleanSchema(schema11, keyName, options8) {
-    if (schema11) {
+  function parseBooleanSchema(schema10, keyName, options8) {
+    if (schema10) {
       return {
         keyName,
         type: options8.unknownAny ? "UNKNOWN" : "ANY"
@@ -142224,157 +142224,157 @@ var require_parser2 = __commonJS((exports) => {
       type: "NEVER"
     };
   }
-  function parseLiteral(schema11, keyName) {
+  function parseLiteral(schema10, keyName) {
     return {
       keyName,
-      params: schema11,
+      params: schema10,
       type: "LITERAL"
     };
   }
-  function parseNonLiteral(schema11, type, options8, keyName, processed, usedNames) {
-    const definitions = getDefinitionsMemoized((0, JSONSchema_1.getRootSchema)(schema11));
-    const keyNameFromDefinition = (0, lodash_1.findKey)(definitions, (_10) => _10 === schema11);
+  function parseNonLiteral(schema10, type, options8, keyName, processed, usedNames) {
+    const definitions = getDefinitionsMemoized((0, JSONSchema_1.getRootSchema)(schema10));
+    const keyNameFromDefinition = (0, lodash_1.findKey)(definitions, (_10) => _10 === schema10);
     switch (type) {
       case "ALL_OF":
         return {
-          comment: schema11.description,
-          deprecated: schema11.deprecated,
+          comment: schema10.description,
+          deprecated: schema10.deprecated,
           keyName,
-          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
-          params: schema11.allOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
+          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
+          params: schema10.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: schema11.description, deprecated: schema11.deprecated, keyName, standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8) });
+        return Object.assign(Object.assign({}, options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY), { comment: schema10.description, deprecated: schema10.deprecated, keyName, standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8) });
       case "ANY_OF":
         return {
-          comment: schema11.description,
-          deprecated: schema11.deprecated,
+          comment: schema10.description,
+          deprecated: schema10.deprecated,
           keyName,
-          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
-          params: schema11.anyOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
+          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
+          params: schema10.anyOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
           type: "UNION"
         };
       case "BOOLEAN":
         return {
-          comment: schema11.description,
-          deprecated: schema11.deprecated,
+          comment: schema10.description,
+          deprecated: schema10.deprecated,
           keyName,
-          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
           type: "BOOLEAN"
         };
       case "CUSTOM_TYPE":
         return {
-          comment: schema11.description,
-          deprecated: schema11.deprecated,
+          comment: schema10.description,
+          deprecated: schema10.deprecated,
           keyName,
-          params: schema11.tsType,
-          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
+          params: schema10.tsType,
+          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
           type: "CUSTOM_TYPE"
         };
       case "NAMED_ENUM":
         return {
-          comment: schema11.description,
-          deprecated: schema11.deprecated,
+          comment: schema10.description,
+          deprecated: schema10.deprecated,
           keyName,
-          standaloneName: standaloneName(schema11, keyNameFromDefinition !== null && keyNameFromDefinition !== undefined ? keyNameFromDefinition : keyName, usedNames, options8),
-          params: schema11.enum.map((_10, n5) => ({
+          standaloneName: standaloneName(schema10, keyNameFromDefinition !== null && keyNameFromDefinition !== undefined ? keyNameFromDefinition : keyName, usedNames, options8),
+          params: schema10.enum.map((_10, n5) => ({
             ast: parseLiteral(_10, undefined),
-            keyName: schema11.tsEnumNames[n5]
+            keyName: schema10.tsEnumNames[n5]
           })),
           type: "ENUM"
         };
       case "NAMED_SCHEMA":
-        return newInterface(schema11, options8, processed, usedNames, keyName);
+        return newInterface(schema10, options8, processed, usedNames, keyName);
       case "NEVER":
         return {
-          comment: schema11.description,
-          deprecated: schema11.deprecated,
+          comment: schema10.description,
+          deprecated: schema10.deprecated,
           keyName,
-          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
           type: "NEVER"
         };
       case "NULL":
         return {
-          comment: schema11.description,
-          deprecated: schema11.deprecated,
+          comment: schema10.description,
+          deprecated: schema10.deprecated,
           keyName,
-          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
           type: "NULL"
         };
       case "NUMBER":
         return {
-          comment: schema11.description,
-          deprecated: schema11.deprecated,
+          comment: schema10.description,
+          deprecated: schema10.deprecated,
           keyName,
-          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
           type: "NUMBER"
         };
       case "OBJECT":
         return {
-          comment: schema11.description,
+          comment: schema10.description,
           keyName,
-          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
           type: "OBJECT",
-          deprecated: schema11.deprecated
+          deprecated: schema10.deprecated
         };
       case "ONE_OF":
         return {
-          comment: schema11.description,
-          deprecated: schema11.deprecated,
+          comment: schema10.description,
+          deprecated: schema10.deprecated,
           keyName,
-          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
-          params: schema11.oneOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
+          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
+          params: schema10.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!", schema11));
+        throw Error((0, util_1.format)("Refs should have been resolved by the resolver!", schema10));
       case "STRING":
         return {
-          comment: schema11.description,
-          deprecated: schema11.deprecated,
+          comment: schema10.description,
+          deprecated: schema10.deprecated,
           keyName,
-          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
           type: "STRING"
         };
       case "TYPED_ARRAY":
-        if (Array.isArray(schema11.items)) {
-          const minItems2 = schema11.minItems;
-          const maxItems2 = schema11.maxItems;
+        if (Array.isArray(schema10.items)) {
+          const minItems2 = schema10.minItems;
+          const maxItems2 = schema10.maxItems;
           const arrayType = {
-            comment: schema11.description,
-            deprecated: schema11.deprecated,
+            comment: schema10.description,
+            deprecated: schema10.deprecated,
             keyName,
             maxItems: maxItems2,
             minItems: minItems2,
-            standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
-            params: schema11.items.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
+            standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
+            params: schema10.items.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
             type: "TUPLE"
           };
-          if (schema11.additionalItems === true) {
+          if (schema10.additionalItems === true) {
             arrayType.spreadParam = options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY;
-          } else if (schema11.additionalItems) {
-            arrayType.spreadParam = parse11(schema11.additionalItems, options8, undefined, processed, usedNames);
+          } else if (schema10.additionalItems) {
+            arrayType.spreadParam = parse11(schema10.additionalItems, options8, undefined, processed, usedNames);
           }
           return arrayType;
         } else {
           return {
-            comment: schema11.description,
-            deprecated: schema11.deprecated,
+            comment: schema10.description,
+            deprecated: schema10.deprecated,
             keyName,
-            standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
-            params: parse11(schema11.items, options8, `{keyNameFromDefinition}Items`, processed, usedNames),
+            standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
+            params: parse11(schema10.items, options8, `{keyNameFromDefinition}Items`, processed, usedNames),
             type: "ARRAY"
           };
         }
       case "UNION":
         return {
-          comment: schema11.description,
-          deprecated: schema11.deprecated,
+          comment: schema10.description,
+          deprecated: schema10.deprecated,
           keyName,
-          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
-          params: schema11.type.map((type2) => {
-            const member = Object.assign(Object.assign({}, (0, lodash_1.omit)(schema11, "$id", "description", "title")), { type: type2 });
+          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
+          params: schema10.type.map((type2) => {
+            const member = Object.assign(Object.assign({}, (0, lodash_1.omit)(schema10, "$id", "description", "title")), { type: type2 });
             (0, utils_1.maybeStripDefault)(member);
             (0, applySchemaTyping_1.applySchemaTyping)(member);
             return parse11(member, options8, undefined, processed, usedNames);
@@ -142383,80 +142383,80 @@ var require_parser2 = __commonJS((exports) => {
         };
       case "UNNAMED_ENUM":
         return {
-          comment: schema11.description,
-          deprecated: schema11.deprecated,
+          comment: schema10.description,
+          deprecated: schema10.deprecated,
           keyName,
-          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
-          params: schema11.enum.map((_10) => parseLiteral(_10, undefined)),
+          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
+          params: schema10.enum.map((_10) => parseLiteral(_10, undefined)),
           type: "UNION"
         };
       case "UNNAMED_SCHEMA":
-        return newInterface(schema11, options8, processed, usedNames, keyName, keyNameFromDefinition);
+        return newInterface(schema10, options8, processed, usedNames, keyName, keyNameFromDefinition);
       case "UNTYPED_ARRAY":
-        const minItems = schema11.minItems;
-        const maxItems = typeof schema11.maxItems === "number" ? schema11.maxItems : -1;
+        const minItems = schema10.minItems;
+        const maxItems = typeof schema10.maxItems === "number" ? schema10.maxItems : -1;
         const params = options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY;
         if (minItems > 0 || maxItems >= 0) {
           return {
-            comment: schema11.description,
-            deprecated: schema11.deprecated,
+            comment: schema10.description,
+            deprecated: schema10.deprecated,
             keyName,
-            maxItems: schema11.maxItems,
+            maxItems: schema10.maxItems,
             minItems,
             params: Array(Math.max(maxItems, minItems) || 0).fill(params),
             spreadParam: maxItems >= 0 ? undefined : params,
-            standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
+            standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
             type: "TUPLE"
           };
         }
         return {
-          comment: schema11.description,
-          deprecated: schema11.deprecated,
+          comment: schema10.description,
+          deprecated: schema10.deprecated,
           keyName,
           params,
-          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
           type: "ARRAY"
         };
     }
   }
-  function standaloneName(schema11, keyNameFromDefinition, usedNames, options8) {
+  function standaloneName(schema10, keyNameFromDefinition, usedNames, options8) {
     var _a7;
-    const name2 = ((_a7 = options8.customName) === null || _a7 === undefined ? undefined : _a7.call(options8, schema11, keyNameFromDefinition)) || schema11.title || schema11.$id || keyNameFromDefinition;
+    const name2 = ((_a7 = options8.customName) === null || _a7 === undefined ? undefined : _a7.call(options8, schema10, keyNameFromDefinition)) || schema10.title || schema10.$id || keyNameFromDefinition;
     if (name2) {
       return (0, utils_1.generateName)(name2, usedNames);
     }
   }
-  function newInterface(schema11, options8, processed, usedNames, keyName, keyNameFromDefinition) {
-    const name2 = standaloneName(schema11, keyNameFromDefinition, usedNames, options8);
+  function newInterface(schema10, options8, processed, usedNames, keyName, keyNameFromDefinition) {
+    const name2 = standaloneName(schema10, keyNameFromDefinition, usedNames, options8);
     return {
-      comment: schema11.description,
-      deprecated: schema11.deprecated,
+      comment: schema10.description,
+      deprecated: schema10.deprecated,
       keyName,
-      params: parseSchema(schema11, options8, processed, usedNames, name2),
+      params: parseSchema(schema10, options8, processed, usedNames, name2),
       standaloneName: name2,
-      superTypes: parseSuperTypes(schema11, options8, processed, usedNames),
+      superTypes: parseSuperTypes(schema10, options8, processed, usedNames),
       type: "INTERFACE"
     };
   }
-  function parseSuperTypes(schema11, options8, processed, usedNames) {
-    const superTypes = schema11.extends;
+  function parseSuperTypes(schema10, options8, processed, usedNames) {
+    const superTypes = schema10.extends;
     if (!superTypes) {
       return [];
     }
     return superTypes.map((_10) => parse11(_10, options8, undefined, processed, usedNames));
   }
-  function parseSchema(schema11, options8, processed, usedNames, parentSchemaName) {
-    let asts = (0, lodash_1.map)(schema11.properties, (value, key2) => ({
+  function parseSchema(schema10, options8, processed, usedNames, parentSchemaName) {
+    let asts = (0, lodash_1.map)(schema10.properties, (value, key2) => ({
       ast: parse11(value, options8, key2, processed, usedNames),
       isPatternProperty: false,
-      isRequired: (0, lodash_1.includes)(schema11.required || [], key2),
+      isRequired: (0, lodash_1.includes)(schema10.required || [], key2),
       isUnreachableDefinition: false,
       keyName: key2
     }));
     let singlePatternProperty = false;
-    if (schema11.patternProperties) {
-      singlePatternProperty = !schema11.additionalProperties && Object.keys(schema11.patternProperties).length === 1;
-      asts = asts.concat((0, lodash_1.map)(schema11.patternProperties, (value, key2) => {
+    if (schema10.patternProperties) {
+      singlePatternProperty = !schema10.additionalProperties && Object.keys(schema10.patternProperties).length === 1;
+      asts = asts.concat((0, lodash_1.map)(schema10.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("*/", "*\\/")}".`;
@@ -142466,14 +142466,14 @@ ${comment}` : comment;
         return {
           ast,
           isPatternProperty: !singlePatternProperty,
-          isRequired: singlePatternProperty || (0, lodash_1.includes)(schema11.required || [], key2),
+          isRequired: singlePatternProperty || (0, lodash_1.includes)(schema10.required || [], key2),
           isUnreachableDefinition: false,
           keyName: singlePatternProperty ? "[k: string]" : key2
         };
       }));
     }
     if (options8.unreachableDefinitions) {
-      asts = asts.concat((0, lodash_1.map)(schema11.$defs, (value, key2) => {
+      asts = asts.concat((0, lodash_1.map)(schema10.$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}".`;
@@ -142483,13 +142483,13 @@ ${comment}` : comment;
         return {
           ast,
           isPatternProperty: false,
-          isRequired: (0, lodash_1.includes)(schema11.required || [], key2),
+          isRequired: (0, lodash_1.includes)(schema10.required || [], key2),
           isUnreachableDefinition: true,
           keyName: key2
         };
       }));
     }
-    switch (schema11.additionalProperties) {
+    switch (schema10.additionalProperties) {
       case undefined:
       case true:
         if (singlePatternProperty) {
@@ -142506,7 +142506,7 @@ ${comment}` : comment;
         return asts;
       default:
         return asts.concat({
-          ast: parse11(schema11.additionalProperties, options8, "[k: string]", processed, usedNames),
+          ast: parse11(schema10.additionalProperties, options8, "[k: string]", processed, usedNames),
           isPatternProperty: false,
           isRequired: true,
           isUnreachableDefinition: false,
@@ -142514,22 +142514,22 @@ ${comment}` : comment;
         });
     }
   }
-  function getDefinitions(schema11, isSchema = true, processed = new Set) {
-    if (processed.has(schema11)) {
+  function getDefinitions(schema10, isSchema = true, processed = new Set) {
+    if (processed.has(schema10)) {
       return {};
     }
-    processed.add(schema11);
-    if (Array.isArray(schema11)) {
-      return schema11.reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(cur, false, processed)), {});
+    processed.add(schema10);
+    if (Array.isArray(schema10)) {
+      return schema10.reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(cur, false, processed)), {});
     }
-    if ((0, lodash_1.isPlainObject)(schema11)) {
-      return Object.assign(Object.assign({}, isSchema && hasDefinitions(schema11) ? schema11.$defs : {}), Object.keys(schema11).reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(schema11[cur], false, processed)), {}));
+    if ((0, lodash_1.isPlainObject)(schema10)) {
+      return Object.assign(Object.assign({}, isSchema && hasDefinitions(schema10) ? schema10.$defs : {}), Object.keys(schema10).reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(schema10[cur], false, processed)), {}));
     }
     return {};
   }
   var getDefinitionsMemoized = (0, lodash_1.memoize)(getDefinitions);
-  function hasDefinitions(schema11) {
-    return "$defs" in schema11;
+  function hasDefinitions(schema10) {
+    return "$defs" in schema10;
   }
 });
 
@@ -142954,7 +142954,7 @@ var require_url = __commonJS((exports) => {
   exports.fromFileSystemPath = fromFileSystemPath;
   exports.toFileSystemPath = toFileSystemPath;
   exports.safePointerToPath = safePointerToPath;
-  exports.relative = relative6;
+  exports.relative = relative4;
   var convert_path_to_posix_1 = __importDefault(require_convert_path_to_posix());
   var path_1 = __importStar(__require("path"));
   var forwardSlashPattern = /\//g;
@@ -143104,7 +143104,7 @@ var require_url = __commonJS((exports) => {
       return decodeURIComponent(value).replace(jsonPointerSlash, "/").replace(jsonPointerTilde, "~");
     });
   }
-  function relative6(from, to5) {
+  function relative4(from, to5) {
     if (!isFileSystemPath(from) || !isFileSystemPath(to5)) {
       return resolve12(from, to5);
     }
@@ -144353,7 +144353,7 @@ var require_normalize_args = __commonJS((exports) => {
   var options_js_1 = require_options();
   function normalizeArgs(_args) {
     let path18;
-    let schema11;
+    let schema10;
     let options8;
     let callback;
     const args = Array.prototype.slice.call(_args);
@@ -144363,15 +144363,15 @@ var require_normalize_args = __commonJS((exports) => {
     if (typeof args[0] === "string") {
       path18 = args[0];
       if (typeof args[2] === "object") {
-        schema11 = args[1];
+        schema10 = args[1];
         options8 = args[2];
       } else {
-        schema11 = undefined;
+        schema10 = undefined;
         options8 = args[1];
       }
     } else {
       path18 = "";
-      schema11 = args[0];
+      schema10 = args[0];
       options8 = args[1];
     }
     try {
@@ -144379,12 +144379,12 @@ var require_normalize_args = __commonJS((exports) => {
     } catch (e8) {
       console.error(`JSON Schema Ref Parser: Error normalizing options: ${e8}`);
     }
-    if (!options8.mutateInputSchema && typeof schema11 === "object") {
-      schema11 = JSON.parse(JSON.stringify(schema11));
+    if (!options8.mutateInputSchema && typeof schema10 === "object") {
+      schema10 = JSON.parse(JSON.stringify(schema10));
     }
     return {
       path: path18,
-      schema: schema11,
+      schema: schema10,
       options: options8,
       callback
     };
@@ -145173,12 +145173,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* (schema11, { cwd, $refOptions }) {
-      (0, utils_1.log)("green", "dereferencer", "Dereferencing input schema:", cwd, schema11);
+    return __awaiter(this, arguments, undefined, function* (schema10, { cwd, $refOptions }) {
+      (0, utils_1.log)("green", "dereferencer", "Dereferencing input schema:", cwd, schema10);
       const parser2 = new json_schema_ref_parser_1.$RefParser;
       const dereferencedPaths = new WeakMap;
-      const dereferencedSchema = yield parser2.dereference(cwd, schema11, Object.assign(Object.assign({}, $refOptions), { dereference: Object.assign(Object.assign({}, $refOptions.dereference), { onDereference($ref, schema12) {
-        dereferencedPaths.set(schema12, $ref);
+      const dereferencedSchema = yield parser2.dereference(cwd, schema10, Object.assign(Object.assign({}, $refOptions), { dereference: Object.assign(Object.assign({}, $refOptions.dereference), { onDereference($ref, schema11) {
+        dereferencedPaths.set(schema11, $ref);
       } }) }));
       return { dereferencedPaths, dereferencedSchema };
     });
@@ -145192,46 +145192,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", (schema11) => {
-    if (schema11.enum && schema11.tsEnumNames && schema11.enum.length !== schema11.tsEnumNames.length) {
+  rules.set("Enum members and tsEnumNames must be of the same length", (schema10) => {
+    if (schema10.enum && schema10.tsEnumNames && schema10.enum.length !== schema10.tsEnumNames.length) {
       return false;
     }
   });
-  rules.set("tsEnumNames must be an array of strings", (schema11) => {
-    if (schema11.tsEnumNames && schema11.tsEnumNames.some((_10) => typeof _10 !== "string")) {
+  rules.set("tsEnumNames must be an array of strings", (schema10) => {
+    if (schema10.tsEnumNames && schema10.tsEnumNames.some((_10) => typeof _10 !== "string")) {
       return false;
     }
   });
-  rules.set("When both maxItems and minItems are present, maxItems >= minItems", (schema11) => {
-    const { maxItems, minItems } = schema11;
+  rules.set("When both maxItems and minItems are present, maxItems >= minItems", (schema10) => {
+    const { maxItems, minItems } = schema10;
     if (typeof maxItems === "number" && typeof minItems === "number") {
       return maxItems >= minItems;
     }
   });
-  rules.set("When maxItems exists, maxItems >= 0", (schema11) => {
-    const { maxItems } = schema11;
+  rules.set("When maxItems exists, maxItems >= 0", (schema10) => {
+    const { maxItems } = schema10;
     if (typeof maxItems === "number") {
       return maxItems >= 0;
     }
   });
-  rules.set("When minItems exists, minItems >= 0", (schema11) => {
-    const { minItems } = schema11;
+  rules.set("When minItems exists, minItems >= 0", (schema10) => {
+    const { minItems } = schema10;
     if (typeof minItems === "number") {
       return minItems >= 0;
     }
   });
-  rules.set("deprecated must be a boolean", (schema11) => {
-    const typeOfDeprecated = typeof schema11.deprecated;
+  rules.set("deprecated must be a boolean", (schema10) => {
+    const typeOfDeprecated = typeof schema10.deprecated;
     return typeOfDeprecated === "boolean" || typeOfDeprecated === "undefined";
   });
-  function validate2(schema11, filename) {
+  function validate2(schema10, filename) {
     const errors5 = [];
     rules.forEach((rule, ruleName) => {
-      (0, utils_1.traverse)(schema11, (schema12, key2) => {
-        if (rule(schema12) === false) {
+      (0, utils_1.traverse)(schema10, (schema11, key2) => {
+        if (rule(schema11) === false) {
           errors5.push(`Error at key "${key2}" in file "${filename}": ${ruleName}`);
         }
-        return schema12;
+        return schema11;
       });
     });
     return errors5;
@@ -145245,25 +145245,25 @@ var require_linker = __commonJS((exports) => {
   exports.link = undefined;
   var JSONSchema_1 = require_JSONSchema();
   var lodash_1 = require_lodash8();
-  function link2(schema11, parent = null) {
-    if (!Array.isArray(schema11) && !(0, lodash_1.isPlainObject)(schema11)) {
-      return schema11;
+  function link2(schema10, parent = null) {
+    if (!Array.isArray(schema10) && !(0, lodash_1.isPlainObject)(schema10)) {
+      return schema10;
     }
-    if (schema11.hasOwnProperty(JSONSchema_1.Parent)) {
-      return schema11;
+    if (schema10.hasOwnProperty(JSONSchema_1.Parent)) {
+      return schema10;
     }
-    Object.defineProperty(schema11, JSONSchema_1.Parent, {
+    Object.defineProperty(schema10, JSONSchema_1.Parent, {
       enumerable: false,
       value: parent,
       writable: false
     });
-    if (Array.isArray(schema11)) {
-      schema11.forEach((child) => link2(child, schema11));
+    if (Array.isArray(schema10)) {
+      schema10.forEach((child) => link2(child, schema10));
     }
-    for (const key2 in schema11) {
-      link2(schema11[key2], schema11);
+    for (const key2 in schema10) {
+      link2(schema10[key2], schema10);
     }
-    return schema11;
+    return schema10;
   }
   exports.link = link2;
 });
@@ -145355,8 +145355,8 @@ var require_src3 = __commonJS((exports) => {
     unknownAny: true
   };
   function compileFromFile(filename, options8 = exports.DEFAULT_OPTIONS) {
-    const schema11 = parseAsJSONSchema(filename);
-    return compile(schema11, (0, utils_1.stripExtension)(filename), Object.assign({ cwd: (0, path_1.dirname)(filename) }, options8));
+    const schema10 = parseAsJSONSchema(filename);
+    return compile(schema10, (0, utils_1.stripExtension)(filename), Object.assign({ cwd: (0, path_1.dirname)(filename) }, options8));
   }
   exports.compileFromFile = compileFromFile;
   function parseAsJSONSchema(filename) {
@@ -145366,7 +145366,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* (schema11, name2, options8 = {}) {
+    return __awaiter(this, arguments, undefined, function* (schema10, name2, options8 = {}) {
       (0, optionValidator_1.validateOptions)(options8);
       const _options = (0, lodash_1.merge)({}, exports.DEFAULT_OPTIONS, options8);
       const start = Date.now();
@@ -145376,7 +145376,7 @@ var require_src3 = __commonJS((exports) => {
       if (!(0, lodash_1.endsWith)(_options.cwd, "/")) {
         _options.cwd += "/";
       }
-      const _schema = (0, lodash_1.cloneDeep)(schema11);
+      const _schema = (0, lodash_1.cloneDeep)(schema10);
       const { dereferencedPaths, dereferencedSchema } = yield (0, resolver_1.dereference)(_schema, _options);
       if (process.env.VERBOSE) {
         if ((0, util_1.isDeepStrictEqual)(_schema, dereferencedSchema)) {
@@ -146286,7 +146286,7 @@ var require_depd = __commonJS((exports, module) => {
    * Copyright(c) 2014-2018 Douglas Christopher Wilson
    * MIT Licensed
    */
-  var relative6 = __require("path").relative;
+  var relative4 = __require("path").relative;
   module.exports = depd;
   var basePath = process.cwd();
   function containsNamespace(str, namespace) {
@@ -146482,7 +146482,7 @@ var require_depd = __commonJS((exports, module) => {
     return formatted;
   }
   function formatLocation(callSite) {
-    return relative6(basePath, callSite[0]) + ":" + callSite[1] + ":" + callSite[2];
+    return relative4(basePath, callSite[0]) + ":" + callSite[1] + ":" + callSite[2];
   }
   function getStack() {
     var limit = Error.stackTraceLimit;
@@ -163944,10 +163944,10 @@ var require_view = __commonJS((exports, module) => {
   var debug = require_src4()("express:view");
   var path18 = __require("node:path");
   var fs28 = __require("node:fs");
-  var dirname22 = path18.dirname;
-  var basename7 = path18.basename;
+  var dirname19 = path18.dirname;
+  var basename6 = path18.basename;
   var extname2 = path18.extname;
-  var join26 = path18.join;
+  var join25 = path18.join;
   var resolve12 = path18.resolve;
   module.exports = View;
   function View(name2, options8) {
@@ -163983,8 +163983,8 @@ var require_view = __commonJS((exports, module) => {
     for (var i5 = 0;i5 < roots.length && !path19; i5++) {
       var root2 = roots[i5];
       var loc = resolve12(root2, name2);
-      var dir = dirname22(loc);
-      var file2 = basename7(loc);
+      var dir = dirname19(loc);
+      var file2 = basename6(loc);
       path19 = this.resolve(dir, file2);
     }
     return path19;
@@ -164009,12 +164009,12 @@ var require_view = __commonJS((exports, module) => {
   };
   View.prototype.resolve = function resolve13(dir, file2) {
     var ext = this.ext;
-    var path19 = join26(dir, file2);
+    var path19 = join25(dir, file2);
     var stat2 = tryStat(path19);
     if (stat2 && stat2.isFile()) {
       return path19;
     }
-    path19 = join26(dir, basename7(file2, ext), "index" + ext);
+    path19 = join25(dir, basename6(file2, ext), "index" + ext);
     stat2 = tryStat(path19);
     if (stat2 && stat2.isFile()) {
       return path19;
@@ -167335,7 +167335,7 @@ var require_content_disposition = __commonJS((exports, module) => {
    */
   module.exports = contentDisposition;
   module.exports.parse = parse11;
-  var basename7 = __require("path").basename;
+  var basename6 = __require("path").basename;
   var ENCODE_URL_ATTR_CHAR_REGEXP = /[\x00-\x20"'()*,/:;<=>?@[\\\]{}\x7f]/g;
   var HEX_ESCAPE_REGEXP = /%[0-9A-Fa-f]{2}/;
   var HEX_ESCAPE_REPLACE_REGEXP = /%([0-9A-Fa-f]{2})/g;
@@ -167370,9 +167370,9 @@ var require_content_disposition = __commonJS((exports, module) => {
     if (typeof fallback === "string" && NON_LATIN1_REGEXP.test(fallback)) {
       throw new TypeError("fallback must be ISO-8859-1 string");
     }
-    var name2 = basename7(filename);
+    var name2 = basename6(filename);
     var isQuotedString = TEXT_REGEXP.test(name2);
-    var fallbackName = typeof fallback !== "string" ? fallback && getlatin1(name2) : basename7(fallback);
+    var fallbackName = typeof fallback !== "string" ? fallback && getlatin1(name2) : basename6(fallback);
     var hasFallback = typeof fallbackName === "string" && fallbackName !== name2;
     if (hasFallback || !isQuotedString || HEX_ESCAPE_REGEXP.test(name2)) {
       params["filename*"] = name2;
@@ -167709,7 +167709,7 @@ var require_send = __commonJS((exports, module) => {
   var Stream2 = __require("stream");
   var util2 = __require("util");
   var extname2 = path18.extname;
-  var join26 = path18.join;
+  var join25 = path18.join;
   var normalize2 = path18.normalize;
   var resolve12 = path18.resolve;
   var sep = path18.sep;
@@ -167881,7 +167881,7 @@ var require_send = __commonJS((exports, module) => {
         return res;
       }
       parts = path19.split(sep);
-      path19 = normalize2(join26(root2, path19));
+      path19 = normalize2(join25(root2, path19));
     } else {
       if (UP_PATH_REGEXP.test(path19)) {
         debug('malicious path "%s"', path19);
@@ -168021,7 +168021,7 @@ var require_send = __commonJS((exports, module) => {
           return self2.onStatError(err);
         return self2.error(404);
       }
-      var p4 = join26(path19, self2._index[i5]);
+      var p4 = join25(path19, self2._index[i5]);
       debug('stat "%s"', p4);
       fs28.stat(p4, function(err2, stat2) {
         if (err2)
@@ -169119,18 +169119,18 @@ var require_common7 = __commonJS((exports) => {
     retSegs.push.apply(retSegs, lastSegs);
     return retSegs.join("?");
   };
-  common2.rewriteCookieProperty = function rewriteCookieProperty(header2, config13, property) {
+  common2.rewriteCookieProperty = function rewriteCookieProperty(header2, config12, property) {
     if (Array.isArray(header2)) {
       return header2.map(function(headerElement) {
-        return rewriteCookieProperty(headerElement, config13, property);
+        return rewriteCookieProperty(headerElement, config12, property);
       });
     }
     return header2.replace(new RegExp("(;\\s*" + property + "=)([^;]+)", "i"), function(match, prefix, previousValue) {
       var newValue;
-      if (previousValue in config13) {
-        newValue = config13[previousValue];
-      } else if ("*" in config13) {
-        newValue = config13["*"];
+      if (previousValue in config12) {
+        newValue = config12[previousValue];
+      } else if ("*" in config12) {
+        newValue = config12["*"];
       } else {
         return match;
       }
@@ -169630,8 +169630,8 @@ var require_follow_redirects = __commonJS((exports, module) => {
     }
     return parsed;
   }
-  function resolveUrl(relative6, base) {
-    return useNativeURL ? new URL2(relative6, base) : parseUrl(url3.resolve(base, relative6));
+  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)) {
@@ -170495,9 +170495,9 @@ var require_router2 = __commonJS((exports) => {
   var is_plain_object_1 = require_is_plain_object();
   var debug_1 = require_debug4();
   var debug = debug_1.Debug.extend("router");
-  async function getTarget(req, config13) {
+  async function getTarget(req, config12) {
     let newTarget;
-    const router = config13.router;
+    const router = config12.router;
     if ((0, is_plain_object_1.isPlainObject)(router)) {
       newTarget = getTargetFromProxyTable(req, router);
     } else if (typeof router === "function") {
@@ -171269,8 +171269,8 @@ var require_tmp = __commonJS((exports, module) => {
       const name2 = options8.name;
       if (path18.isAbsolute(name2))
         throw new Error(`name option must not contain an absolute path, found "${name2}".`);
-      const basename7 = path18.basename(name2);
-      if (basename7 === ".." || basename7 === "." || basename7 !== name2)
+      const basename6 = path18.basename(name2);
+      if (basename6 === ".." || basename6 === "." || basename6 !== name2)
         throw new Error(`name option must not contain a path, found "${name2}".`);
     }
     if (!_isUndefined(options8.template) && !options8.template.match(TEMPLATE_PATTERN)) {
@@ -210550,7 +210550,7 @@ var require_utils12 = __commonJS((exports, module) => {
     if (decode4)
       return decode4(data, hint);
   }
-  function basename7(path18) {
+  function basename6(path18) {
     if (typeof path18 !== "string")
       return "";
     for (let i5 = path18.length - 1;i5 >= 0; --i5) {
@@ -211854,7 +211854,7 @@ var require_utils12 = __commonJS((exports, module) => {
     -1
   ];
   module.exports = {
-    basename: basename7,
+    basename: basename6,
     convertToUTF8,
     getDecoder,
     parseContentType,
@@ -212262,7 +212262,7 @@ var require_multipart = __commonJS((exports, module) => {
   var { Readable: Readable6, Writable: Writable4 } = __require("stream");
   var StreamSearch = require_sbmh();
   var {
-    basename: basename7,
+    basename: basename6,
     convertToUTF8,
     getDecoder,
     parseContentType,
@@ -212524,7 +212524,7 @@ var require_multipart = __commonJS((exports, module) => {
           else if (disp.params.filename)
             filename = disp.params.filename;
           if (filename !== undefined && !preservePath)
-            filename = basename7(filename);
+            filename = basename6(filename);
         }
         if (header2["content-type"]) {
           const conType = parseContentType(header2["content-type"][0]);
@@ -214616,7 +214616,7 @@ var require_buffer_list = __commonJS((exports, module) => {
       }
     }, {
       key: "join",
-      value: function join26(s5) {
+      value: function join25(s5) {
         if (this.length === 0)
           return "";
         var p4 = this.head;
@@ -234018,7 +234018,7 @@ function normalizeBase44Env() {
 loadProjectEnvFiles();
 
 // src/cli/index.ts
-import { dirname as dirname26, join as join29 } from "node:path";
+import { dirname as dirname23, join as join28 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 
 // ../../node_modules/@clack/core/dist/index.mjs
@@ -235226,7 +235226,7 @@ var {
 } = import__.default;
 
 // src/cli/commands/agents/pull.ts
-import { dirname as dirname12, join as join14 } from "node:path";
+import { dirname as dirname10, join as join14 } 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`;
@@ -236038,7 +236038,6 @@ var ProjectConfigSchema = exports_external.object({
   site: SiteConfigSchema.optional(),
   entitiesDir: exports_external.string().optional().default("entities"),
   functionsDir: exports_external.string().optional().default("functions"),
-  realtimeDir: exports_external.string().optional().default("realtime"),
   agentsDir: exports_external.string().optional().default("agents"),
   connectorsDir: exports_external.string().optional().default("connectors"),
   authDir: exports_external.string().optional().default("auth"),
@@ -241895,7 +241894,7 @@ async function getSiteUrl() {
   return result.data.url;
 }
 // src/core/project/config.ts
-import { dirname as dirname10, join as join10 } from "node:path";
+import { dirname as dirname8, join as join10 } from "node:path";
 
 // src/core/project/plugins.ts
 import { createRequire as createRequire2 } from "node:module";
@@ -241947,11 +241946,18 @@ var ToolConfigSchema = exports_external.union([
   EntityToolConfigSchema,
   BackendFunctionToolConfigSchema
 ]);
+var MemoryConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  scope: exports_external.enum(["global", "user", "both"]).default("both"),
+  include_other_conversation_context: exports_external.boolean().default(false),
+  instructions: exports_external.string().nullable().optional()
+});
 var AgentConfigSchema = exports_external.looseObject({
   name: exports_external.string().trim().min(1).max(100),
   description: exports_external.string().trim().min(1, "Description is required"),
   instructions: exports_external.string().trim().min(1, "Instructions are required"),
   tool_configs: exports_external.array(ToolConfigSchema).optional().default([]),
+  memory_config: MemoryConfigSchema.optional(),
   whatsapp_greeting: exports_external.string().nullable().optional()
 });
 var SyncAgentsResponseSchema = exports_external.object({
@@ -243752,131 +243758,6 @@ var functionResource = {
   readAll: readAllFunctions,
   push: (functions) => deployFunctionsSequentially(functions)
 };
-// src/core/resources/realtime-handler/schema.ts
-var RealtimeHandlerConfigSchema = exports_external.object({
-  name: exports_external.string().min(1),
-  entry: exports_external.string().min(1)
-});
-var DeployRealtimeHandlerResponseSchema = exports_external.object({
-  status: exports_external.enum(["deployed", "unchanged"]),
-  handler_name: exports_external.string().optional()
-});
-var RealtimeHandlerSchema = RealtimeHandlerConfigSchema.extend({
-  entryPath: exports_external.string().min(1),
-  filePaths: exports_external.array(exports_external.string()).min(1),
-  source: ResourceSourceSchema
-});
-
-// src/core/resources/realtime-handler/api.ts
-async function deploySingleRealtimeHandler(name2, payload) {
-  const appClient = getAppClient();
-  let response;
-  try {
-    response = await appClient.put(`backend-functions/${encodeURIComponent(name2)}`, { json: payload, timeout: false });
-  } catch (error48) {
-    throw await ApiError.fromHttpError(error48, `deploying realtime handler "${name2}"`);
-  }
-  const result = DeployRealtimeHandlerResponseSchema.safeParse(await response.json());
-  if (!result.success) {
-    throw new SchemaValidationError("Invalid response from server", result.error);
-  }
-  return result.data;
-}
-// src/core/resources/realtime-handler/config.ts
-import { basename as basename4, dirname as dirname8, relative as relative3 } from "node:path";
-async function readRealtimeHandler(entryFile, realtimeDir) {
-  const handlerDir = dirname8(entryFile);
-  const filePaths = await globby("**/*.ts", {
-    cwd: handlerDir,
-    absolute: true
-  });
-  const name2 = relative3(realtimeDir, handlerDir).split(/[/\\]/).join("/");
-  if (!name2) {
-    throw new InvalidInputError("entry.ts found directly in the realtime directory — it must be inside a named subfolder", {
-      hints: [
-        {
-          message: `Move ${entryFile} into a subfolder (e.g. realtime/myHandler/entry.ts)`
-        }
-      ]
-    });
-  }
-  const entry = basename4(entryFile);
-  return {
-    name: name2,
-    entry,
-    entryPath: entryFile,
-    filePaths,
-    source: { type: "project" }
-  };
-}
-async function readAllRealtimeHandlers(realtimeDir) {
-  if (!await pathExists(realtimeDir)) {
-    return [];
-  }
-  const entryFiles = await globby(ENTRY_FILE_GLOB, {
-    cwd: realtimeDir,
-    absolute: true,
-    ignore: ENTRY_IGNORE_DOT_PATHS
-  });
-  const handlers = await Promise.all(entryFiles.map((entryFile) => readRealtimeHandler(entryFile, realtimeDir)));
-  const names = new Set;
-  for (const handler of handlers) {
-    if (names.has(handler.name)) {
-      throw new InvalidInputError(`Duplicate realtime handler name "${handler.name}" in ${realtimeDir}`);
-    }
-    names.add(handler.name);
-  }
-  return handlers;
-}
-// src/core/resources/realtime-handler/deploy.ts
-import { dirname as dirname9, relative as relative4 } from "node:path";
-async function loadHandlerCode(handler) {
-  const handlerDir = dirname9(handler.entryPath);
-  const resolvedFiles = await Promise.all(handler.filePaths.map(async (filePath) => {
-    const content = await readTextFile(filePath);
-    const path11 = relative4(handlerDir, filePath).split(/[/\\]/).join("/");
-    return { path: path11, content };
-  }));
-  return { name: handler.name, entry: handler.entry, files: resolvedFiles };
-}
-async function deployOne2(handler) {
-  const start = Date.now();
-  try {
-    const loaded = await loadHandlerCode(handler);
-    const response = await deploySingleRealtimeHandler(loaded.name, {
-      entry: loaded.entry,
-      files: loaded.files
-    });
-    return {
-      name: loaded.name,
-      status: response.status,
-      durationMs: Date.now() - start
-    };
-  } catch (error48) {
-    return {
-      name: handler.name,
-      status: "error",
-      error: error48 instanceof Error ? error48.message : String(error48)
-    };
-  }
-}
-async function deployRealtimeHandlersSequentially(handlers, options) {
-  if (handlers.length === 0)
-    return [];
-  const results = [];
-  for (const handler of handlers) {
-    options?.onStart?.([handler.name]);
-    const result = await deployOne2(handler);
-    results.push(result);
-    options?.onResult?.(result);
-  }
-  return results;
-}
-// src/core/resources/realtime-handler/resource.ts
-var realtimeHandlerResource = {
-  readAll: readAllRealtimeHandlers,
-  push: (handlers) => deployRealtimeHandlersSequentially(handlers)
-};
 // src/core/project/config.ts
 class ProjectConfigReader {
   pluginSourceByNamespace = new Map;
@@ -243896,7 +243777,6 @@ class ProjectConfigReader {
       project: { ...project, root, configPath },
       entities,
       functions,
-      realtimeHandlers: localResources.realtimeHandlers,
       agents: localResources.agents,
       connectors: localResources.connectors,
       authConfig: localResources.authConfig
@@ -243924,30 +243804,15 @@ class ProjectConfigReader {
     return result.data;
   }
   async readProjectResources(configPath, project) {
-    const configDir = dirname10(configPath);
-    const [
-      entities,
-      functions,
-      realtimeHandlers,
-      agents,
-      connectors,
-      authConfig
-    ] = await Promise.all([
+    const configDir = dirname8(configPath);
+    const [entities, functions, agents, connectors, authConfig] = await Promise.all([
       entityResource.readAll(join10(configDir, project.entitiesDir)),
       functionResource.readAll(join10(configDir, project.functionsDir)),
-      realtimeHandlerResource.readAll(join10(configDir, project.realtimeDir)),
       agentResource.readAll(join10(configDir, project.agentsDir)),
       connectorResource.readAll(join10(configDir, project.connectorsDir)),
       authConfigResource.readAll(join10(configDir, project.authDir))
     ]);
-    return {
-      entities,
-      functions,
-      realtimeHandlers,
-      agents,
-      connectors,
-      authConfig
-    };
+    return { entities, functions, agents, connectors, authConfig };
   }
   assertPluginProjectDoesNotLoadPlugins(project, configPath) {
     if (project.plugin && project.plugins.length > 0) {
@@ -243968,7 +243833,7 @@ class ProjectConfigReader {
     this.pluginSourceByNamespace.set(namespace, source);
   }
   async readPluginConfig(plugin, hostConfigPath) {
-    const pluginRoot = resolvePluginRoot(plugin.source, dirname10(hostConfigPath));
+    const pluginRoot = resolvePluginRoot(plugin.source, dirname8(hostConfigPath));
     const { configPath } = await this.findConfigOrThrow(pluginRoot);
     const project = await this.readConfigFile(configPath);
     const namespace = requirePluginNamespace(project, plugin.source, configPath);
@@ -243980,7 +243845,6 @@ class ProjectConfigReader {
     return {
       entities: markPluginEntities(resources.entities, namespace),
       functions: namespacePluginFunctions(resources.functions, namespace),
-      realtimeHandlers: [],
       agents: [],
       connectors: [],
       authConfig: []
@@ -244018,7 +243882,6 @@ class ProjectConfigReader {
     return {
       entities,
       functions,
-      realtimeHandlers: [],
       agents: [],
       connectors: [],
       authConfig: []
@@ -244048,7 +243911,7 @@ async function readProjectConfig(projectRoot) {
 // src/core/project/template.ts
 var import_ejs = __toESM(require_ejs(), 1);
 var import_front_matter = __toESM(require_front_matter(), 1);
-import { dirname as dirname11, join as join12 } from "node:path";
+import { dirname as dirname9, join as join12 } from "node:path";
 
 // src/core/assets.ts
 import { cpSync, existsSync } from "node:fs";
@@ -244200,7 +244063,7 @@ async function renderTemplate(template, destPath, data, options = {}) {
       if (file2.endsWith(".ejs")) {
         const rendered = await import_ejs.default.renderFile(srcPath, data);
         const { attributes, body } = import_front_matter.default(rendered);
-        const destFile = attributes.outputFileName ? join12(dirname11(file2), attributes.outputFileName) : file2.replace(/\.ejs$/, "");
+        const destFile = attributes.outputFileName ? join12(dirname9(file2), attributes.outputFileName) : file2.replace(/\.ejs$/, "");
         const destFilePath = join12(destPath, destFile);
         if (skipExisting && await pathExists(destFilePath)) {
           skipped.push(destFile);
@@ -244336,40 +244199,22 @@ async function createArchive(pathToArchive, targetArchivePath) {
 }
 // src/core/project/deploy.ts
 function hasResourcesToDeploy(projectData) {
-  const {
-    project,
-    entities,
-    functions,
-    realtimeHandlers,
-    agents,
-    connectors,
-    authConfig
-  } = projectData;
+  const { project, entities, functions, agents, connectors, authConfig } = projectData;
   const hasSite = Boolean(project.site?.outputDirectory);
   const hasEntities = entities.length > 0;
   const hasFunctions = functions.length > 0;
-  const hasRealtimeHandlers = realtimeHandlers.length > 0;
   const hasAgents = agents.length > 0;
   const hasConnectors = connectors.length > 0;
   const hasAuthConfig = authConfig.length > 0;
-  return hasEntities || hasFunctions || hasRealtimeHandlers || hasAgents || hasConnectors || hasAuthConfig || hasSite;
+  return hasEntities || hasFunctions || hasAgents || hasConnectors || hasAuthConfig || hasSite;
 }
 async function deployAll(projectData, options) {
-  const {
-    project,
-    entities,
-    functions,
-    realtimeHandlers,
-    agents,
-    connectors,
-    authConfig
-  } = projectData;
+  const { project, entities, functions, agents, connectors, authConfig } = projectData;
   await entityResource.push(entities);
   await deployFunctionsSequentially(functions, {
     onStart: options?.onFunctionStart,
     onResult: options?.onFunctionResult
   });
-  await deployRealtimeHandlersSequentially(realtimeHandlers);
   await agentResource.push(agents);
   await authConfigResource.push(authConfig);
   const { results: connectorResults } = await pushConnectors(connectors);
@@ -251566,7 +251411,7 @@ async function pullAgentsAction({
   runTask: runTask2
 }) {
   const { project: project2 } = await readProjectConfig();
-  const configDir = dirname12(project2.configPath);
+  const configDir = dirname10(project2.configPath);
   const agentsDir = join14(configDir, project2.agentsDir);
   const remoteAgents = await runTask2("Fetching agents from Base44", async () => {
     return await fetchAgents();
@@ -251631,11 +251476,11 @@ function getAgentsCommand() {
 }
 
 // src/cli/commands/auth/password-login.ts
-import { dirname as dirname13, join as join15 } from "node:path";
+import { dirname as dirname11, join as join15 } 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 configDir = dirname11(project2.configPath);
   const authDir = join15(configDir, project2.authDir);
   const updated = await runTask2("Updating local auth config", async () => {
     const current = await readAuthConfig(authDir) ?? DEFAULT_AUTH_CONFIG;
@@ -251656,13 +251501,13 @@ function getPasswordLoginCommand() {
 }
 
 // src/cli/commands/auth/pull.ts
-import { dirname as dirname14, join as join16 } from "node:path";
+import { dirname as dirname12, join as join16 } from "node:path";
 async function pullAuthAction({
   log,
   runTask: runTask2
 }) {
   const { project: project2 } = await readProjectConfig();
-  const configDir = dirname14(project2.configPath);
+  const configDir = dirname12(project2.configPath);
   const authDir = join16(configDir, project2.authDir);
   const remoteConfig = await runTask2("Fetching auth config from Base44", async () => {
     return await pullAuthConfig();
@@ -251727,7 +251572,7 @@ function getAuthPushCommand() {
 }
 
 // src/cli/commands/auth/social-login.ts
-import { dirname as dirname15, join as join17, resolve as resolve3 } from "node:path";
+import { dirname as dirname13, join as join17, resolve as resolve3 } from "node:path";
 var PROVIDER_LABELS = {
   google: "Google",
   microsoft: "Microsoft",
@@ -251797,7 +251642,7 @@ async function socialLoginAction({ log, isNonInteractive, runTask: runTask2 }, p
     }
   }
   const { project: project2 } = await readProjectConfig();
-  const configDir = dirname15(project2.configPath);
+  const configDir = dirname13(project2.configPath);
   const authDir = join17(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) {
@@ -251823,7 +251668,7 @@ function getSocialLoginCommand() {
 }
 
 // src/cli/commands/auth/sso.ts
-import { dirname as dirname16, join as join18, resolve as resolve4 } from "node:path";
+import { dirname as dirname14, join as join18, resolve as resolve4 } from "node:path";
 var SSOConfigFileSchema = exports_external.object({
   provider: exports_external.enum(Object.values(KNOWN_SSO_PROVIDERS)),
   clientId: exports_external.string(),
@@ -251986,7 +251831,7 @@ async function ssoEnableAction({ isNonInteractive, runTask: runTask2 }, options)
     throw error48;
   }
   const { project: project2 } = await readProjectConfig();
-  const configDir = dirname16(project2.configPath);
+  const configDir = dirname14(project2.configPath);
   const authDir = join18(configDir, project2.authDir);
   await runTask2("Updating local auth config", async () => updateSSOConfig(authDir, provider, true));
   await runTask2("Saving SSO credentials", async () => pushSSOSecrets(secrets));
@@ -252002,7 +251847,7 @@ 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 configDir = dirname14(project2.configPath);
   const authDir = join18(configDir, project2.authDir);
   const updated = await runTask2("Updating local auth config", async () => updateSSOConfig(authDir, null, false));
   await runTask2("Removing SSO credentials", async () => deleteSSOSecrets());
@@ -252854,13 +252699,13 @@ function getConnectorsListAvailableCommand() {
 }
 
 // src/cli/commands/connectors/pull.ts
-import { dirname as dirname17, join as join19, resolve as resolve5 } from "node:path";
+import { dirname as dirname15, join as join19, resolve as resolve5 } from "node:path";
 async function resolveConnectorsDir(options) {
   if (!getAppContext().projectRoot) {
     return resolve5(options.dir ?? "connectors");
   }
   const { project: project2 } = await readProjectConfig();
-  return join19(dirname17(project2.configPath), project2.connectorsDir);
+  return join19(dirname15(project2.configPath), project2.connectorsDir);
 }
 async function pullConnectorsAction({ log, runTask: runTask2, jsonMode }, options) {
   const connectorsDir = await resolveConnectorsDir(options);
@@ -253253,10 +253098,10 @@ function getListCommand() {
 }
 
 // src/cli/commands/functions/pull.ts
-import { dirname as dirname18, join as join20 } from "node:path";
+import { dirname as dirname16, join as join20 } from "node:path";
 async function pullFunctionsAction({ log, runTask: runTask2 }, name2) {
   const { project: project2, functions } = await readProjectConfig();
-  const configDir = dirname18(project2.configPath);
+  const configDir = dirname16(project2.configPath);
   const functionsDir = join20(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 () => {
@@ -253316,7 +253161,7 @@ function getFunctionsCommand() {
 }
 
 // src/cli/commands/project/create.ts
-import { basename as basename5, resolve as resolve7 } from "node:path";
+import { basename as basename4, resolve as resolve7 } from "node:path";
 var import_kebabCase = __toESM(require_kebabCase(), 1);
 
 // src/cli/commands/project/scaffold-shared.ts
@@ -253337,7 +253182,7 @@ async function completeProjectSetup({
   projectId,
   name: name2,
   resolvedPath,
-  deploy: deploy6,
+  deploy: deploy5,
   skills,
   isInteractive
 }, { runTask: runTask2 }) {
@@ -253351,7 +253196,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 () => {
@@ -253371,7 +253216,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) => {
@@ -253440,8 +253285,8 @@ async function createInteractive(options, ctx) {
     name: () => {
       return options.name ? Promise.resolve(options.name) : Ze({
         message: "What is the name of your project?",
-        placeholder: basename5(process.cwd()),
-        initialValue: basename5(process.cwd()),
+        placeholder: basename4(process.cwd()),
+        initialValue: basename4(process.cwd()),
         validate: (value) => {
           if (!value || value.trim().length === 0) {
             return "Every project deserves a name";
@@ -253486,7 +253331,7 @@ async function executeCreate({
   name: rawName,
   description,
   projectPath,
-  deploy: deploy6,
+  deploy: deploy5,
   skills,
   isInteractive
 }, ctx) {
@@ -253505,7 +253350,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" };
 }
@@ -253550,15 +253395,7 @@ async function deployAction({ isNonInteractive, log }, options = {}) {
       outroMessage: "No resources found to deploy"
     };
   }
-  const {
-    project: project2,
-    entities,
-    functions,
-    realtimeHandlers,
-    agents,
-    connectors,
-    authConfig
-  } = projectData;
+  const { project: project2, entities, functions, agents, connectors, authConfig } = projectData;
   const summaryLines = [];
   if (entities.length > 0) {
     summaryLines.push(`  - ${entities.length} ${entities.length === 1 ? "entity" : "entities"}`);
@@ -253566,9 +253403,6 @@ async function deployAction({ isNonInteractive, log }, options = {}) {
   if (functions.length > 0) {
     summaryLines.push(`  - ${functions.length} ${functions.length === 1 ? "function" : "functions"}`);
   }
-  if (realtimeHandlers.length > 0) {
-    summaryLines.push(`  - ${realtimeHandlers.length} ${realtimeHandlers.length === 1 ? "realtime handler" : "realtime handlers"}`);
-  }
   if (agents.length > 0) {
     summaryLines.push(`  - ${agents.length} ${agents.length === 1 ? "agent" : "agents"}`);
   }
@@ -254012,7 +253846,7 @@ function getLogsCommand() {
 }
 
 // src/cli/commands/project/scaffold.ts
-import { basename as basename6, resolve as resolve8 } from "node:path";
+import { basename as basename5, resolve as resolve8 } from "node:path";
 function resolveAppId(options) {
   const appId = options.appId;
   if (!appId) {
@@ -254029,7 +253863,7 @@ async function scaffoldAction(ctx, name2, options, command2) {
   const { log, runTask: runTask2 } = ctx;
   const appId = resolveAppId(command2.optsWithGlobals());
   const resolvedPath = resolve8("./");
-  const projectName = (name2 ?? basename6(resolvedPath)).trim();
+  const projectName = (name2 ?? basename5(resolvedPath)).trim();
   const template2 = await getTemplateById("backend-only");
   log.info(`Scaffolding project at ${resolvedPath}`);
   const { projectId } = await runTask2("Setting up your project...", async () => {
@@ -254065,127 +253899,6 @@ Examples:
   $ base44 scaffold my-app --app-id app_123  Scaffolds the current dir, named "my-app"`).action(scaffoldAction);
 }
 
-// src/cli/commands/realtime/deploy.ts
-function parseNames3(args) {
-  return args.flatMap((arg) => arg.split(",")).map((n2) => n2.trim()).filter(Boolean);
-}
-function resolveHandlersToDeploy(names, allHandlers) {
-  if (names.length === 0)
-    return allHandlers;
-  const notFound = names.filter((n2) => !allHandlers.some((h2) => h2.name === n2));
-  if (notFound.length > 0) {
-    throw new InvalidInputError(`Realtime handler${notFound.length > 1 ? "s" : ""} not found in project: ${notFound.join(", ")}`);
-  }
-  return allHandlers.filter((h2) => names.includes(h2.name));
-}
-function formatDeployResult2(result, log) {
-  const label = result.name.padEnd(25);
-  if (result.status === "deployed") {
-    const timing = result.durationMs ? theme.styles.dim(` (${(result.durationMs / 1000).toFixed(1)}s)`) : "";
-    log.success(`${label} deployed${timing}`);
-  } else if (result.status === "unchanged") {
-    log.success(`${label} unchanged`);
-  } else {
-    log.error(`${label} error: ${result.error}`);
-  }
-}
-function buildDeploySummary2(results) {
-  const deployed = results.filter((r) => r.status === "deployed").length;
-  const unchanged = results.filter((r) => r.status === "unchanged").length;
-  const failed = results.filter((r) => r.status === "error").length;
-  const parts = [];
-  if (deployed > 0)
-    parts.push(`${deployed} deployed`);
-  if (unchanged > 0)
-    parts.push(`${unchanged} unchanged`);
-  if (failed > 0)
-    parts.push(`${failed} error${failed !== 1 ? "s" : ""}`);
-  return parts.join(", ") || "No realtime handlers deployed";
-}
-async function deployRealtimeAction({ log }, names) {
-  const { realtimeHandlers } = await readProjectConfig();
-  const toDeploy = resolveHandlersToDeploy(names, realtimeHandlers);
-  if (toDeploy.length === 0) {
-    return {
-      outroMessage: "No realtime handlers found. Create handlers in the 'realtime' directory."
-    };
-  }
-  log.info(`Found ${toDeploy.length} ${toDeploy.length === 1 ? "realtime handler" : "realtime handlers"} to deploy`);
-  let completed = 0;
-  const total = toDeploy.length;
-  const results = await deployRealtimeHandlersSequentially(toDeploy, {
-    onStart: (startNames) => {
-      const label = startNames.length === 1 ? startNames[0] : `${startNames.length} realtime handlers`;
-      log.step(theme.styles.dim(`[${completed + 1}/${total}] Deploying ${label}...`));
-    },
-    onResult: (result) => {
-      completed++;
-      formatDeployResult2(result, log);
-    }
-  });
-  const hasFailures = results.some((r) => r.status === "error");
-  if (hasFailures) {
-    log.message(buildDeploySummary2(results));
-    throw new CLIExitError(1);
-  }
-  return { outroMessage: buildDeploySummary2(results) };
-}
-function getDeployCommand3() {
-  return new Base44Command("deploy").description("Deploy realtime handlers to Base44").argument("[names...]", "Handler names to deploy (deploys all if omitted)").action(async (ctx, rawNames) => {
-    const names = parseNames3(rawNames);
-    return deployRealtimeAction(ctx, names);
-  });
-}
-
-// src/cli/commands/realtime/new.ts
-import { dirname as dirname19, join as join22 } from "node:path";
-function buildHandlerScaffold(handlerName) {
-  return `import { RealtimeHandler, type Conn } from "@base44/sdk";
-
-interface State {
-  // shared state broadcast to all clients
-}
-
-interface Message {
-  // messages sent from clients
-}
-
-export class ${handlerName} extends RealtimeHandler<State, Message> {
-  handleConnect(conn: Conn) {
-    console.log("Connected:", conn.userId);
-  }
-  handleMessage(conn: Conn, msg: Message) {
-    console.log("Message:", msg);
-  }
-  handleTick() {}
-  handleClose(conn: Conn) {}
-}
-`;
-}
-async function newRealtimeHandlerAction(_ctx, handlerName) {
-  const { project: project2 } = await readProjectConfig();
-  const realtimeDir = join22(dirname19(project2.configPath), project2.realtimeDir);
-  const handlerDir = join22(realtimeDir, handlerName);
-  if (await pathExists(handlerDir)) {
-    throw new InvalidInputError(`Realtime handler "${handlerName}" already exists at ${handlerDir}`);
-  }
-  const entryPath = join22(handlerDir, "entry.ts");
-  await writeFile(entryPath, buildHandlerScaffold(handlerName));
-  return {
-    outroMessage: `Created realtime handler "${handlerName}" at ${entryPath}`
-  };
-}
-function getNewCommand() {
-  return new Base44Command("new").description("Create a new realtime handler scaffold").argument("<HandlerName>", "Name of the realtime handler class").action(async (ctx, handlerName) => {
-    return newRealtimeHandlerAction(ctx, handlerName);
-  });
-}
-
-// src/cli/commands/realtime/index.ts
-function getRealtimeCommand() {
-  return new Command("realtime").description("Manage realtime handlers").addCommand(getNewCommand()).addCommand(getDeployCommand3());
-}
-
 // src/core/resources/sandbox/schema.ts
 var FileErrorSchema = exports_external.object({
   code: exports_external.string(),
@@ -254304,7 +254017,7 @@ function withSandboxAuthHint(error48) {
     cause: error48
   });
 }
-async function callTool(appId, tool, payload, schema11, context, timeout2 = 60000) {
+async function callTool(appId, tool, payload, schema10, context, timeout2 = 60000) {
   const client = getSandboxClient(appId);
   let response;
   try {
@@ -254312,7 +254025,7 @@ async function callTool(appId, tool, payload, schema11, context, timeout2 = 6000
   } catch (error48) {
     throw withSandboxAuthHint(await ApiError.fromHttpError(error48, context));
   }
-  const result = schema11.safeParse(await response.json());
+  const result = schema10.safeParse(await response.json());
   if (!result.success) {
     throw new SchemaValidationError("Invalid response from server", result.error);
   }
@@ -254710,9 +254423,9 @@ async function generateContent(input) {
 `);
 }
 async function compileEntity(entity2) {
-  const { name: name2, source: _source, ...schema11 } = entity2;
+  const { name: name2, source: _source, ...schema10 } = entity2;
   const jsonSchema = {
-    ...schema11,
+    ...schema10,
     title: name2,
     additionalProperties: false
   };
@@ -254739,10 +254452,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 join25 } from "node:path";
+import { join as join24 } from "node:path";
 var TYPES_INCLUDE_PATH = `${PROJECT_SUBDIR}/${TYPES_OUTPUT_SUBDIR}/*.d.ts`;
 async function updateProjectConfig(projectRoot) {
-  const tsconfigPath = join25(projectRoot, "tsconfig.json");
+  const tsconfigPath = join24(projectRoot, "tsconfig.json");
   if (!await pathExists(tsconfigPath)) {
     return false;
   }
@@ -254793,7 +254506,7 @@ function getTypesCommand() {
 // 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 join28 } from "node:path";
+import { dirname as dirname21, join as join27 } from "node:path";
 
 // ../../node_modules/get-port/index.js
 import net from "node:net";
@@ -254814,8 +254527,8 @@ var getLocalHosts = () => {
   const interfaces = os9.networkInterfaces();
   const results = new Set([undefined, "0.0.0.0"]);
   for (const _interface of Object.values(interfaces)) {
-    for (const config13 of _interface) {
-      results.add(config13.address);
+    for (const config12 of _interface) {
+      results.add(config12.address);
     }
   }
   return results;
@@ -255455,22 +255168,22 @@ class Database {
     this.schemas.clear();
   }
   validate(entityName, record2, partial2 = false) {
-    const schema11 = this.schemas.get(this.normalizeName(entityName));
-    if (!schema11) {
+    const schema10 = this.schemas.get(this.normalizeName(entityName));
+    if (!schema10) {
       throw new Error(`Entity "${entityName}" not found`);
     }
-    return this.validator.validate(record2, schema11, partial2);
+    return this.validator.validate(record2, schema10, partial2);
   }
   prepareRecord(entityName, record2, partial2 = false) {
-    const schema11 = this.schemas.get(this.normalizeName(entityName));
-    if (!schema11) {
+    const schema10 = this.schemas.get(this.normalizeName(entityName));
+    if (!schema10) {
       throw new Error(`Entity "${entityName}" not found`);
     }
-    const filteredRecord = this.validator.filterFields(record2, schema11);
+    const filteredRecord = this.validator.filterFields(record2, schema10);
     if (partial2) {
       return filteredRecord;
     }
-    return this.validator.applyDefaults(filteredRecord, schema11);
+    return this.validator.applyDefaults(filteredRecord, schema10);
   }
   normalizeName(entityName) {
     return entityName.toLowerCase();
@@ -255764,13 +255477,13 @@ function checkRLS(rule, record2, user) {
     return false;
   return evaluateCondition(rule, record2, user);
 }
-function applyFLS(record2, schema11, user, operation) {
+function applyFLS(record2, schema10, user, operation) {
   if (Array.isArray(record2)) {
-    return record2.map((r5) => applyFLS(r5, schema11, user, operation));
+    return record2.map((r5) => applyFLS(r5, schema10, user, operation));
   }
   const result = {};
   for (const [key2, value] of Object.entries(record2)) {
-    const rule = schema11.properties[key2]?.rls?.[operation];
+    const rule = schema10.properties[key2]?.rls?.[operation];
     if (rule === undefined || checkRLS(rule, record2, user)) {
       result[key2] = value;
     }
@@ -255998,14 +255711,14 @@ async function createEntityRoutes(db2, logger2, broadcast) {
         res.status(404).json({ error: `Entity "${entityName}" not found` });
         return;
       }
-      const schema11 = db2.getSchema(entityName);
-      if (!schema11) {
+      const schema10 = db2.getSchema(entityName);
+      if (!schema10) {
         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, schema11, currentUser);
+      await handler(req, res, collection, schema10, currentUser);
     };
   }
   function emit(appId, entityName, type, data) {
@@ -256023,19 +255736,19 @@ async function createEntityRoutes(db2, logger2, broadcast) {
     }
     broadcast(appId, entityName, createData(data));
   }
-  function prepareCreateRecord(entityName, body, schema11, currentUser, now) {
+  function prepareCreateRecord(entityName, body, schema10, currentUser, now) {
     const { _id, ...recordBody } = body;
     const ownerFields = {
       created_by: currentUser?.email,
       created_by_id: currentUser?.id
     };
-    if (!checkRLS(schema11.rls?.create, {
+    if (!checkRLS(schema10.rls?.create, {
       ...recordBody,
       ...ownerFields
     }, currentUser)) {
       return;
     }
-    const filteredBody = applyFLS(db2.prepareRecord(entityName, recordBody), schema11, currentUser, "write");
+    const filteredBody = applyFLS(db2.prepareRecord(entityName, recordBody), schema10, currentUser, "write");
     db2.validate(entityName, filteredBody);
     return {
       ...filteredBody,
@@ -256047,7 +255760,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, schema11, currentUser) => {
+  router.get("/:entityName/:id", withCollection(async (req, res, collection, schema10, currentUser) => {
     const { entityName, id: id2 } = req.params;
     try {
       const doc2 = await collection.findOneAsync({ id: id2 });
@@ -256055,27 +255768,27 @@ async function createEntityRoutes(db2, logger2, broadcast) {
         res.status(404).json({ error: `Record with id "${id2}" not found` });
         return;
       }
-      if (!checkRLS(schema11.rls?.read, doc2, currentUser)) {
+      if (!checkRLS(schema10.rls?.read, doc2, currentUser)) {
         res.status(404).json({
           message: `Entity ${entityName} with ID ${id2} not found`
         });
         return;
       }
-      const result = applyFLS(stripInternalFields(doc2), schema11, currentUser, "read");
+      const result = applyFLS(stripInternalFields(doc2), schema10, 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, schema11, currentUser) => {
+  router.get("/:entityName", withCollection(async (req, res, collection, schema10, currentUser) => {
     const { entityName } = req.params;
     try {
       let results = stripInternalFields(await queryEntity(collection, req.query));
-      if (schema11.rls?.read !== undefined && schema11.rls.read !== true) {
-        results = results.filter((doc2) => checkRLS(schema11.rls.read, doc2, currentUser));
+      if (schema10.rls?.read !== undefined && schema10.rls.read !== true) {
+        results = results.filter((doc2) => checkRLS(schema10.rls.read, doc2, currentUser));
       }
-      results = results.map((doc2) => applyFLS(doc2, schema11, currentUser, "read"));
+      results = results.map((doc2) => applyFLS(doc2, schema10, currentUser, "read"));
       res.json(results);
     } catch (error48) {
       if (error48 instanceof InvalidInputError) {
@@ -256086,16 +255799,16 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       }
     }
   }));
-  router.post("/:entityName", parseBody, withCollection(async (req, res, collection, schema11, currentUser) => {
+  router.post("/:entityName", parseBody, withCollection(async (req, res, collection, schema10, currentUser) => {
     const { appId, entityName } = req.params;
     try {
       const now = new Date().toISOString();
-      const record2 = prepareCreateRecord(entityName, req.body, schema11, currentUser, now);
+      const record2 = prepareCreateRecord(entityName, req.body, schema10, currentUser, now);
       if (!record2) {
         res.status(403).json({ error: "Permission denied" });
         return;
       }
-      const inserted = applyFLS(stripInternalFields(await collection.insertAsync(record2)), schema11, currentUser, "read");
+      const inserted = applyFLS(stripInternalFields(await collection.insertAsync(record2)), schema10, currentUser, "read");
       emit(appId, entityName, "create", inserted);
       res.status(201).json(inserted);
     } catch (error48) {
@@ -256107,7 +255820,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, schema11, currentUser) => {
+  router.post("/:entityName/bulk", parseBody, withCollection(async (req, res, collection, schema10, currentUser) => {
     const { appId, entityName } = req.params;
     if (!Array.isArray(req.body)) {
       res.status(400).json({ error: "Request body must be an array" });
@@ -256117,14 +255830,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, schema11, currentUser, now);
+        const record2 = prepareCreateRecord(entityName, body, schema10, currentUser, now);
         if (!record2) {
           res.status(403).json({ error: "Permission denied" });
           return;
         }
         records.push(record2);
       }
-      const inserted = applyFLS(stripInternalFields(await collection.insertAsync(records)), schema11, currentUser, "read");
+      const inserted = applyFLS(stripInternalFields(await collection.insertAsync(records)), schema10, currentUser, "read");
       emit(appId, entityName, "create", inserted);
       res.status(201).json(inserted);
     } catch (error48) {
@@ -256136,24 +255849,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, schema11, currentUser) => {
+  router.put("/:entityName/:id", parseBody, withCollection(async (req, res, collection, schema10, currentUser) => {
     const { appId, entityName, id: id2 } = req.params;
     const { id: _id, created_date: _created_date, ...body } = req.body;
     try {
-      if (schema11.rls?.update !== undefined) {
+      if (schema10.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(schema11.rls.update, existing, currentUser)) {
+        if (!checkRLS(schema10.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), schema11, currentUser, "write");
+      const filteredBody = applyFLS(db2.prepareRecord(entityName, body, true), schema10, currentUser, "write");
       db2.validate(entityName, filteredBody, true);
       const updateData = {
         ...filteredBody,
@@ -256164,7 +255877,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), schema11, currentUser, "read");
+      const updated = applyFLS(stripInternalFields(result.affectedDocuments), schema10, currentUser, "read");
       emit(appId, entityName, "update", updated);
       res.json(updated);
     } catch (error48) {
@@ -256176,7 +255889,7 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       res.status(500).json({ error: "Internal server error" });
     }
   }));
-  router.delete("/:entityName/:id", withCollection(async (req, res, collection, schema11, currentUser) => {
+  router.delete("/:entityName/:id", withCollection(async (req, res, collection, schema10, currentUser) => {
     const { appId, entityName, id: id2 } = req.params;
     try {
       const doc2 = await collection.findOneAsync({ id: id2 });
@@ -256184,7 +255897,7 @@ async function createEntityRoutes(db2, logger2, broadcast) {
         res.status(404).json({ error: `Record with id "${id2}" not found` });
         return;
       }
-      if (!checkRLS(schema11.rls?.delete, doc2, currentUser)) {
+      if (!checkRLS(schema10.rls?.delete, doc2, currentUser)) {
         res.status(404).json({
           message: `Entity ${entityName} with ID ${id2} not found`
         });
@@ -256198,11 +255911,11 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       res.status(500).json({ error: "Internal server error" });
     }
   }));
-  router.delete("/:entityName", parseBody, withCollection(async (req, res, collection, schema11, currentUser) => {
+  router.delete("/:entityName", parseBody, withCollection(async (req, res, collection, schema10, currentUser) => {
     const { entityName } = req.params;
     try {
       const query = req.body || {};
-      const rlsDelete = schema11?.rls?.delete;
+      const rlsDelete = schema10?.rls?.delete;
       if (rlsDelete !== undefined && rlsDelete !== true) {
         if (rlsDelete === false && currentUser?.is_service !== true) {
           res.status(403).json({ error: "Permission denied" });
@@ -256421,7 +256134,7 @@ class ServeRunner {
 
 // src/cli/dev/dev-server/watcher.ts
 import { EventEmitter as EventEmitter4 } from "node:events";
-import { relative as relative8 } from "node:path";
+import { relative as relative6 } from "node:path";
 
 // ../../node_modules/chokidar/index.js
 import { EventEmitter as EventEmitter3 } from "node:events";
@@ -256591,10 +256304,10 @@ class ReaddirpStream extends Readable6 {
   }
   async _formatEntry(dirent, path19) {
     let entry;
-    const basename7 = this._isDirent ? dirent.name : dirent;
+    const basename6 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path19, basename7));
-      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename7 };
+      const fullPath = presolve(pjoin(path19, basename6));
+      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename6 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
       this._onError(err);
@@ -257121,9 +256834,9 @@ class NodeFsHandler {
   _watchWithNodeFs(path19, listener) {
     const opts = this.fsw.options;
     const directory = sp2.dirname(path19);
-    const basename8 = sp2.basename(path19);
+    const basename7 = sp2.basename(path19);
     const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename8);
+    parent.add(basename7);
     const absolutePath = sp2.resolve(path19);
     const options8 = {
       persistent: opts.persistent
@@ -257133,7 +256846,7 @@ class NodeFsHandler {
     let closer;
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
-      options8.interval = enableBin && isBinaryPath(basename8) ? opts.binaryInterval : opts.interval;
+      options8.interval = enableBin && isBinaryPath(basename7) ? opts.binaryInterval : opts.interval;
       closer = setFsWatchFileListener(path19, absolutePath, options8, {
         listener,
         rawEmitter: this.fsw._emitRaw
@@ -257151,11 +256864,11 @@ class NodeFsHandler {
     if (this.fsw.closed) {
       return;
     }
-    const dirname23 = sp2.dirname(file2);
-    const basename8 = sp2.basename(file2);
-    const parent = this.fsw._getWatchedDir(dirname23);
+    const dirname20 = sp2.dirname(file2);
+    const basename7 = sp2.basename(file2);
+    const parent = this.fsw._getWatchedDir(dirname20);
     let prevStats = stats;
-    if (parent.has(basename8))
+    if (parent.has(basename7))
       return;
     const listener = async (path19, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
@@ -257180,9 +256893,9 @@ class NodeFsHandler {
             prevStats = newStats2;
           }
         } catch (error48) {
-          this.fsw._remove(dirname23, basename8);
+          this.fsw._remove(dirname20, basename7);
         }
-      } else if (parent.has(basename8)) {
+      } else if (parent.has(basename7)) {
         const at13 = newStats.atimeMs;
         const mt12 = newStats.mtimeMs;
         if (!at13 || at13 <= mt12 || mt12 !== prevStats.mtimeMs) {
@@ -257403,11 +257116,11 @@ function createPattern(matcher) {
       if (matcher.path === string4)
         return true;
       if (matcher.recursive) {
-        const relative8 = sp3.relative(matcher.path, string4);
-        if (!relative8) {
+        const relative6 = sp3.relative(matcher.path, string4);
+        if (!relative6) {
           return false;
         }
-        return !relative8.startsWith("..") && !sp3.isAbsolute(relative8);
+        return !relative6.startsWith("..") && !sp3.isAbsolute(relative6);
       }
       return false;
     };
@@ -258106,7 +257819,7 @@ class WatchBase44 extends EventEmitter4 {
       ignoreInitial: true
     });
     watcher.on("all", import_debounce.default(async (_event, path19) => {
-      this.emit("change", name2, relative8(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);
@@ -258213,8 +257926,8 @@ async function createDevServer(options8) {
     broadcastEntityEvent(io6, appId, entityName, event);
   };
   const base44ConfigWatcher = new WatchBase44({
-    functions: join28(dirname24(project2.configPath), project2.functionsDir),
-    entities: join28(dirname24(project2.configPath), project2.entitiesDir)
+    functions: join27(dirname21(project2.configPath), project2.functionsDir),
+    entities: join27(dirname21(project2.configPath), project2.entitiesDir)
   }, devLogger);
   base44ConfigWatcher.on("change", async (name2) => {
     try {
@@ -258563,7 +258276,6 @@ function createProgram(context) {
   program2.addCommand(getAgentsCommand());
   program2.addCommand(getConnectorsCommand());
   program2.addCommand(getFunctionsCommand());
-  program2.addCommand(getRealtimeCommand());
   program2.addCommand(getSecretsCommand());
   program2.addCommand(getSandboxCommand());
   program2.addCommand(getAuthCommand());
@@ -258580,7 +258292,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 } from "path";
+import { dirname as dirname22, posix, sep } from "path";
 function createModulerModifier() {
   const getModuleFromFileName = createGetModuleFromFilename();
   return async (frames) => {
@@ -258589,7 +258301,7 @@ function createModulerModifier() {
     return frames;
   };
 }
-function createGetModuleFromFilename(basePath = process.argv[1] ? dirname25(process.argv[1]) : process.cwd(), isWindows5 = sep === "\\") {
+function createGetModuleFromFilename(basePath = process.argv[1] ? dirname22(process.argv[1]) : process.cwd(), isWindows5 = sep === "\\") {
   const normalizedBase = isWindows5 ? normalizeWindowsPath2(basePath) : basePath;
   return (filename) => {
     if (!filename)
@@ -262778,9 +262490,9 @@ function addCommandInfoToErrorReporter(program2, errorReporter) {
   });
 }
 // src/cli/index.ts
-var __dirname4 = dirname26(fileURLToPath6(import.meta.url));
+var __dirname4 = dirname23(fileURLToPath6(import.meta.url));
 async function runCLI(options8) {
-  ensureNpmAssets(join29(__dirname4, "../assets"));
+  ensureNpmAssets(join28(__dirname4, "../assets"));
   const errorReporter = new ErrorReporter;
   errorReporter.registerProcessErrorHandlers();
   const jsonMode = process.argv.includes("--json");
@@ -262819,4 +262531,4 @@ export {
   CLIExitError
 };
 
-//# debugId=3D480857EA9CF9EE64756E2164756E21
+//# debugId=5E8B47CEC753F05764756E2164756E21