@base44-preview/cli 0.1.5-pr.575.c55cbe2 → 0.1.5-pr.576.7190826

package/dist/cli/index.js

@@ -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];
       }
@@ -20114,7 +20114,7 @@ var require_lodash8 = __commonJS((exports, module) => {
         }
         return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped, undefined2, comparator) : [];
       });
-      function join15(array2, separator) {
+      function join14(array2, separator) {
         return array2 == null ? "" : nativeJoin.call(array2, separator);
       }
       function last(array2) {
@@ -22046,7 +22046,7 @@ __p += '`;
       lodash.isUndefined = isUndefined;
       lodash.isWeakMap = isWeakMap;
       lodash.isWeakSet = isWeakSet;
-      lodash.join = join15;
+      lodash.join = join14;
       lodash.kebabCase = kebabCase;
       lodash.last = last;
       lodash.lastIndexOf = lastIndexOf;
@@ -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" ? join24(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 join24(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: join24,
+    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 schema12 = new SchemaConstructor(parameters);
-  const subSchema = Object.create(schema12);
+  const schema11 = new SchemaConstructor(parameters);
+  const subSchema = Object.create(schema11);
   for (const handlerKey of HANDLER_KEYS) {
     if (handlerKey in parameters) {
-      subSchema[handlerKey] = normalizeHandler(parameters[handlerKey], schema12, Schema2.prototype[handlerKey].length);
+      subSchema[handlerKey] = normalizeHandler(parameters[handlerKey], schema11, 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) {
@@ -122904,9 +122904,9 @@ function optionInfoToSchema(optionInfo, {
       throw new Error(`Unexpected type ${optionInfo.type}`);
   }
   if (optionInfo.exception) {
-    parameters.validate = (value, schema12, utils3) => optionInfo.exception(value) || schema12.validate(value, utils3);
+    parameters.validate = (value, schema11, utils3) => optionInfo.exception(value) || schema11.validate(value, utils3);
   } else {
-    parameters.validate = (value, schema12, utils3) => value === undefined || schema12.validate(value, utils3);
+    parameters.validate = (value, schema11, utils3) => value === undefined || schema11.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, schema12, utils3) => schema12.preprocess(originalPreprocess(Array.isArray(value) ? method_at_default2(0, value, -1) : value), utils3);
+    parameters.preprocess = (value, schema11, utils3) => schema11.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 schema12 = this._utils.schemas[key2];
+      const schema11 = this._utils.schemas[key2];
       if (!(key2 in newOptions)) {
-        const defaultResult = normalizeDefaultResult(schema12.default(this._utils));
+        const defaultResult = normalizeDefaultResult(schema11.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 schema12 = this._utils.schemas[key2];
+      const schema11 = this._utils.schemas[key2];
       const value = newOptions[key2];
-      const newValue = schema12.postprocess(value, this._utils);
+      const newValue = schema11.postprocess(value, this._utils);
       if (newValue === VALUE_UNCHANGED) {
         continue;
       }
-      this._applyValidation(newValue, key2, schema12);
+      this._applyValidation(newValue, key2, schema11);
       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 schema12 = this._utils.schemas[key2];
-      const value = schema12.preprocess(options8[key2], this._utils);
-      this._applyValidation(value, key2, schema12);
+      const schema11 = this._utils.schemas[key2];
+      const value = schema11.preprocess(options8[key2], this._utils);
+      this._applyValidation(value, key2, schema11);
       const appendTransferredOptions = ({ from, to: to5 }) => {
         transferredOptionsArray.push(typeof to5 === "string" ? { [to5]: from } : { [to5.key]: to5.value });
       };
       const warnDeprecated = ({ value: currentValue, redirectTo }) => {
-        const deprecatedResult = normalizeDeprecatedResult(schema12.deprecated(currentValue, this._utils), value, true);
+        const deprecatedResult = normalizeDeprecatedResult(schema11.deprecated(currentValue, this._utils), value, true);
         if (deprecatedResult === false) {
           return;
         }
@@ -124553,13 +124553,13 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc,
           }
         }
       };
-      const forwardResult = normalizeForwardResult(schema12.forward(value, this._utils), value);
+      const forwardResult = normalizeForwardResult(schema11.forward(value, this._utils), value);
       forwardResult.forEach(appendTransferredOptions);
-      const redirectResult = normalizeRedirectResult(schema12.redirect(value, this._utils), value);
+      const redirectResult = normalizeRedirectResult(schema11.redirect(value, this._utils), value);
       redirectResult.redirect.forEach(appendTransferredOptions);
       if ("remain" in redirectResult) {
         const remainingValue = redirectResult.remain;
-        newOptions[key2] = key2 in newOptions ? schema12.overlap(newOptions[key2], remainingValue, this._utils) : remainingValue;
+        newOptions[key2] = key2 in newOptions ? schema11.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, schema12) {
-    const validateResult = normalizeValidateResult(schema12.validate(value, this._utils), value);
+  _applyValidation(value, key2, schema11) {
+    const validateResult = normalizeValidateResult(schema11.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 schema12 = this._utils.schemas[knownResultKey];
-          this._applyValidation(knownResultValue, knownResultKey, schema12);
+          const schema11 = this._utils.schemas[knownResultKey];
+          this._applyValidation(knownResultValue, knownResultKey, schema11);
           options8[knownResultKey] = knownResultValue;
         });
       }
@@ -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" ? join26(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 join26(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: join26,
+      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)((schema12) => {
-    const parent = schema12[exports.Parent];
+  exports.getRootSchema = (0, lodash_1.memoize)((schema11) => {
+    const parent = schema11[exports.Parent];
     if (!parent) {
-      return schema12;
+      return schema11;
     }
     return (0, exports.getRootSchema)(parent);
   });
-  function isBoolean(schema12) {
-    return schema12 === true || schema12 === false;
+  function isBoolean(schema11) {
+    return schema11 === true || schema11 === false;
   }
   exports.isBoolean = isBoolean;
-  function isPrimitive(schema12) {
-    return !(0, lodash_1.isPlainObject)(schema12);
+  function isPrimitive(schema11) {
+    return !(0, lodash_1.isPlainObject)(schema11);
   }
   exports.isPrimitive = isPrimitive;
-  function isCompound(schema12) {
-    return Array.isArray(schema12.type) || "anyOf" in schema12 || "oneOf" in schema12;
+  function isCompound(schema11) {
+    return Array.isArray(schema11.type) || "anyOf" in schema11 || "oneOf" in schema11;
   }
   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(schema12, name2) {
+  function compileList(schema11, name2) {
     var result = [];
-    schema12[name2].forEach(function(currentType) {
+    schema11[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(schema12, map2) {
+  function compileStyleMap(schema11, 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 = schema12.compiledTypeMap["fallback"][tag];
+      type = schema11.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(schema12, callback, processed) {
-    if (typeof schema12 !== "object" || !schema12) {
+  function traverseIntersection(schema11, callback, processed) {
+    if (typeof schema11 !== "object" || !schema11) {
       return;
     }
-    const r5 = schema12;
+    const r5 = schema11;
     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(schema12, callback, processed = new Set, key2) {
-    if (processed.has(schema12)) {
+  function traverse(schema11, callback, processed = new Set, key2) {
+    if (processed.has(schema11)) {
       return;
     }
-    processed.add(schema12);
-    callback(schema12, key2 !== null && key2 !== undefined ? key2 : null);
-    if (schema12.anyOf) {
-      traverseArray(schema12.anyOf, callback, processed);
+    processed.add(schema11);
+    callback(schema11, key2 !== null && key2 !== undefined ? key2 : null);
+    if (schema11.anyOf) {
+      traverseArray(schema11.anyOf, callback, processed);
     }
-    if (schema12.allOf) {
-      traverseArray(schema12.allOf, callback, processed);
+    if (schema11.allOf) {
+      traverseArray(schema11.allOf, callback, processed);
     }
-    if (schema12.oneOf) {
-      traverseArray(schema12.oneOf, callback, processed);
+    if (schema11.oneOf) {
+      traverseArray(schema11.oneOf, callback, processed);
     }
-    if (schema12.properties) {
-      traverseObjectKeys(schema12.properties, callback, processed);
+    if (schema11.properties) {
+      traverseObjectKeys(schema11.properties, callback, processed);
     }
-    if (schema12.patternProperties) {
-      traverseObjectKeys(schema12.patternProperties, callback, processed);
+    if (schema11.patternProperties) {
+      traverseObjectKeys(schema11.patternProperties, callback, processed);
     }
-    if (schema12.additionalProperties && typeof schema12.additionalProperties === "object") {
-      traverse(schema12.additionalProperties, callback, processed);
+    if (schema11.additionalProperties && typeof schema11.additionalProperties === "object") {
+      traverse(schema11.additionalProperties, callback, processed);
     }
-    if (schema12.items) {
-      const { items } = schema12;
+    if (schema11.items) {
+      const { items } = schema11;
       if (Array.isArray(items)) {
         traverseArray(items, callback, processed);
       } else {
         traverse(items, callback, processed);
       }
     }
-    if (schema12.additionalItems && typeof schema12.additionalItems === "object") {
-      traverse(schema12.additionalItems, callback, processed);
+    if (schema11.additionalItems && typeof schema11.additionalItems === "object") {
+      traverse(schema11.additionalItems, callback, processed);
     }
-    if (schema12.dependencies) {
-      if (Array.isArray(schema12.dependencies)) {
-        traverseArray(schema12.dependencies, callback, processed);
+    if (schema11.dependencies) {
+      if (Array.isArray(schema11.dependencies)) {
+        traverseArray(schema11.dependencies, callback, processed);
       } else {
-        traverseObjectKeys(schema12.dependencies, callback, processed);
+        traverseObjectKeys(schema11.dependencies, callback, processed);
       }
     }
-    if (schema12.definitions) {
-      traverseObjectKeys(schema12.definitions, callback, processed);
+    if (schema11.definitions) {
+      traverseObjectKeys(schema11.definitions, callback, processed);
     }
-    if (schema12.$defs) {
-      traverseObjectKeys(schema12.$defs, callback, processed);
+    if (schema11.$defs) {
+      traverseObjectKeys(schema11.$defs, callback, processed);
     }
-    if (schema12.not) {
-      traverse(schema12.not, callback, processed);
+    if (schema11.not) {
+      traverse(schema11.not, callback, processed);
     }
-    traverseIntersection(schema12, callback, processed);
-    Object.keys(schema12).filter((key3) => !BLACKLISTED_KEYS.has(key3)).forEach((key3) => {
-      const child = schema12[key3];
+    traverseIntersection(schema11, callback, processed);
+    Object.keys(schema11).filter((key3) => !BLACKLISTED_KEYS.has(key3)).forEach((key3) => {
+      const child = schema11[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(schema12) {
+  function escapeBlockComment(schema11) {
     const replacer = "* /";
-    if (schema12 === null || typeof schema12 !== "object") {
+    if (schema11 === null || typeof schema11 !== "object") {
       return;
     }
-    for (const key2 of Object.keys(schema12)) {
-      if (key2 === "description" && typeof schema12[key2] === "string") {
-        schema12[key2] = schema12[key2].replace(/\*\//g, replacer);
+    for (const key2 of Object.keys(schema11)) {
+      if (key2 === "description" && typeof schema11[key2] === "string") {
+        schema11[key2] = schema11[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(schema12) {
-    if (!("default" in schema12)) {
-      return schema12;
+  function maybeStripDefault(schema11) {
+    if (!("default" in schema11)) {
+      return schema11;
     }
-    switch (schema12.type) {
+    switch (schema11.type) {
       case "array":
-        if (Array.isArray(schema12.default)) {
-          return schema12;
+        if (Array.isArray(schema11.default)) {
+          return schema11;
         }
         break;
       case "boolean":
-        if (typeof schema12.default === "boolean") {
-          return schema12;
+        if (typeof schema11.default === "boolean") {
+          return schema11;
         }
         break;
       case "integer":
       case "number":
-        if (typeof schema12.default === "number") {
-          return schema12;
+        if (typeof schema11.default === "number") {
+          return schema11;
         }
         break;
       case "string":
-        if (typeof schema12.default === "string") {
-          return schema12;
+        if (typeof schema11.default === "string") {
+          return schema11;
         }
         break;
       case "null":
-        if (schema12.default === null) {
-          return schema12;
+        if (schema11.default === null) {
+          return schema11;
         }
         break;
       case "object":
-        if ((0, lodash_1.isPlainObject)(schema12.default)) {
-          return schema12;
+        if ((0, lodash_1.isPlainObject)(schema11.default)) {
+          return schema11;
         }
         break;
     }
-    delete schema12.default;
-    return schema12;
+    delete schema11.default;
+    return schema11;
   }
   exports.maybeStripDefault = maybeStripDefault;
   function appendToDescription(existingDescription, ...values) {
@@ -141424,11 +141424,11 @@ ${values.join(`
 `);
   }
   exports.appendToDescription = appendToDescription;
-  function isSchemaLike(schema12) {
-    if (!(0, lodash_1.isPlainObject)(schema12)) {
+  function isSchemaLike(schema11) {
+    if (!(0, lodash_1.isPlainObject)(schema11)) {
       return false;
     }
-    const parent = schema12[JSONSchema_1.Parent];
+    const parent = schema11[JSONSchema_1.Parent];
     if (parent === null) {
       return true;
     }
@@ -141445,7 +141445,7 @@ ${values.join(`
       "properties",
       "required"
     ];
-    if (JSON_SCHEMA_KEYWORDS.some((_10) => parent[_10] === schema12)) {
+    if (JSON_SCHEMA_KEYWORDS.some((_10) => parent[_10] === schema11)) {
       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(schema12) {
-    if (schema12.tsType) {
+  function typesOfSchema(schema11) {
+    if (schema11.tsType) {
       return new Set(["CUSTOM_TYPE"]);
     }
     const matchedTypes = new Set;
     for (const [schemaType, f7] of Object.entries(matchers)) {
-      if (f7(schema12)) {
+      if (f7(schema11)) {
         matchedTypes.add(schemaType);
       }
     }
@@ -141760,26 +141760,26 @@ var require_typesOfSchema = __commonJS((exports) => {
   }
   exports.typesOfSchema = typesOfSchema;
   var matchers = {
-    ALL_OF(schema12) {
-      return "allOf" in schema12;
+    ALL_OF(schema11) {
+      return "allOf" in schema11;
     },
-    ANY(schema12) {
-      if (Object.keys(schema12).length === 0) {
+    ANY(schema11) {
+      if (Object.keys(schema11).length === 0) {
         return true;
       }
-      return schema12.type === "any";
+      return schema11.type === "any";
     },
-    ANY_OF(schema12) {
-      return "anyOf" in schema12;
+    ANY_OF(schema11) {
+      return "anyOf" in schema11;
     },
-    BOOLEAN(schema12) {
-      if ("enum" in schema12) {
+    BOOLEAN(schema11) {
+      if ("enum" in schema11) {
         return false;
       }
-      if (schema12.type === "boolean") {
+      if (schema11.type === "boolean") {
         return true;
       }
-      if (!(0, JSONSchema_1.isCompound)(schema12) && typeof schema12.default === "boolean") {
+      if (!(0, JSONSchema_1.isCompound)(schema11) && typeof schema11.default === "boolean") {
         return true;
       }
       return false;
@@ -141787,74 +141787,74 @@ var require_typesOfSchema = __commonJS((exports) => {
     CUSTOM_TYPE() {
       return false;
     },
-    NAMED_ENUM(schema12) {
-      return "enum" in schema12 && "tsEnumNames" in schema12;
+    NAMED_ENUM(schema11) {
+      return "enum" in schema11 && "tsEnumNames" in schema11;
     },
-    NAMED_SCHEMA(schema12) {
-      return "$id" in schema12 && (("patternProperties" in schema12) || ("properties" in schema12));
+    NAMED_SCHEMA(schema11) {
+      return "$id" in schema11 && (("patternProperties" in schema11) || ("properties" in schema11));
     },
-    NEVER(schema12) {
-      return schema12 === false;
+    NEVER(schema11) {
+      return schema11 === false;
     },
-    NULL(schema12) {
-      return schema12.type === "null";
+    NULL(schema11) {
+      return schema11.type === "null";
     },
-    NUMBER(schema12) {
-      if ("enum" in schema12) {
+    NUMBER(schema11) {
+      if ("enum" in schema11) {
         return false;
       }
-      if (schema12.type === "integer" || schema12.type === "number") {
+      if (schema11.type === "integer" || schema11.type === "number") {
         return true;
       }
-      if (!(0, JSONSchema_1.isCompound)(schema12) && typeof schema12.default === "number") {
+      if (!(0, JSONSchema_1.isCompound)(schema11) && typeof schema11.default === "number") {
         return true;
       }
       return false;
     },
-    OBJECT(schema12) {
-      return schema12.type === "object" && !(0, lodash_1.isPlainObject)(schema12.additionalProperties) && !schema12.allOf && !schema12.anyOf && !schema12.oneOf && !schema12.patternProperties && !schema12.properties && !schema12.required;
+    OBJECT(schema11) {
+      return schema11.type === "object" && !(0, lodash_1.isPlainObject)(schema11.additionalProperties) && !schema11.allOf && !schema11.anyOf && !schema11.oneOf && !schema11.patternProperties && !schema11.properties && !schema11.required;
     },
-    ONE_OF(schema12) {
-      return "oneOf" in schema12;
+    ONE_OF(schema11) {
+      return "oneOf" in schema11;
     },
-    REFERENCE(schema12) {
-      return "$ref" in schema12;
+    REFERENCE(schema11) {
+      return "$ref" in schema11;
     },
-    STRING(schema12) {
-      if ("enum" in schema12) {
+    STRING(schema11) {
+      if ("enum" in schema11) {
         return false;
       }
-      if (schema12.type === "string") {
+      if (schema11.type === "string") {
         return true;
       }
-      if (!(0, JSONSchema_1.isCompound)(schema12) && typeof schema12.default === "string") {
+      if (!(0, JSONSchema_1.isCompound)(schema11) && typeof schema11.default === "string") {
         return true;
       }
       return false;
     },
-    TYPED_ARRAY(schema12) {
-      if (schema12.type && schema12.type !== "array") {
+    TYPED_ARRAY(schema11) {
+      if (schema11.type && schema11.type !== "array") {
         return false;
       }
-      return "items" in schema12;
+      return "items" in schema11;
     },
-    UNION(schema12) {
-      return Array.isArray(schema12.type);
+    UNION(schema11) {
+      return Array.isArray(schema11.type);
     },
-    UNNAMED_ENUM(schema12) {
-      if ("tsEnumNames" in schema12) {
+    UNNAMED_ENUM(schema11) {
+      if ("tsEnumNames" in schema11) {
         return false;
       }
-      if (schema12.type && schema12.type !== "boolean" && schema12.type !== "integer" && schema12.type !== "number" && schema12.type !== "string") {
+      if (schema11.type && schema11.type !== "boolean" && schema11.type !== "integer" && schema11.type !== "number" && schema11.type !== "string") {
         return false;
       }
-      return "enum" in schema12;
+      return "enum" in schema11;
     },
     UNNAMED_SCHEMA() {
       return false;
     },
-    UNTYPED_ARRAY(schema12) {
-      return schema12.type === "array" && !("items" in schema12);
+    UNTYPED_ARRAY(schema11) {
+      return schema11.type === "array" && !("items" in schema11);
     }
   };
 });
@@ -141865,10 +141865,10 @@ var require_applySchemaTyping = __commonJS((exports) => {
   exports.applySchemaTyping = undefined;
   var JSONSchema_1 = require_JSONSchema();
   var typesOfSchema_1 = require_typesOfSchema();
-  function applySchemaTyping(schema12) {
+  function applySchemaTyping(schema11) {
     var _a7;
-    const types = (0, typesOfSchema_1.typesOfSchema)(schema12);
-    Object.defineProperty(schema12, JSONSchema_1.Types, {
+    const types = (0, typesOfSchema_1.typesOfSchema)(schema11);
+    Object.defineProperty(schema11, JSONSchema_1.Types, {
       enumerable: false,
       value: types,
       writable: false
@@ -141877,23 +141877,23 @@ var require_applySchemaTyping = __commonJS((exports) => {
       return;
     }
     const intersection2 = {
-      [JSONSchema_1.Parent]: schema12,
+      [JSONSchema_1.Parent]: schema11,
       [JSONSchema_1.Types]: new Set(["ALL_OF"]),
-      $id: schema12.$id,
-      description: schema12.description,
-      name: schema12.name,
-      title: schema12.title,
-      allOf: (_a7 = schema12.allOf) !== null && _a7 !== undefined ? _a7 : [],
+      $id: schema11.$id,
+      description: schema11.description,
+      name: schema11.name,
+      title: schema11.title,
+      allOf: (_a7 = schema11.allOf) !== null && _a7 !== undefined ? _a7 : [],
       required: [],
       additionalProperties: false
     };
     types.delete("ALL_OF");
-    delete schema12.allOf;
-    delete schema12.$id;
-    delete schema12.description;
-    delete schema12.name;
-    delete schema12.title;
-    Object.defineProperty(schema12, JSONSchema_1.Intersection, {
+    delete schema11.allOf;
+    delete schema11.$id;
+    delete schema11.description;
+    delete schema11.name;
+    delete schema11.title;
+    Object.defineProperty(schema11, 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(schema12, type) {
-    return schema12.type === type || Array.isArray(schema12.type) && schema12.type.includes(type);
+  function hasType(schema11, type) {
+    return schema11.type === type || Array.isArray(schema11.type) && schema11.type.includes(type);
   }
-  function isObjectType(schema12) {
-    return schema12.properties !== undefined || hasType(schema12, "object") || hasType(schema12, "any");
+  function isObjectType(schema11) {
+    return schema11.properties !== undefined || hasType(schema11, "object") || hasType(schema11, "any");
   }
-  function isArrayType(schema12) {
-    return schema12.items !== undefined || hasType(schema12, "array") || hasType(schema12, "any");
+  function isArrayType(schema11) {
+    return schema11.items !== undefined || hasType(schema11, "array") || hasType(schema11, "any");
   }
-  function isEnumTypeWithoutTsEnumNames(schema12) {
-    return schema12.type === "string" && schema12.enum !== undefined && schema12.tsEnumNames === undefined;
+  function isEnumTypeWithoutTsEnumNames(schema11) {
+    return schema11.type === "string" && schema11.enum !== undefined && schema11.tsEnumNames === undefined;
   }
-  rules.set('Remove `type=["null"]` if `enum=[null]`', (schema12) => {
-    if (Array.isArray(schema12.enum) && schema12.enum.some((e8) => e8 === null) && Array.isArray(schema12.type) && schema12.type.includes("null")) {
-      schema12.type = schema12.type.filter((type) => type !== "null");
+  rules.set('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("Destructure unary types", (schema12) => {
-    if (schema12.type && Array.isArray(schema12.type) && schema12.type.length === 1) {
-      schema12.type = schema12.type[0];
+  rules.set("Destructure unary types", (schema11) => {
+    if (schema11.type && Array.isArray(schema11.type) && schema11.type.length === 1) {
+      schema11.type = schema11.type[0];
     }
   });
-  rules.set("Add empty `required` property if none is defined", (schema12) => {
-    if (isObjectType(schema12) && !("required" in schema12)) {
-      schema12.required = [];
+  rules.set("Add empty `required` property if none is defined", (schema11) => {
+    if (isObjectType(schema11) && !("required" in schema11)) {
+      schema11.required = [];
     }
   });
-  rules.set("Transform `required`=false to `required`=[]", (schema12) => {
-    if (schema12.required === false) {
-      schema12.required = [];
+  rules.set("Transform `required`=false to `required`=[]", (schema11) => {
+    if (schema11.required === false) {
+      schema11.required = [];
     }
   });
-  rules.set("Default additionalProperties", (schema12, _10, options8) => {
-    if (isObjectType(schema12) && !("additionalProperties" in schema12) && schema12.patternProperties === undefined) {
-      schema12.additionalProperties = options8.additionalProperties;
+  rules.set("Default additionalProperties", (schema11, _10, options8) => {
+    if (isObjectType(schema11) && !("additionalProperties" in schema11) && schema11.patternProperties === undefined) {
+      schema11.additionalProperties = options8.additionalProperties;
     }
   });
-  rules.set("Transform id to $id", (schema12, fileName) => {
-    if (!(0, utils_1.isSchemaLike)(schema12)) {
+  rules.set("Transform id to $id", (schema11, fileName) => {
+    if (!(0, utils_1.isSchemaLike)(schema11)) {
       return;
     }
-    if (schema12.id && schema12.$id && schema12.id !== schema12.$id) {
-      throw ReferenceError(`Schema must define either id or $id, not both. Given id=${schema12.id}, $id=${schema12.$id} in ${fileName}`);
+    if (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 (schema12.id) {
-      schema12.$id = schema12.id;
-      delete schema12.id;
+    if (schema11.id) {
+      schema11.$id = schema11.id;
+      delete schema11.id;
     }
   });
-  rules.set("Add an $id to anything that needs it", (schema12, fileName, _options, _key, dereferencedPaths) => {
-    if (!(0, utils_1.isSchemaLike)(schema12)) {
+  rules.set("Add an $id to anything that needs it", (schema11, fileName, _options, _key, dereferencedPaths) => {
+    if (!(0, utils_1.isSchemaLike)(schema11)) {
       return;
     }
-    if (!schema12.$id && !schema12[JSONSchema_1.Parent]) {
-      schema12.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(fileName));
+    if (!schema11.$id && !schema11[JSONSchema_1.Parent]) {
+      schema11.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(fileName));
       return;
     }
-    if (!isArrayType(schema12) && !isObjectType(schema12)) {
+    if (!isArrayType(schema11) && !isObjectType(schema11)) {
       return;
     }
-    const dereferencedName = dereferencedPaths.get(schema12);
-    if (!schema12.$id && !schema12.title && dereferencedName) {
-      schema12.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(dereferencedName));
+    const dereferencedName = dereferencedPaths.get(schema11);
+    if (!schema11.$id && !schema11.title && dereferencedName) {
+      schema11.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(dereferencedName));
     }
     if (dereferencedName) {
-      dereferencedPaths.delete(schema12);
+      dereferencedPaths.delete(schema11);
     }
   });
-  rules.set("Escape closing JSDoc comment", (schema12) => {
-    (0, utils_1.escapeBlockComment)(schema12);
+  rules.set("Escape closing JSDoc comment", (schema11) => {
+    (0, utils_1.escapeBlockComment)(schema11);
   });
-  rules.set("Add JSDoc comments for minItems and maxItems", (schema12) => {
-    if (!isArrayType(schema12)) {
+  rules.set("Add JSDoc comments for minItems and maxItems", (schema11) => {
+    if (!isArrayType(schema11)) {
       return;
     }
     const commentsToAppend = [
-      "minItems" in schema12 ? `@minItems ${schema12.minItems}` : "",
-      "maxItems" in schema12 ? `@maxItems ${schema12.maxItems}` : ""
+      "minItems" in schema11 ? `@minItems ${schema11.minItems}` : "",
+      "maxItems" in schema11 ? `@maxItems ${schema11.maxItems}` : ""
     ].filter(Boolean);
     if (commentsToAppend.length) {
-      schema12.description = (0, utils_1.appendToDescription)(schema12.description, ...commentsToAppend);
+      schema11.description = (0, utils_1.appendToDescription)(schema11.description, ...commentsToAppend);
     }
   });
-  rules.set("Optionally remove maxItems and minItems", (schema12, _fileName, options8) => {
-    if (!isArrayType(schema12)) {
+  rules.set("Optionally remove maxItems and minItems", (schema11, _fileName, options8) => {
+    if (!isArrayType(schema11)) {
       return;
     }
-    if ("minItems" in schema12 && options8.ignoreMinAndMaxItems) {
-      delete schema12.minItems;
+    if ("minItems" in schema11 && options8.ignoreMinAndMaxItems) {
+      delete schema11.minItems;
     }
-    if ("maxItems" in schema12 && (options8.ignoreMinAndMaxItems || options8.maxItems === -1)) {
-      delete schema12.maxItems;
+    if ("maxItems" in schema11 && (options8.ignoreMinAndMaxItems || options8.maxItems === -1)) {
+      delete schema11.maxItems;
     }
   });
-  rules.set("Normalize schema.minItems", (schema12, _fileName, options8) => {
+  rules.set("Normalize schema.minItems", (schema11, _fileName, options8) => {
     if (options8.ignoreMinAndMaxItems) {
       return;
     }
-    if (!isArrayType(schema12)) {
+    if (!isArrayType(schema11)) {
       return;
     }
-    const { minItems } = schema12;
-    schema12.minItems = typeof minItems === "number" ? minItems : 0;
+    const { minItems } = schema11;
+    schema11.minItems = typeof minItems === "number" ? minItems : 0;
   });
-  rules.set("Remove maxItems if it is big enough to likely cause OOMs", (schema12, _fileName, options8) => {
+  rules.set("Remove maxItems if it is big enough to likely cause OOMs", (schema11, _fileName, options8) => {
     if (options8.ignoreMinAndMaxItems || options8.maxItems === -1) {
       return;
     }
-    if (!isArrayType(schema12)) {
+    if (!isArrayType(schema11)) {
       return;
     }
-    const { maxItems, minItems } = schema12;
+    const { maxItems, minItems } = schema11;
     if (maxItems !== undefined && maxItems - minItems > options8.maxItems) {
-      delete schema12.maxItems;
+      delete schema11.maxItems;
     }
   });
-  rules.set("Normalize schema.items", (schema12, _fileName, options8) => {
+  rules.set("Normalize schema.items", (schema11, _fileName, options8) => {
     if (options8.ignoreMinAndMaxItems) {
       return;
     }
-    const { maxItems, minItems } = schema12;
+    const { maxItems, minItems } = schema11;
     const hasMaxItems = typeof maxItems === "number" && maxItems >= 0;
     const hasMinItems = typeof minItems === "number" && minItems > 0;
-    if (schema12.items && !Array.isArray(schema12.items) && (hasMaxItems || hasMinItems)) {
-      const items = schema12.items;
+    if (schema11.items && !Array.isArray(schema11.items) && (hasMaxItems || hasMinItems)) {
+      const items = schema11.items;
       const newItems = Array(maxItems || minItems || 0).fill(items);
       if (!hasMaxItems) {
-        schema12.additionalItems = items;
+        schema11.additionalItems = items;
       }
-      schema12.items = newItems;
+      schema11.items = newItems;
     }
-    if (Array.isArray(schema12.items) && hasMaxItems && maxItems < schema12.items.length) {
-      schema12.items = schema12.items.slice(0, maxItems);
+    if (Array.isArray(schema11.items) && hasMaxItems && maxItems < schema11.items.length) {
+      schema11.items = schema11.items.slice(0, maxItems);
     }
-    return schema12;
+    return schema11;
   });
-  rules.set("Remove extends, if it is empty", (schema12) => {
-    if (!schema12.hasOwnProperty("extends")) {
+  rules.set("Remove extends, if it is empty", (schema11) => {
+    if (!schema11.hasOwnProperty("extends")) {
       return;
     }
-    if (schema12.extends == null || Array.isArray(schema12.extends) && schema12.extends.length === 0) {
-      delete schema12.extends;
+    if (schema11.extends == null || Array.isArray(schema11.extends) && schema11.extends.length === 0) {
+      delete schema11.extends;
     }
   });
-  rules.set("Make extends always an array, if it is defined", (schema12) => {
-    if (schema12.extends == null) {
+  rules.set("Make extends always an array, if it is defined", (schema11) => {
+    if (schema11.extends == null) {
       return;
     }
-    if (!Array.isArray(schema12.extends)) {
-      schema12.extends = [schema12.extends];
+    if (!Array.isArray(schema11.extends)) {
+      schema11.extends = [schema11.extends];
     }
   });
-  rules.set("Transform definitions to $defs", (schema12, fileName) => {
-    if (schema12.definitions && schema12.$defs && !(0, util_1.isDeepStrictEqual)(schema12.definitions, schema12.$defs)) {
-      throw ReferenceError(`Schema must define either definitions or $defs, not both. Given id=${schema12.id} in ${fileName}`);
+  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}`);
     }
-    if (schema12.definitions) {
-      schema12.$defs = schema12.definitions;
-      delete schema12.definitions;
+    if (schema11.definitions) {
+      schema11.$defs = schema11.definitions;
+      delete schema11.definitions;
     }
   });
-  rules.set("Transform const to singleton enum", (schema12) => {
-    if (schema12.const !== undefined) {
-      schema12.enum = [schema12.const];
-      delete schema12.const;
+  rules.set("Transform const to singleton enum", (schema11) => {
+    if (schema11.const !== undefined) {
+      schema11.enum = [schema11.const];
+      delete schema11.const;
     }
   });
-  rules.set("Add tsEnumNames to enum types", (schema12, _10, options8) => {
+  rules.set("Add tsEnumNames to enum types", (schema11, _10, options8) => {
     var _a7;
-    if (isEnumTypeWithoutTsEnumNames(schema12) && options8.inferStringEnumKeysFromValues) {
-      schema12.tsEnumNames = (_a7 = schema12.enum) === null || _a7 === undefined ? undefined : _a7.map(String);
+    if (isEnumTypeWithoutTsEnumNames(schema11) && options8.inferStringEnumKeysFromValues) {
+      schema11.tsEnumNames = (_a7 = schema11.enum) === null || _a7 === undefined ? undefined : _a7.map(String);
     }
   });
-  rules.set("Pre-calculate schema types and intersections", (schema12) => {
-    if (schema12 !== null && typeof schema12 === "object") {
-      (0, applySchemaTyping_1.applySchemaTyping)(schema12);
+  rules.set("Pre-calculate schema types and intersections", (schema11) => {
+    if (schema11 !== null && typeof schema11 === "object") {
+      (0, applySchemaTyping_1.applySchemaTyping)(schema11);
     }
   });
   function normalize2(rootSchema, dereferencedPaths, filename, options8) {
-    rules.forEach((rule) => (0, utils_1.traverse)(rootSchema, (schema12, key2) => rule(schema12, filename, options8, key2, dereferencedPaths)));
+    rules.forEach((rule) => (0, utils_1.traverse)(rootSchema, (schema11, key2) => rule(schema11, 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(schema12, options8, keyName, processed = new Map, usedNames = new Set) {
-    if ((0, JSONSchema_1.isPrimitive)(schema12)) {
-      if ((0, JSONSchema_1.isBoolean)(schema12)) {
-        return parseBooleanSchema(schema12, keyName, options8);
+  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);
       }
-      return parseLiteral(schema12, keyName);
+      return parseLiteral(schema11, keyName);
     }
-    const intersection2 = schema12[JSONSchema_1.Intersection];
-    const types = schema12[JSONSchema_1.Types];
+    const intersection2 = schema11[JSONSchema_1.Intersection];
+    const types = schema11[JSONSchema_1.Types];
     if (intersection2) {
       const ast = parseAsTypeWithCache(intersection2, "ALL_OF", options8, keyName, processed, usedNames);
       types.forEach((type) => {
-        ast.params.push(parseAsTypeWithCache(schema12, type, options8, keyName, processed, usedNames));
+        ast.params.push(parseAsTypeWithCache(schema11, type, options8, keyName, processed, usedNames));
       });
-      (0, utils_1.log)("blue", "parser", "Types:", [...types], "Input:", schema12, "Output:", ast);
+      (0, utils_1.log)("blue", "parser", "Types:", [...types], "Input:", schema11, "Output:", ast);
       return ast;
     }
     if (types.size === 1) {
       const type = [...types][0];
-      const ast = parseAsTypeWithCache(schema12, type, options8, keyName, processed, usedNames);
-      (0, utils_1.log)("blue", "parser", "Type:", type, "Input:", schema12, "Output:", ast);
+      const ast = parseAsTypeWithCache(schema11, type, options8, keyName, processed, usedNames);
+      (0, utils_1.log)("blue", "parser", "Type:", type, "Input:", schema11, "Output:", ast);
       return ast;
     }
     throw new ReferenceError("Expected intersection schema. Please file an issue on GitHub.");
   }
   exports.parse = parse11;
-  function parseAsTypeWithCache(schema12, type, options8, keyName, processed = new Map, usedNames = new Set) {
-    let cachedTypeMap = processed.get(schema12);
+  function parseAsTypeWithCache(schema11, type, options8, keyName, processed = new Map, usedNames = new Set) {
+    let cachedTypeMap = processed.get(schema11);
     if (!cachedTypeMap) {
       cachedTypeMap = new Map;
-      processed.set(schema12, cachedTypeMap);
+      processed.set(schema11, 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(schema12, type, options8, keyName, processed, usedNames));
+    return Object.assign(ast, parseNonLiteral(schema11, type, options8, keyName, processed, usedNames));
   }
-  function parseBooleanSchema(schema12, keyName, options8) {
-    if (schema12) {
+  function parseBooleanSchema(schema11, keyName, options8) {
+    if (schema11) {
       return {
         keyName,
         type: options8.unknownAny ? "UNKNOWN" : "ANY"
@@ -142224,157 +142224,157 @@ var require_parser2 = __commonJS((exports) => {
       type: "NEVER"
     };
   }
-  function parseLiteral(schema12, keyName) {
+  function parseLiteral(schema11, keyName) {
     return {
       keyName,
-      params: schema12,
+      params: schema11,
       type: "LITERAL"
     };
   }
-  function parseNonLiteral(schema12, type, options8, keyName, processed, usedNames) {
-    const definitions = getDefinitionsMemoized((0, JSONSchema_1.getRootSchema)(schema12));
-    const keyNameFromDefinition = (0, lodash_1.findKey)(definitions, (_10) => _10 === schema12);
+  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);
     switch (type) {
       case "ALL_OF":
         return {
-          comment: schema12.description,
-          deprecated: schema12.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
-          params: schema12.allOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
+          params: schema11.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: schema12.description, deprecated: schema12.deprecated, keyName, standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8) });
+        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) });
       case "ANY_OF":
         return {
-          comment: schema12.description,
-          deprecated: schema12.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
-          params: schema12.anyOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
+          params: schema11.anyOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
           type: "UNION"
         };
       case "BOOLEAN":
         return {
-          comment: schema12.description,
-          deprecated: schema12.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
           type: "BOOLEAN"
         };
       case "CUSTOM_TYPE":
         return {
-          comment: schema12.description,
-          deprecated: schema12.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          params: schema12.tsType,
-          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
+          params: schema11.tsType,
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
           type: "CUSTOM_TYPE"
         };
       case "NAMED_ENUM":
         return {
-          comment: schema12.description,
-          deprecated: schema12.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema12, keyNameFromDefinition !== null && keyNameFromDefinition !== undefined ? keyNameFromDefinition : keyName, usedNames, options8),
-          params: schema12.enum.map((_10, n5) => ({
+          standaloneName: standaloneName(schema11, keyNameFromDefinition !== null && keyNameFromDefinition !== undefined ? keyNameFromDefinition : keyName, usedNames, options8),
+          params: schema11.enum.map((_10, n5) => ({
             ast: parseLiteral(_10, undefined),
-            keyName: schema12.tsEnumNames[n5]
+            keyName: schema11.tsEnumNames[n5]
           })),
           type: "ENUM"
         };
       case "NAMED_SCHEMA":
-        return newInterface(schema12, options8, processed, usedNames, keyName);
+        return newInterface(schema11, options8, processed, usedNames, keyName);
       case "NEVER":
         return {
-          comment: schema12.description,
-          deprecated: schema12.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
           type: "NEVER"
         };
       case "NULL":
         return {
-          comment: schema12.description,
-          deprecated: schema12.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
           type: "NULL"
         };
       case "NUMBER":
         return {
-          comment: schema12.description,
-          deprecated: schema12.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
           type: "NUMBER"
         };
       case "OBJECT":
         return {
-          comment: schema12.description,
+          comment: schema11.description,
           keyName,
-          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
           type: "OBJECT",
-          deprecated: schema12.deprecated
+          deprecated: schema11.deprecated
         };
       case "ONE_OF":
         return {
-          comment: schema12.description,
-          deprecated: schema12.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
-          params: schema12.oneOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
+          params: schema11.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!", schema12));
+        throw Error((0, util_1.format)("Refs should have been resolved by the resolver!", schema11));
       case "STRING":
         return {
-          comment: schema12.description,
-          deprecated: schema12.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
           type: "STRING"
         };
       case "TYPED_ARRAY":
-        if (Array.isArray(schema12.items)) {
-          const minItems2 = schema12.minItems;
-          const maxItems2 = schema12.maxItems;
+        if (Array.isArray(schema11.items)) {
+          const minItems2 = schema11.minItems;
+          const maxItems2 = schema11.maxItems;
           const arrayType = {
-            comment: schema12.description,
-            deprecated: schema12.deprecated,
+            comment: schema11.description,
+            deprecated: schema11.deprecated,
             keyName,
             maxItems: maxItems2,
             minItems: minItems2,
-            standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
-            params: schema12.items.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
+            standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
+            params: schema11.items.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
             type: "TUPLE"
           };
-          if (schema12.additionalItems === true) {
+          if (schema11.additionalItems === true) {
             arrayType.spreadParam = options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY;
-          } else if (schema12.additionalItems) {
-            arrayType.spreadParam = parse11(schema12.additionalItems, options8, undefined, processed, usedNames);
+          } else if (schema11.additionalItems) {
+            arrayType.spreadParam = parse11(schema11.additionalItems, options8, undefined, processed, usedNames);
           }
           return arrayType;
         } else {
           return {
-            comment: schema12.description,
-            deprecated: schema12.deprecated,
+            comment: schema11.description,
+            deprecated: schema11.deprecated,
             keyName,
-            standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
-            params: parse11(schema12.items, options8, `{keyNameFromDefinition}Items`, processed, usedNames),
+            standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
+            params: parse11(schema11.items, options8, `{keyNameFromDefinition}Items`, processed, usedNames),
             type: "ARRAY"
           };
         }
       case "UNION":
         return {
-          comment: schema12.description,
-          deprecated: schema12.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
-          params: schema12.type.map((type2) => {
-            const member = Object.assign(Object.assign({}, (0, lodash_1.omit)(schema12, "$id", "description", "title")), { type: type2 });
+          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 });
             (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: schema12.description,
-          deprecated: schema12.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
-          params: schema12.enum.map((_10) => parseLiteral(_10, undefined)),
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
+          params: schema11.enum.map((_10) => parseLiteral(_10, undefined)),
           type: "UNION"
         };
       case "UNNAMED_SCHEMA":
-        return newInterface(schema12, options8, processed, usedNames, keyName, keyNameFromDefinition);
+        return newInterface(schema11, options8, processed, usedNames, keyName, keyNameFromDefinition);
       case "UNTYPED_ARRAY":
-        const minItems = schema12.minItems;
-        const maxItems = typeof schema12.maxItems === "number" ? schema12.maxItems : -1;
+        const minItems = schema11.minItems;
+        const maxItems = typeof schema11.maxItems === "number" ? schema11.maxItems : -1;
         const params = options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY;
         if (minItems > 0 || maxItems >= 0) {
           return {
-            comment: schema12.description,
-            deprecated: schema12.deprecated,
+            comment: schema11.description,
+            deprecated: schema11.deprecated,
             keyName,
-            maxItems: schema12.maxItems,
+            maxItems: schema11.maxItems,
             minItems,
             params: Array(Math.max(maxItems, minItems) || 0).fill(params),
             spreadParam: maxItems >= 0 ? undefined : params,
-            standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
+            standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
             type: "TUPLE"
           };
         }
         return {
-          comment: schema12.description,
-          deprecated: schema12.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
           params,
-          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
           type: "ARRAY"
         };
     }
   }
-  function standaloneName(schema12, keyNameFromDefinition, usedNames, options8) {
+  function standaloneName(schema11, keyNameFromDefinition, usedNames, options8) {
     var _a7;
-    const name2 = ((_a7 = options8.customName) === null || _a7 === undefined ? undefined : _a7.call(options8, schema12, keyNameFromDefinition)) || schema12.title || schema12.$id || keyNameFromDefinition;
+    const name2 = ((_a7 = options8.customName) === null || _a7 === undefined ? undefined : _a7.call(options8, schema11, keyNameFromDefinition)) || schema11.title || schema11.$id || keyNameFromDefinition;
     if (name2) {
       return (0, utils_1.generateName)(name2, usedNames);
     }
   }
-  function newInterface(schema12, options8, processed, usedNames, keyName, keyNameFromDefinition) {
-    const name2 = standaloneName(schema12, keyNameFromDefinition, usedNames, options8);
+  function newInterface(schema11, options8, processed, usedNames, keyName, keyNameFromDefinition) {
+    const name2 = standaloneName(schema11, keyNameFromDefinition, usedNames, options8);
     return {
-      comment: schema12.description,
-      deprecated: schema12.deprecated,
+      comment: schema11.description,
+      deprecated: schema11.deprecated,
       keyName,
-      params: parseSchema(schema12, options8, processed, usedNames, name2),
+      params: parseSchema(schema11, options8, processed, usedNames, name2),
       standaloneName: name2,
-      superTypes: parseSuperTypes(schema12, options8, processed, usedNames),
+      superTypes: parseSuperTypes(schema11, options8, processed, usedNames),
       type: "INTERFACE"
     };
   }
-  function parseSuperTypes(schema12, options8, processed, usedNames) {
-    const superTypes = schema12.extends;
+  function parseSuperTypes(schema11, options8, processed, usedNames) {
+    const superTypes = schema11.extends;
     if (!superTypes) {
       return [];
     }
     return superTypes.map((_10) => parse11(_10, options8, undefined, processed, usedNames));
   }
-  function parseSchema(schema12, options8, processed, usedNames, parentSchemaName) {
-    let asts = (0, lodash_1.map)(schema12.properties, (value, key2) => ({
+  function parseSchema(schema11, options8, processed, usedNames, parentSchemaName) {
+    let asts = (0, lodash_1.map)(schema11.properties, (value, key2) => ({
       ast: parse11(value, options8, key2, processed, usedNames),
       isPatternProperty: false,
-      isRequired: (0, lodash_1.includes)(schema12.required || [], key2),
+      isRequired: (0, lodash_1.includes)(schema11.required || [], key2),
       isUnreachableDefinition: false,
       keyName: key2
     }));
     let singlePatternProperty = false;
-    if (schema12.patternProperties) {
-      singlePatternProperty = !schema12.additionalProperties && Object.keys(schema12.patternProperties).length === 1;
-      asts = asts.concat((0, lodash_1.map)(schema12.patternProperties, (value, key2) => {
+    if (schema11.patternProperties) {
+      singlePatternProperty = !schema11.additionalProperties && Object.keys(schema11.patternProperties).length === 1;
+      asts = asts.concat((0, lodash_1.map)(schema11.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)(schema12.required || [], key2),
+          isRequired: singlePatternProperty || (0, lodash_1.includes)(schema11.required || [], key2),
           isUnreachableDefinition: false,
           keyName: singlePatternProperty ? "[k: string]" : key2
         };
       }));
     }
     if (options8.unreachableDefinitions) {
-      asts = asts.concat((0, lodash_1.map)(schema12.$defs, (value, key2) => {
+      asts = asts.concat((0, lodash_1.map)(schema11.$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)(schema12.required || [], key2),
+          isRequired: (0, lodash_1.includes)(schema11.required || [], key2),
           isUnreachableDefinition: true,
           keyName: key2
         };
       }));
     }
-    switch (schema12.additionalProperties) {
+    switch (schema11.additionalProperties) {
       case undefined:
       case true:
         if (singlePatternProperty) {
@@ -142506,7 +142506,7 @@ ${comment}` : comment;
         return asts;
       default:
         return asts.concat({
-          ast: parse11(schema12.additionalProperties, options8, "[k: string]", processed, usedNames),
+          ast: parse11(schema11.additionalProperties, options8, "[k: string]", processed, usedNames),
           isPatternProperty: false,
           isRequired: true,
           isUnreachableDefinition: false,
@@ -142514,22 +142514,22 @@ ${comment}` : comment;
         });
     }
   }
-  function getDefinitions(schema12, isSchema = true, processed = new Set) {
-    if (processed.has(schema12)) {
+  function getDefinitions(schema11, isSchema = true, processed = new Set) {
+    if (processed.has(schema11)) {
       return {};
     }
-    processed.add(schema12);
-    if (Array.isArray(schema12)) {
-      return schema12.reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(cur, false, processed)), {});
+    processed.add(schema11);
+    if (Array.isArray(schema11)) {
+      return schema11.reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(cur, false, processed)), {});
     }
-    if ((0, lodash_1.isPlainObject)(schema12)) {
-      return Object.assign(Object.assign({}, isSchema && hasDefinitions(schema12) ? schema12.$defs : {}), Object.keys(schema12).reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(schema12[cur], false, processed)), {}));
+    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)), {}));
     }
     return {};
   }
   var getDefinitionsMemoized = (0, lodash_1.memoize)(getDefinitions);
-  function hasDefinitions(schema12) {
-    return "$defs" in schema12;
+  function hasDefinitions(schema11) {
+    return "$defs" in schema11;
   }
 });
 
@@ -144353,7 +144353,7 @@ var require_normalize_args = __commonJS((exports) => {
   var options_js_1 = require_options();
   function normalizeArgs(_args) {
     let path18;
-    let schema12;
+    let schema11;
     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") {
-        schema12 = args[1];
+        schema11 = args[1];
         options8 = args[2];
       } else {
-        schema12 = undefined;
+        schema11 = undefined;
         options8 = args[1];
       }
     } else {
       path18 = "";
-      schema12 = args[0];
+      schema11 = 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 schema12 === "object") {
-      schema12 = JSON.parse(JSON.stringify(schema12));
+    if (!options8.mutateInputSchema && typeof schema11 === "object") {
+      schema11 = JSON.parse(JSON.stringify(schema11));
     }
     return {
       path: path18,
-      schema: schema12,
+      schema: schema11,
       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* (schema12, { cwd, $refOptions }) {
-      (0, utils_1.log)("green", "dereferencer", "Dereferencing input schema:", cwd, schema12);
+    return __awaiter(this, arguments, undefined, function* (schema11, { cwd, $refOptions }) {
+      (0, utils_1.log)("green", "dereferencer", "Dereferencing input schema:", cwd, schema11);
       const parser2 = new json_schema_ref_parser_1.$RefParser;
       const dereferencedPaths = new WeakMap;
-      const dereferencedSchema = yield parser2.dereference(cwd, schema12, Object.assign(Object.assign({}, $refOptions), { dereference: Object.assign(Object.assign({}, $refOptions.dereference), { onDereference($ref, schema13) {
-        dereferencedPaths.set(schema13, $ref);
+      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);
       } }) }));
       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", (schema12) => {
-    if (schema12.enum && schema12.tsEnumNames && schema12.enum.length !== schema12.tsEnumNames.length) {
+  rules.set("Enum members and tsEnumNames must be of the same length", (schema11) => {
+    if (schema11.enum && schema11.tsEnumNames && schema11.enum.length !== schema11.tsEnumNames.length) {
       return false;
     }
   });
-  rules.set("tsEnumNames must be an array of strings", (schema12) => {
-    if (schema12.tsEnumNames && schema12.tsEnumNames.some((_10) => typeof _10 !== "string")) {
+  rules.set("tsEnumNames must be an array of strings", (schema11) => {
+    if (schema11.tsEnumNames && schema11.tsEnumNames.some((_10) => typeof _10 !== "string")) {
       return false;
     }
   });
-  rules.set("When both maxItems and minItems are present, maxItems >= minItems", (schema12) => {
-    const { maxItems, minItems } = schema12;
+  rules.set("When both maxItems and minItems are present, maxItems >= minItems", (schema11) => {
+    const { maxItems, minItems } = schema11;
     if (typeof maxItems === "number" && typeof minItems === "number") {
       return maxItems >= minItems;
     }
   });
-  rules.set("When maxItems exists, maxItems >= 0", (schema12) => {
-    const { maxItems } = schema12;
+  rules.set("When maxItems exists, maxItems >= 0", (schema11) => {
+    const { maxItems } = schema11;
     if (typeof maxItems === "number") {
       return maxItems >= 0;
     }
   });
-  rules.set("When minItems exists, minItems >= 0", (schema12) => {
-    const { minItems } = schema12;
+  rules.set("When minItems exists, minItems >= 0", (schema11) => {
+    const { minItems } = schema11;
     if (typeof minItems === "number") {
       return minItems >= 0;
     }
   });
-  rules.set("deprecated must be a boolean", (schema12) => {
-    const typeOfDeprecated = typeof schema12.deprecated;
+  rules.set("deprecated must be a boolean", (schema11) => {
+    const typeOfDeprecated = typeof schema11.deprecated;
     return typeOfDeprecated === "boolean" || typeOfDeprecated === "undefined";
   });
-  function validate2(schema12, filename) {
+  function validate2(schema11, filename) {
     const errors5 = [];
     rules.forEach((rule, ruleName) => {
-      (0, utils_1.traverse)(schema12, (schema13, key2) => {
-        if (rule(schema13) === false) {
+      (0, utils_1.traverse)(schema11, (schema12, key2) => {
+        if (rule(schema12) === false) {
           errors5.push(`Error at key "${key2}" in file "${filename}": ${ruleName}`);
         }
-        return schema13;
+        return schema12;
       });
     });
     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(schema12, parent = null) {
-    if (!Array.isArray(schema12) && !(0, lodash_1.isPlainObject)(schema12)) {
-      return schema12;
+  function link2(schema11, parent = null) {
+    if (!Array.isArray(schema11) && !(0, lodash_1.isPlainObject)(schema11)) {
+      return schema11;
     }
-    if (schema12.hasOwnProperty(JSONSchema_1.Parent)) {
-      return schema12;
+    if (schema11.hasOwnProperty(JSONSchema_1.Parent)) {
+      return schema11;
     }
-    Object.defineProperty(schema12, JSONSchema_1.Parent, {
+    Object.defineProperty(schema11, JSONSchema_1.Parent, {
       enumerable: false,
       value: parent,
       writable: false
     });
-    if (Array.isArray(schema12)) {
-      schema12.forEach((child) => link2(child, schema12));
+    if (Array.isArray(schema11)) {
+      schema11.forEach((child) => link2(child, schema11));
     }
-    for (const key2 in schema12) {
-      link2(schema12[key2], schema12);
+    for (const key2 in schema11) {
+      link2(schema11[key2], schema11);
     }
-    return schema12;
+    return schema11;
   }
   exports.link = link2;
 });
@@ -145355,8 +145355,8 @@ var require_src3 = __commonJS((exports) => {
     unknownAny: true
   };
   function compileFromFile(filename, options8 = exports.DEFAULT_OPTIONS) {
-    const schema12 = parseAsJSONSchema(filename);
-    return compile(schema12, (0, utils_1.stripExtension)(filename), Object.assign({ cwd: (0, path_1.dirname)(filename) }, options8));
+    const schema11 = parseAsJSONSchema(filename);
+    return compile(schema11, (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* (schema12, name2, options8 = {}) {
+    return __awaiter(this, arguments, undefined, function* (schema11, 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)(schema12);
+      const _schema = (0, lodash_1.cloneDeep)(schema11);
       const { dereferencedPaths, dereferencedSchema } = yield (0, resolver_1.dereference)(_schema, _options);
       if (process.env.VERBOSE) {
         if ((0, util_1.isDeepStrictEqual)(_schema, dereferencedSchema)) {
@@ -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 dirname20 = path18.dirname;
+  var dirname19 = path18.dirname;
   var basename6 = path18.basename;
   var extname2 = path18.extname;
-  var join27 = path18.join;
+  var join25 = path18.join;
   var resolve13 = path18.resolve;
   module.exports = View;
   function View(name2, options8) {
@@ -163983,7 +163983,7 @@ var require_view = __commonJS((exports, module) => {
     for (var i5 = 0;i5 < roots.length && !path19; i5++) {
       var root2 = roots[i5];
       var loc = resolve13(root2, name2);
-      var dir = dirname20(loc);
+      var dir = dirname19(loc);
       var file2 = basename6(loc);
       path19 = this.resolve(dir, file2);
     }
@@ -164009,12 +164009,12 @@ var require_view = __commonJS((exports, module) => {
   };
   View.prototype.resolve = function resolve14(dir, file2) {
     var ext = this.ext;
-    var path19 = join27(dir, file2);
+    var path19 = join25(dir, file2);
     var stat2 = tryStat(path19);
     if (stat2 && stat2.isFile()) {
       return path19;
     }
-    path19 = join27(dir, basename6(file2, ext), "index" + ext);
+    path19 = join25(dir, basename6(file2, ext), "index" + ext);
     stat2 = tryStat(path19);
     if (stat2 && stat2.isFile()) {
       return path19;
@@ -167709,7 +167709,7 @@ var require_send = __commonJS((exports, module) => {
   var Stream2 = __require("stream");
   var util2 = __require("util");
   var extname2 = path18.extname;
-  var join27 = path18.join;
+  var join25 = path18.join;
   var normalize2 = path18.normalize;
   var resolve13 = path18.resolve;
   var sep = path18.sep;
@@ -167881,7 +167881,7 @@ var require_send = __commonJS((exports, module) => {
         return res;
       }
       parts = path19.split(sep);
-      path19 = normalize2(join27(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 = join27(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;
       }
@@ -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") {
@@ -213884,7 +213884,7 @@ var require_parse_path = __commonJS((exports, module) => {
   var reFirstKey = /^[^\[]*/;
   var reDigitPath = /^\[(\d+)\]/;
   var reNormalPath = /^\[([^\]]+)\]/;
-  function parsePath(key2) {
+  function parsePath2(key2) {
     function failure() {
       return [{ type: "object", key: key2, last: true }];
     }
@@ -213925,7 +213925,7 @@ var require_parse_path = __commonJS((exports, module) => {
     tail.last = true;
     return steps;
   }
-  module.exports = parsePath;
+  module.exports = parsePath2;
 });
 
 // ../../node_modules/append-field/lib/set-value.js
@@ -213996,10 +213996,10 @@ var require_set_value = __commonJS((exports, module) => {
 
 // ../../node_modules/append-field/index.js
 var require_append_field = __commonJS((exports, module) => {
-  var parsePath = require_parse_path();
+  var parsePath2 = require_parse_path();
   var setValue = require_set_value();
   function appendField(store, key2, value) {
-    var steps = parsePath(key2);
+    var steps = parsePath2(key2);
     steps.reduce(function(context, step) {
       return setValue(context, step, context[step.key], value);
     }, store);
@@ -218205,7 +218205,7 @@ var require_dist5 = __commonJS((exports, module) => {
   });
   module.exports = __toCommonJS(src_exports);
   var import_promises22 = __require("node:fs/promises");
-  var import_node_fs23 = __require("node:fs");
+  var import_node_fs24 = __require("node:fs");
   var DEVIN_LOCAL_PATH = "/opt/.devin";
   var CURSOR2 = "cursor";
   var CURSOR_CLI = "cursor-cli";
@@ -218262,7 +218262,7 @@ var require_dist5 = __commonJS((exports, module) => {
       return { isAgent: true, agent: { name: REPLIT } };
     }
     try {
-      await (0, import_promises22.access)(DEVIN_LOCAL_PATH, import_node_fs23.constants.F_OK);
+      await (0, import_promises22.access)(DEVIN_LOCAL_PATH, import_node_fs24.constants.F_OK);
       return { isAgent: true, agent: { name: DEVIN } };
     } catch (error48) {}
     return { isAgent: false, agent: undefined };
@@ -234033,7 +234033,7 @@ function normalizeBase44Env() {
 loadProjectEnvFiles();
 
 // src/cli/index.ts
-import { dirname as dirname24, join as join30 } from "node:path";
+import { dirname as dirname25, join as join30 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 
 // ../../node_modules/@clack/core/dist/index.mjs
@@ -235240,8 +235240,8 @@ var {
   Help
 } = import__.default;
 
-// src/cli/commands/agent-skills/pull.ts
-import { dirname as dirname10, join as join15 } from "node:path";
+// src/cli/commands/agents/pull.ts
+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`;
@@ -236056,7 +236056,6 @@ var ProjectConfigSchema = exports_external.object({
   entitiesDir: exports_external.string().optional().default("entities"),
   functionsDir: exports_external.string().optional().default("functions"),
   agentsDir: exports_external.string().optional().default("agents"),
-  agentSkillsDir: exports_external.string().optional().default("agent-skills"),
   connectorsDir: exports_external.string().optional().default("connectors"),
   authDir: exports_external.string().optional().default("auth"),
   plugin: PluginMetadataSchema.optional(),
@@ -241966,7 +241965,7 @@ async function getSiteUrl() {
   return result.data.url;
 }
 // src/core/project/config.ts
-import { dirname as dirname8, join as join11 } 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";
@@ -242029,7 +242028,6 @@ var AgentConfigSchema = exports_external.looseObject({
   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([]),
-  selected_skill_names: exports_external.array(exports_external.string()).optional().default([]),
   memory_config: MemoryConfigSchema.optional(),
   whatsapp_greeting: exports_external.string().nullable().optional()
 });
@@ -242173,145 +242171,6 @@ var agentResource = {
   readAll: readAllAgents,
   push: pushAgents
 };
-// src/core/resources/agent-skill/schema.ts
-var SKILL_NAME_REGEX = /^[a-z0-9]+(-[a-z0-9]+)*$/;
-var AgentSkillSchema = exports_external.object({
-  name: exports_external.string().trim().min(1).max(64).regex(SKILL_NAME_REGEX, "Skill name must be lowercase-hyphenated (a-z, 0-9, -)"),
-  description: exports_external.string().trim().min(1, "Description is required").max(1024),
-  body: exports_external.string().trim().min(1, "Body is required").max(15000)
-});
-var AgentSkillApiResponseSchema = exports_external.object({
-  name: exports_external.string(),
-  description: exports_external.string(),
-  body: exports_external.string()
-});
-var ListAgentSkillsResponseSchema = exports_external.object({
-  items: exports_external.array(AgentSkillApiResponseSchema),
-  total: exports_external.number()
-});
-var SyncAgentSkillsResultSchema = exports_external.object({
-  created: exports_external.array(exports_external.string()),
-  updated: exports_external.array(exports_external.string()),
-  deleted: exports_external.array(exports_external.string())
-});
-
-// src/core/resources/agent-skill/api.ts
-async function fetchAgentSkills() {
-  const appClient = getAppClient();
-  let response;
-  try {
-    response = await appClient.get("agent-skills");
-  } catch (error48) {
-    throw await ApiError.fromHttpError(error48, "fetching agent skills");
-  }
-  const result = ListAgentSkillsResponseSchema.safeParse(await response.json());
-  if (!result.success) {
-    throw new SchemaValidationError("Invalid response from server", result.error);
-  }
-  return result.data;
-}
-async function pushAgentSkills(skills) {
-  if (skills.length === 0) {
-    return { created: [], updated: [], deleted: [] };
-  }
-  const appClient = getAppClient();
-  const remote = await fetchAgentSkills();
-  const remoteByName = new Map(remote.items.map((s) => [s.name, s]));
-  const localNames = new Set(skills.map((s) => s.name));
-  const created = [];
-  const updated = [];
-  const deleted = [];
-  try {
-    for (const skill of skills) {
-      const prev = remoteByName.get(skill.name);
-      if (!prev) {
-        await appClient.post("agent-skills", { json: skill });
-        created.push(skill.name);
-      } else if (prev.description !== skill.description || prev.body !== skill.body) {
-        await appClient.put(`agent-skills/${skill.name}`, {
-          json: { description: skill.description, body: skill.body }
-        });
-        updated.push(skill.name);
-      }
-    }
-    for (const remoteSkill of remote.items) {
-      if (!localNames.has(remoteSkill.name)) {
-        await appClient.delete(`agent-skills/${remoteSkill.name}`);
-        deleted.push(remoteSkill.name);
-      }
-    }
-  } catch (error48) {
-    throw await ApiError.fromHttpError(error48, "syncing agent skills");
-  }
-  return { created, updated, deleted };
-}
-// src/core/resources/agent-skill/config.ts
-import { join as join6 } from "node:path";
-function parseSkillFile(raw2) {
-  const match = raw2.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
-  if (!match) {
-    return { description: "", body: raw2.trim() };
-  }
-  const [, frontmatter, body] = match;
-  let description = "";
-  for (const line of frontmatter.split(/\r?\n/)) {
-    const kv = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
-    if (kv && kv[1] === "description") {
-      description = kv[2].trim().replace(/^["']|["']$/g, "");
-    }
-  }
-  return { description, body: body.trim() };
-}
-function serializeSkillFile(skill) {
-  return `---
-description: ${skill.description}
----
-
-${skill.body}
-`;
-}
-async function readAllAgentSkills(dir) {
-  if (!await pathExists(dir)) {
-    return [];
-  }
-  const files = await globby("*.md", { cwd: dir, absolute: true });
-  return await Promise.all(files.map(async (filePath) => {
-    const name2 = filePath.split(/[/\\]/).pop()?.replace(/\.md$/, "") ?? "";
-    const { description, body } = parseSkillFile(await readTextFile(filePath));
-    const result = AgentSkillSchema.safeParse({ name: name2, description, body });
-    if (!result.success) {
-      throw new SchemaValidationError("Invalid skill file", result.error, filePath);
-    }
-    return result.data;
-  }));
-}
-async function writeAgentSkills(dir, remote) {
-  const existing = await readAllAgentSkills(dir);
-  const remoteNames = new Set(remote.map((s) => s.name));
-  const deleted = [];
-  for (const skill of existing) {
-    if (!remoteNames.has(skill.name)) {
-      await deleteFile(join6(dir, `${skill.name}.md`));
-      deleted.push(skill.name);
-    }
-  }
-  const existingByName = new Map(existing.map((s) => [s.name, s]));
-  const written = [];
-  for (const skill of remote) {
-    const prev = existingByName.get(skill.name);
-    if (prev && prev.description === skill.description && prev.body === skill.body) {
-      continue;
-    }
-    await writeFile(join6(dir, `${skill.name}.md`), serializeSkillFile(skill));
-    written.push(skill.name);
-  }
-  return { written, deleted };
-}
-// src/core/resources/agent-skill/resource.ts
-var agentSkillResource = {
-  readAll: readAllAgentSkills,
-  push: pushAgentSkills
-};
 // src/core/resources/auth-config/schema.ts
 var GoogleOAuthMode = exports_external.enum(["default", "custom"]);
 var AuthConfigSchema = exports_external.object({
@@ -242354,8 +242213,8 @@ var AppAuthConfigResponseSchema = exports_external.object({
 }).transform((data) => ({
   authConfig: data.auth_config
 }));
-function hasAnyLoginMethod(config5) {
-  return config5.enableUsernamePassword || config5.enableGoogleLogin || config5.enableMicrosoftLogin || config5.enableFacebookLogin || config5.enableAppleLogin || config5.enableSSOLogin;
+function hasAnyLoginMethod(config4) {
+  return config4.enableUsernamePassword || config4.enableGoogleLogin || config4.enableMicrosoftLogin || config4.enableFacebookLogin || config4.enableAppleLogin || config4.enableSSOLogin;
 }
 var SOCIAL_PROVIDERS = {
   google: {
@@ -242370,18 +242229,18 @@ var SOCIAL_PROVIDERS = {
   facebook: { field: "enableFacebookLogin" },
   apple: { field: "enableAppleLogin" }
 };
-function toAuthConfigPayload(config5) {
+function toAuthConfigPayload(config4) {
   return {
-    enable_username_password: config5.enableUsernamePassword,
-    enable_google_login: config5.enableGoogleLogin,
-    enable_microsoft_login: config5.enableMicrosoftLogin,
-    enable_facebook_login: config5.enableFacebookLogin,
-    enable_apple_login: config5.enableAppleLogin,
-    sso_provider_name: config5.ssoProviderName,
-    enable_sso_login: config5.enableSSOLogin,
-    google_oauth_mode: config5.googleOAuthMode,
-    google_oauth_client_id: config5.googleOAuthClientId,
-    use_workspace_sso: config5.useWorkspaceSSO
+    enable_username_password: config4.enableUsernamePassword,
+    enable_google_login: config4.enableGoogleLogin,
+    enable_microsoft_login: config4.enableMicrosoftLogin,
+    enable_facebook_login: config4.enableFacebookLogin,
+    enable_apple_login: config4.enableAppleLogin,
+    sso_provider_name: config4.ssoProviderName,
+    enable_sso_login: config4.enableSSOLogin,
+    google_oauth_mode: config4.googleOAuthMode,
+    google_oauth_client_id: config4.googleOAuthClientId,
+    use_workspace_sso: config4.useWorkspaceSSO
   };
 }
 
@@ -242400,9 +242259,9 @@ async function getAuthConfig() {
   }
   return result.data.authConfig;
 }
-async function pushAuthConfigToApi(config5) {
+async function pushAuthConfigToApi(config4) {
   const { id } = getAppContext();
-  const payload = toAuthConfigPayload(config5);
+  const payload = toAuthConfigPayload(config4);
   if (hasWorkspaceApiKeyAuth()) {
     try {
       await base44Client.put(`api/apps/${id}/deployment/auth-configuration`, {
@@ -242411,7 +242270,7 @@ async function pushAuthConfigToApi(config5) {
     } catch (error48) {
       throw await ApiError.fromHttpError(error48, "updating auth config");
     }
-    return config5;
+    return config4;
   }
   let response;
   try {
@@ -242428,7 +242287,7 @@ async function pushAuthConfigToApi(config5) {
   return result.data.authConfig;
 }
 // src/core/resources/auth-config/config.ts
-import { join as join7 } from "node:path";
+import { join as join6 } from "node:path";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "node:util";
 var AUTH_CONFIG_FILENAME = `config.${CONFIG_FILE_EXTENSION}`;
 var DEFAULT_AUTH_CONFIG = {
@@ -242444,7 +242303,7 @@ var DEFAULT_AUTH_CONFIG = {
   useWorkspaceSSO: false
 };
 function getAuthConfigPath(authDir) {
-  return join7(authDir, AUTH_CONFIG_FILENAME);
+  return join6(authDir, AUTH_CONFIG_FILENAME);
 }
 async function readAuthConfig(authDir) {
   const filePath = getAuthConfigPath(authDir);
@@ -242458,16 +242317,16 @@ async function readAuthConfig(authDir) {
   }
   return result.data;
 }
-async function writeAuthConfig(authDir, config5) {
+async function writeAuthConfig(authDir, config4) {
   const filePath = getAuthConfigPath(authDir);
   if (await pathExists(filePath)) {
     const existing = await readJsonFile(filePath);
     const existingResult = AuthConfigFileSchema.safeParse(existing);
-    if (existingResult.success && isDeepStrictEqual2(existingResult.data, config5)) {
+    if (existingResult.success && isDeepStrictEqual2(existingResult.data, config4)) {
       return { written: false };
     }
   }
-  await writeJsonFile(filePath, config5);
+  await writeJsonFile(filePath, config4);
   return { written: true };
 }
 // src/core/resources/auth-config/pull.ts
@@ -242475,17 +242334,17 @@ async function pullAuthConfig() {
   return await getAuthConfig();
 }
 // src/core/resources/auth-config/push.ts
-async function pushAuthConfig(config5) {
-  if (!config5) {
+async function pushAuthConfig(config4) {
+  if (!config4) {
     return;
   }
-  await pushAuthConfigToApi(config5);
+  await pushAuthConfigToApi(config4);
 }
 // src/core/resources/auth-config/resource.ts
 var authConfigResource = {
   readAll: async (dir) => {
-    const config5 = await readAuthConfig(dir);
-    return config5 ? [config5] : [];
+    const config4 = await readAuthConfig(dir);
+    return config4 ? [config4] : [];
   },
   push: async (items) => {
     await pushAuthConfig(items[0] ?? null);
@@ -242725,7 +242584,7 @@ class MissingSSOFieldsError extends InvalidInputError {
   }
 }
 function buildSSOSecrets(provider, options) {
-  const schema4 = SSO_PROVIDER_SCHEMAS[provider];
+  const schema3 = SSO_PROVIDER_SCHEMAS[provider];
   const secrets = {};
   secrets["sso_name" /* Name */] = options.ssoName ?? provider;
   secrets["sso_client_id" /* ClientId */] = options.clientId;
@@ -242736,21 +242595,21 @@ function buildSSOSecrets(provider, options) {
       secrets[secretKey] = value;
     }
   }
-  if (schema4.deriveDefaults) {
-    const derived = schema4.deriveDefaults(secrets);
+  if (schema3.deriveDefaults) {
+    const derived = schema3.deriveDefaults(secrets);
     for (const [key, val] of Object.entries(derived)) {
       if (!secrets[key]) {
         secrets[key] = val;
       }
     }
   }
-  for (const [key, val] of Object.entries(schema4.defaults)) {
+  for (const [key, val] of Object.entries(schema3.defaults)) {
     if (!secrets[key]) {
       secrets[key] = val;
     }
   }
   const missing = [];
-  for (const key of schema4.requiredKeys) {
+  for (const key of schema3.requiredKeys) {
     if (!secrets[key]) {
       missing.push(key);
     }
@@ -243096,7 +242955,7 @@ async function removeStripe() {
   return result.data;
 }
 // src/core/resources/connector/config.ts
-import { join as join8 } from "node:path";
+import { join as join7 } from "node:path";
 import { isDeepStrictEqual as isDeepStrictEqual3 } from "node:util";
 async function readConnectorFile(connectorPath) {
   const parsed = await readJsonFile(connectorPath);
@@ -243157,7 +243016,7 @@ async function writeConnectors(connectorsDir, remoteConnectors) {
     if (existing && isDeepStrictEqual3(existing.data, connector)) {
       continue;
     }
-    const filePath = existing?.filePath ?? join8(connectorsDir, `${connector.type}.${CONFIG_FILE_EXTENSION}`);
+    const filePath = existing?.filePath ?? join7(connectorsDir, `${connector.type}.${CONFIG_FILE_EXTENSION}`);
     await writeJsonFile(filePath, connector);
     written.push(connector.type);
   }
@@ -243759,7 +243618,7 @@ async function fetchFunctionLogs(functionName, filters = {}) {
   return result.data;
 }
 // src/core/resources/function/config.ts
-import { basename as basename3, dirname as dirname6, join as join9, relative, resolve as resolve2 } from "node:path";
+import { basename as basename3, dirname as dirname6, join as join8, relative, resolve as resolve2 } from "node:path";
 async function readSharedFiles(functionsDir) {
   const sharedDir = resolve2(functionsDir, "..", "shared");
   if (!await pathExists(sharedDir)) {
@@ -243776,9 +243635,9 @@ async function readFunctionConfig(configPath) {
   return result.data;
 }
 async function readFunction(configPath, sharedFiles) {
-  const config8 = await readFunctionConfig(configPath);
+  const config7 = await readFunctionConfig(configPath);
   const functionDir = dirname6(configPath);
-  const entryPath = join9(functionDir, config8.entry);
+  const entryPath = join8(functionDir, config7.entry);
   if (!await pathExists(entryPath)) {
     throw new InvalidInputError(`Function entry file not found: ${entryPath} (referenced in ${configPath})`, {
       hints: [{ message: "Check the 'entry' field in your function config" }]
@@ -243790,7 +243649,7 @@ async function readFunction(configPath, sharedFiles) {
   });
   const allFilePaths = [...new Set([...filePaths, ...sharedFiles])];
   const functionData = {
-    ...config8,
+    ...config7,
     entryPath,
     filePaths: allFilePaths,
     source: { type: "project" }
@@ -243927,28 +243786,28 @@ async function pruneRemovedFunctions(localFunctionNames, options) {
   return results;
 }
 // src/core/resources/function/pull.ts
-import { join as join10 } from "node:path";
+import { join as join9 } from "node:path";
 import { isDeepStrictEqual as isDeepStrictEqual4 } from "node:util";
 async function writeFunctions(functionsDir, functions) {
   const written = [];
   const skipped = [];
   for (const fn of functions) {
-    const functionDir = join10(functionsDir, fn.name);
-    const configPath = join10(functionDir, "function.jsonc");
+    const functionDir = join9(functionsDir, fn.name);
+    const configPath = join9(functionDir, "function.jsonc");
     if (await isFunctionUnchanged(functionDir, fn)) {
       skipped.push(fn.name);
       continue;
     }
-    const config8 = {
+    const config7 = {
       name: fn.name,
       entry: fn.entry
     };
     if (fn.automations.length > 0) {
-      config8.automations = fn.automations;
+      config7.automations = fn.automations;
     }
-    await writeJsonFile(configPath, config8);
+    await writeJsonFile(configPath, config7);
     for (const file2 of fn.files) {
-      await writeFile(join10(functionDir, file2.path), file2.content);
+      await writeFile(join9(functionDir, file2.path), file2.content);
     }
     written.push(fn.name);
   }
@@ -243958,7 +243817,7 @@ async function isFunctionUnchanged(functionDir, fn) {
   if (!await pathExists(functionDir)) {
     return false;
   }
-  const configPath = join10(functionDir, "function.jsonc");
+  const configPath = join9(functionDir, "function.jsonc");
   try {
     const localConfig = await readJsonFile(configPath);
     if (localConfig.entry !== fn.entry) {
@@ -243971,7 +243830,7 @@ async function isFunctionUnchanged(functionDir, fn) {
     return false;
   }
   for (const file2 of fn.files) {
-    const filePath = join10(functionDir, file2.path);
+    const filePath = join9(functionDir, file2.path);
     if (!await pathExists(filePath)) {
       return false;
     }
@@ -244011,7 +243870,6 @@ class ProjectConfigReader {
       entities,
       functions,
       agents: localResources.agents,
-      agentSkills: localResources.agentSkills,
       connectors: localResources.connectors,
       authConfig: localResources.authConfig
     };
@@ -244039,15 +243897,14 @@ class ProjectConfigReader {
   }
   async readProjectResources(configPath, project) {
     const configDir = dirname8(configPath);
-    const [entities, functions, agents, agentSkills, connectors, authConfig] = await Promise.all([
-      entityResource.readAll(join11(configDir, project.entitiesDir)),
-      functionResource.readAll(join11(configDir, project.functionsDir)),
-      agentResource.readAll(join11(configDir, project.agentsDir)),
-      agentSkillResource.readAll(join11(configDir, project.agentSkillsDir)),
-      connectorResource.readAll(join11(configDir, project.connectorsDir)),
-      authConfigResource.readAll(join11(configDir, project.authDir))
+    const [entities, functions, agents, connectors, authConfig] = await Promise.all([
+      entityResource.readAll(join10(configDir, project.entitiesDir)),
+      functionResource.readAll(join10(configDir, project.functionsDir)),
+      agentResource.readAll(join10(configDir, project.agentsDir)),
+      connectorResource.readAll(join10(configDir, project.connectorsDir)),
+      authConfigResource.readAll(join10(configDir, project.authDir))
     ]);
-    return { entities, functions, agents, agentSkills, connectors, authConfig };
+    return { entities, functions, agents, connectors, authConfig };
   }
   assertPluginProjectDoesNotLoadPlugins(project, configPath) {
     if (project.plugin && project.plugins.length > 0) {
@@ -244081,7 +243938,6 @@ class ProjectConfigReader {
       entities: markPluginEntities(resources.entities, namespace),
       functions: namespacePluginFunctions(resources.functions, namespace),
       agents: [],
-      agentSkills: [],
       connectors: [],
       authConfig: []
     };
@@ -244119,7 +243975,6 @@ class ProjectConfigReader {
       entities,
       functions,
       agents: [],
-      agentSkills: [],
       connectors: [],
       authConfig: []
     };
@@ -244148,12 +244003,12 @@ 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 dirname9, join as join13 } from "node:path";
+import { dirname as dirname9, join as join12 } from "node:path";
 
 // src/core/assets.ts
 import { cpSync, existsSync } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join12 } from "node:path";
+import { join as join11 } from "node:path";
 // package.json
 var package_default = {
   name: "base44",
@@ -244254,21 +244109,24 @@ var package_default = {
 };
 
 // src/core/assets.ts
-var ASSETS_DIR = join12(homedir2(), ".base44", "assets", package_default.version);
+var ASSETS_DIR = join11(homedir2(), ".base44", "assets", package_default.version);
 function getTemplatesDir() {
-  return join12(ASSETS_DIR, "templates");
+  return join11(ASSETS_DIR, "templates");
 }
 function getTemplatesIndexPath() {
-  return join12(ASSETS_DIR, "templates", "templates.json");
+  return join11(ASSETS_DIR, "templates", "templates.json");
+}
+function getBackendRuntimeDir() {
+  return join11(ASSETS_DIR, "backend-runtime");
 }
 function getDenoWrapperPath() {
-  return join12(ASSETS_DIR, "deno-runtime", "main.ts");
+  return join11(getBackendRuntimeDir(), "main.ts");
 }
 function getExecWrapperPath() {
-  return join12(ASSETS_DIR, "deno-runtime", "exec.ts");
+  return join11(getBackendRuntimeDir(), "exec.ts");
 }
 function ensureNpmAssets(sourceDir) {
-  if (existsSync(ASSETS_DIR))
+  if (existsSync(ASSETS_DIR) && existsSync(getBackendRuntimeDir()))
     return;
   if (!existsSync(sourceDir))
     return;
@@ -244287,7 +244145,7 @@ async function listTemplates() {
 }
 async function renderTemplate(template, destPath, data, options = {}) {
   const { skipExisting = false } = options;
-  const templateDir = join13(getTemplatesDir(), template.path);
+  const templateDir = join12(getTemplatesDir(), template.path);
   const files = await globby("**/*", {
     cwd: templateDir,
     dot: true,
@@ -244295,20 +244153,20 @@ async function renderTemplate(template, destPath, data, options = {}) {
   });
   const skipped = [];
   for (const file2 of files) {
-    const srcPath = join13(templateDir, file2);
+    const srcPath = join12(templateDir, file2);
     try {
       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 ? join13(dirname9(file2), attributes.outputFileName) : file2.replace(/\.ejs$/, "");
-        const destFilePath = join13(destPath, destFile);
+        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);
           continue;
         }
         await writeFile(destFilePath, body);
       } else {
-        const destFilePath = join13(destPath, file2);
+        const destFilePath = join12(destPath, file2);
         if (skipExisting && await pathExists(destFilePath)) {
           skipped.push(file2);
           continue;
@@ -244408,7 +244266,7 @@ async function getSiteFilePaths(outputDir) {
 // src/core/site/deploy.ts
 import { randomUUID } from "node:crypto";
 import { tmpdir } from "node:os";
-import { join as join14 } from "node:path";
+import { join as join13 } from "node:path";
 async function deploySite(siteOutputDir) {
   if (!await pathExists(siteOutputDir)) {
     throw new InvalidInputError(`Output directory does not exist: ${siteOutputDir}. Make sure to build your project first.`, {
@@ -244425,7 +244283,7 @@ async function deploySite(siteOutputDir) {
       ]
     });
   }
-  const archivePath = join14(tmpdir(), `base44-site-${randomUUID()}.tar.gz`);
+  const archivePath = join13(tmpdir(), `base44-site-${randomUUID()}.tar.gz`);
   try {
     await createArchive(siteOutputDir, archivePath);
     return await uploadSite(archivePath);
@@ -244442,35 +244300,18 @@ async function createArchive(pathToArchive, targetArchivePath) {
 }
 // src/core/project/deploy.ts
 function hasResourcesToDeploy(projectData) {
-  const {
-    project,
-    entities,
-    functions,
-    agents,
-    agentSkills,
-    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 hasAgents = agents.length > 0;
-  const hasAgentSkills = agentSkills.length > 0;
   const hasConnectors = connectors.length > 0;
   const hasAuthConfig = authConfig.length > 0;
   const hasVisibility = Boolean(project.visibility);
-  return hasEntities || hasFunctions || hasAgents || hasAgentSkills || hasConnectors || hasAuthConfig || hasVisibility || hasSite;
+  return hasEntities || hasFunctions || hasAgents || hasConnectors || hasAuthConfig || hasVisibility || hasSite;
 }
 async function deployAll(projectData, options) {
-  const {
-    project,
-    entities,
-    functions,
-    agents,
-    agentSkills,
-    connectors,
-    authConfig
-  } = projectData;
+  const { project, entities, functions, agents, connectors, authConfig } = projectData;
   await setAppVisibility(project.visibility);
   if (project.visibility) {
     options?.onVisibilitySet?.(project.visibility);
@@ -244480,7 +244321,6 @@ async function deployAll(projectData, options) {
     onStart: options?.onFunctionStart,
     onResult: options?.onFunctionResult
   });
-  await agentSkillResource.push(agentSkills);
   await agentResource.push(agents);
   await authConfigResource.push(authConfig);
   const skipConnectorSync = connectors.length === 0 && hasWorkspaceApiKeyAuth();
@@ -251778,70 +251618,14 @@ async function moveAppToWorkspace(appId, targetWorkspaceId, options = {}) {
   }
   return result.data;
 }
-// src/cli/commands/agent-skills/pull.ts
-async function pullAction({
-  log,
-  runTask: runTask2
-}) {
-  const { project: project2 } = await readProjectConfig();
-  const dir = join15(dirname10(project2.configPath), project2.agentSkillsDir);
-  const remote = await runTask2("Fetching agent skills from Base44", () => fetchAgentSkills(), {
-    successMessage: "Agent skills fetched",
-    errorMessage: "Failed to fetch agent skills"
-  });
-  const { written, deleted } = await runTask2("Syncing skill files", () => writeAgentSkills(dir, remote.items), {
-    successMessage: "Skill files synced",
-    errorMessage: "Failed to sync skill files"
-  });
-  if (written.length > 0)
-    log.success(`Written: ${written.join(", ")}`);
-  if (deleted.length > 0)
-    log.warn(`Deleted: ${deleted.join(", ")}`);
-  if (written.length === 0 && deleted.length === 0)
-    log.info("All skills are already up to date");
-  return { outroMessage: `Pulled ${remote.total} agent skills to ${dir}` };
-}
-function getAgentSkillsPullCommand() {
-  return new Base44Command("pull").description("Pull agent skills from Base44 to local files").action(pullAction);
-}
-
-// src/cli/commands/agent-skills/push.ts
-async function pushAction({
-  log,
-  runTask: runTask2
-}) {
-  const { agentSkills } = await readProjectConfig();
-  log.info(agentSkills.length === 0 ? "No local agent skills found - this will delete all remote skills" : `Found ${agentSkills.length} agent skills to push`);
-  const result = await runTask2("Pushing agent skills to Base44", () => pushAgentSkills(agentSkills), {
-    successMessage: "Agent skills pushed",
-    errorMessage: "Failed to push agent skills"
-  });
-  if (result.created.length > 0)
-    log.success(`Created: ${result.created.join(", ")}`);
-  if (result.updated.length > 0)
-    log.success(`Updated: ${result.updated.join(", ")}`);
-  if (result.deleted.length > 0)
-    log.warn(`Deleted: ${result.deleted.join(", ")}`);
-  return { outroMessage: "Agent skills pushed to Base44" };
-}
-function getAgentSkillsPushCommand() {
-  return new Base44Command("push").description("Push local agent skills to Base44").action(pushAction);
-}
-
-// src/cli/commands/agent-skills/index.ts
-function getAgentSkillsCommand() {
-  return new Command("agent-skills").description("Manage app agent skills").addCommand(getAgentSkillsPushCommand()).addCommand(getAgentSkillsPullCommand());
-}
-
 // src/cli/commands/agents/pull.ts
-import { dirname as dirname11, join as join16 } from "node:path";
 async function pullAgentsAction({
   log,
   runTask: runTask2
 }) {
   const { project: project2 } = await readProjectConfig();
-  const configDir = dirname11(project2.configPath);
-  const agentsDir = join16(configDir, project2.agentsDir);
+  const configDir = dirname10(project2.configPath);
+  const agentsDir = join14(configDir, project2.agentsDir);
   const remoteAgents = await runTask2("Fetching agents from Base44", async () => {
     return await fetchAgents();
   }, {
@@ -251911,12 +251695,12 @@ function getAgentsCommand() {
 }
 
 // src/cli/commands/auth/password-login.ts
-import { dirname as dirname12, join as join17 } 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 = dirname12(project2.configPath);
-  const authDir = join17(configDir, project2.authDir);
+  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;
     const merged = { ...current, enableUsernamePassword: shouldEnable };
@@ -251936,14 +251720,14 @@ function getPasswordLoginCommand() {
 }
 
 // src/cli/commands/auth/pull.ts
-import { dirname as dirname13, join as join18 } 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 = dirname13(project2.configPath);
-  const authDir = join18(configDir, project2.authDir);
+  const configDir = dirname12(project2.configPath);
+  const authDir = join16(configDir, project2.authDir);
   const remoteConfig = await runTask2("Fetching auth config from Base44", async () => {
     return await pullAuthConfig();
   }, {
@@ -252007,7 +251791,7 @@ function getAuthPushCommand() {
 }
 
 // src/cli/commands/auth/social-login.ts
-import { dirname as dirname14, join as join19, resolve as resolve4 } from "node:path";
+import { dirname as dirname13, join as join17, resolve as resolve4 } from "node:path";
 var PROVIDER_LABELS = {
   google: "Google",
   microsoft: "Microsoft",
@@ -252077,8 +251861,8 @@ async function socialLoginAction({ log, isNonInteractive, runTask: runTask2 }, p
     }
   }
   const { project: project2 } = await readProjectConfig();
-  const configDir = dirname14(project2.configPath);
-  const authDir = join19(configDir, project2.authDir);
+  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) {
     await runTask2("Saving client secret", async () => pushCustomOAuthSecret(provider, clientSecret));
@@ -252103,7 +251887,7 @@ function getSocialLoginCommand() {
 }
 
 // src/cli/commands/auth/sso.ts
-import { dirname as dirname15, join as join20, resolve as resolve5 } from "node:path";
+import { dirname as dirname14, join as join18, resolve as resolve5 } from "node:path";
 var SSOConfigFileSchema = exports_external.object({
   provider: exports_external.enum(Object.values(KNOWN_SSO_PROVIDERS)),
   clientId: exports_external.string(),
@@ -252266,8 +252050,8 @@ async function ssoEnableAction({ isNonInteractive, runTask: runTask2 }, options)
     throw error48;
   }
   const { project: project2 } = await readProjectConfig();
-  const configDir = dirname15(project2.configPath);
-  const authDir = join20(configDir, project2.authDir);
+  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));
   return {
@@ -252282,8 +252066,8 @@ async function ssoDisableAction({ log, runTask: runTask2 }, options) {
     throw new InvalidInputError("Configuration options cannot be used with disable. To disable SSO: base44 auth sso disable");
   }
   const { project: project2 } = await readProjectConfig();
-  const configDir = dirname15(project2.configPath);
-  const authDir = join20(configDir, project2.authDir);
+  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());
   if (!hasAnyLoginMethod(updated)) {
@@ -253140,13 +252924,13 @@ function getConnectorsListAvailableCommand() {
 }
 
 // src/cli/commands/connectors/pull.ts
-import { dirname as dirname16, join as join21, resolve as resolve6 } from "node:path";
+import { dirname as dirname15, join as join19, resolve as resolve6 } from "node:path";
 async function resolveConnectorsDir(options) {
   if (!getAppContext().projectRoot) {
     return resolve6(options.dir ?? "connectors");
   }
   const { project: project2 } = await readProjectConfig();
-  return join21(dirname16(project2.configPath), project2.connectorsDir);
+  return join19(dirname15(project2.configPath), project2.connectorsDir);
 }
 async function pullConnectorsAction({ log, runTask: runTask2, jsonMode }, options) {
   const connectorsDir = await resolveConnectorsDir(options);
@@ -253554,11 +253338,11 @@ function getListCommand() {
 }
 
 // src/cli/commands/functions/pull.ts
-import { dirname as dirname17, join as join22 } 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 = dirname17(project2.configPath);
-  const functionsDir = join22(configDir, project2.functionsDir);
+  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 () => {
     const { functions: functions2 } = await listDeployedFunctions();
@@ -253621,7 +253405,7 @@ import { basename as basename4, resolve as resolve8 } from "node:path";
 var import_kebabCase = __toESM(require_kebabCase(), 1);
 
 // src/cli/commands/project/scaffold-shared.ts
-import { join as join23 } from "node:path";
+import { join as join21 } from "node:path";
 var DEFAULT_TEMPLATE_ID = "backend-only";
 async function getTemplateById(templateId) {
   const templates = await listTemplates();
@@ -253680,7 +253464,7 @@ async function completeProjectSetup({
         updateMessage("Building project...");
         await execa({ cwd: resolvedPath, shell: true })`${buildCommand}`;
         updateMessage("Deploying site...");
-        return await deploySite(join23(resolvedPath, outputDirectory));
+        return await deploySite(join21(resolvedPath, outputDirectory));
       }, {
         successMessage: theme.colors.base44Orange("Site deployed successfully"),
         errorMessage: "Failed to deploy site"
@@ -254535,7 +254319,7 @@ function withSandboxAuthHint(error48) {
     cause: error48
   });
 }
-async function callTool(appId, tool, payload, schema12, context, timeout2 = 60000) {
+async function callTool(appId, tool, payload, schema11, context, timeout2 = 60000) {
   const client = getSandboxClient(appId);
   let response;
   try {
@@ -254543,7 +254327,7 @@ async function callTool(appId, tool, payload, schema12, context, timeout2 = 6000
   } catch (error48) {
     throw withSandboxAuthHint(await ApiError.fromHttpError(error48, context));
   }
-  const result = schema12.safeParse(await response.json());
+  const result = schema11.safeParse(await response.json());
   if (!result.success) {
     throw new SchemaValidationError("Invalid response from server", result.error);
   }
@@ -254937,9 +254721,9 @@ async function generateContent(input) {
 `);
 }
 async function compileEntity(entity2) {
-  const { name: name2, source: _source, ...schema12 } = entity2;
+  const { name: name2, source: _source, ...schema11 } = entity2;
   const jsonSchema = {
-    ...schema12,
+    ...schema11,
     title: name2,
     additionalProperties: false
   };
@@ -254966,10 +254750,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 join26 } 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 = join26(projectRoot, "tsconfig.json");
+  const tsconfigPath = join24(projectRoot, "tsconfig.json");
   if (!await pathExists(tsconfigPath)) {
     return false;
   }
@@ -255167,7 +254951,7 @@ function getWorkspaceCommand() {
 // src/cli/dev/dev-server/main.ts
 var import_cors = __toESM(require_lib4(), 1);
 var import_express6 = __toESM(require_express(), 1);
-import { dirname as dirname22, join as join29 } from "node:path";
+import { dirname as dirname23, join as join29 } from "node:path";
 
 // ../../node_modules/get-port/index.js
 import net from "node:net";
@@ -255188,8 +254972,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;
@@ -255339,7 +255123,79 @@ function createDevLogger(label2, labelColor = theme.styles.dim) {
 
 // src/cli/dev/dev-server/function-manager.ts
 import { spawn as spawn2 } from "node:child_process";
+import { dirname as dirname20, join as join26 } from "node:path";
+import { pathToFileURL as pathToFileURL6 } from "node:url";
+
+// src/cli/dev/dev-server/import-map.ts
+var import_json52 = __toESM(require_lib(), 1);
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
+import { dirname as dirname19, join as join25, parse as parsePath } from "node:path";
 import { pathToFileURL } from "node:url";
+var DENO_CONFIG_NAMES = ["deno.json", "deno.jsonc"];
+function findDenoConfig(startDir) {
+  const { root: root2 } = parsePath(startDir);
+  let dir = startDir;
+  while (true) {
+    for (const name2 of DENO_CONFIG_NAMES) {
+      const candidate = join25(dir, name2);
+      if (existsSync2(candidate))
+        return candidate;
+    }
+    if (dir === root2)
+      return null;
+    const parent = dirname19(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+}
+function absolutize(value, baseUrl) {
+  if (!value.startsWith("./") && !value.startsWith("../"))
+    return value;
+  return new URL(value, baseUrl).href;
+}
+function absolutizeEntries(entries, baseUrl) {
+  return Object.fromEntries(Object.entries(entries).map(([key2, value]) => [
+    absolutize(key2, baseUrl),
+    absolutize(value, baseUrl)
+  ]));
+}
+function readImportMap(filePath) {
+  const parsed = import_json52.default.parse(readFileSync3(filePath, "utf-8"));
+  if (!parsed || typeof parsed !== "object")
+    return {};
+  const { imports, scopes } = parsed;
+  return { imports, scopes };
+}
+function buildImportMapArg(baseImportMapPath, projectDir) {
+  const baseUrl = pathToFileURL(baseImportMapPath).href;
+  const base = readImportMap(baseImportMapPath);
+  const merged = {
+    imports: absolutizeEntries(base.imports ?? {}, baseUrl),
+    scopes: {}
+  };
+  const projectConfigPath = findDenoConfig(projectDir);
+  if (projectConfigPath) {
+    const projectUrl = pathToFileURL(projectConfigPath).href;
+    let project2 = {};
+    try {
+      project2 = readImportMap(projectConfigPath);
+    } catch {
+      project2 = {};
+    }
+    merged.imports = {
+      ...absolutizeEntries(project2.imports ?? {}, projectUrl),
+      ...merged.imports
+    };
+    for (const [scope, entries] of Object.entries(project2.scopes ?? {})) {
+      merged.scopes[absolutize(scope, projectUrl)] = absolutizeEntries(entries, projectUrl);
+    }
+  }
+  const json3 = JSON.stringify(merged);
+  return `data:application/json,${encodeURIComponent(json3)}`;
+}
+
+// src/cli/dev/dev-server/function-manager.ts
 var READY_TIMEOUT = 30000;
 
 class FunctionManager {
@@ -255422,10 +255278,11 @@ class FunctionManager {
   }
   spawnFunction(func, port) {
     this.logger.log(`Spawning function "${func.name}" on port ${port}`);
-    const process21 = spawn2("deno", ["run", "--allow-all", this.wrapperPath], {
+    const importMapArg = buildImportMapArg(join26(dirname20(this.wrapperPath), "import-map.json"), globalThis.process.cwd());
+    const process21 = spawn2("deno", ["run", "--allow-all", "--import-map", importMapArg, this.wrapperPath], {
       env: {
         ...globalThis.process.env,
-        FUNCTION_PATH: pathToFileURL(func.entryPath).href,
+        FUNCTION_PATH: pathToFileURL6(func.entryPath).href,
         FUNCTION_PORT: String(port),
         FUNCTION_NAME: func.name
       },
@@ -255829,22 +255686,22 @@ class Database {
     this.schemas.clear();
   }
   validate(entityName, record2, partial2 = false) {
-    const schema12 = this.schemas.get(this.normalizeName(entityName));
-    if (!schema12) {
+    const schema11 = this.schemas.get(this.normalizeName(entityName));
+    if (!schema11) {
       throw new Error(`Entity "${entityName}" not found`);
     }
-    return this.validator.validate(record2, schema12, partial2);
+    return this.validator.validate(record2, schema11, partial2);
   }
   prepareRecord(entityName, record2, partial2 = false) {
-    const schema12 = this.schemas.get(this.normalizeName(entityName));
-    if (!schema12) {
+    const schema11 = this.schemas.get(this.normalizeName(entityName));
+    if (!schema11) {
       throw new Error(`Entity "${entityName}" not found`);
     }
-    const filteredRecord = this.validator.filterFields(record2, schema12);
+    const filteredRecord = this.validator.filterFields(record2, schema11);
     if (partial2) {
       return filteredRecord;
     }
-    return this.validator.applyDefaults(filteredRecord, schema12);
+    return this.validator.applyDefaults(filteredRecord, schema11);
   }
   normalizeName(entityName) {
     return entityName.toLowerCase();
@@ -256138,13 +255995,13 @@ function checkRLS(rule, record2, user) {
     return false;
   return evaluateCondition(rule, record2, user);
 }
-function applyFLS(record2, schema12, user, operation) {
+function applyFLS(record2, schema11, user, operation) {
   if (Array.isArray(record2)) {
-    return record2.map((r5) => applyFLS(r5, schema12, user, operation));
+    return record2.map((r5) => applyFLS(r5, schema11, user, operation));
   }
   const result = {};
   for (const [key2, value] of Object.entries(record2)) {
-    const rule = schema12.properties[key2]?.rls?.[operation];
+    const rule = schema11.properties[key2]?.rls?.[operation];
     if (rule === undefined || checkRLS(rule, record2, user)) {
       result[key2] = value;
     }
@@ -256372,14 +256229,14 @@ async function createEntityRoutes(db2, logger2, broadcast) {
         res.status(404).json({ error: `Entity "${entityName}" not found` });
         return;
       }
-      const schema12 = db2.getSchema(entityName);
-      if (!schema12) {
+      const schema11 = db2.getSchema(entityName);
+      if (!schema11) {
         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, schema12, currentUser);
+      await handler(req, res, collection, schema11, currentUser);
     };
   }
   function emit(appId, entityName, type, data) {
@@ -256397,19 +256254,19 @@ async function createEntityRoutes(db2, logger2, broadcast) {
     }
     broadcast(appId, entityName, createData(data));
   }
-  function prepareCreateRecord(entityName, body, schema12, currentUser, now) {
+  function prepareCreateRecord(entityName, body, schema11, currentUser, now) {
     const { _id, ...recordBody } = body;
     const ownerFields = {
       created_by: currentUser?.email,
       created_by_id: currentUser?.id
     };
-    if (!checkRLS(schema12.rls?.create, {
+    if (!checkRLS(schema11.rls?.create, {
       ...recordBody,
       ...ownerFields
     }, currentUser)) {
       return;
     }
-    const filteredBody = applyFLS(db2.prepareRecord(entityName, recordBody), schema12, currentUser, "write");
+    const filteredBody = applyFLS(db2.prepareRecord(entityName, recordBody), schema11, currentUser, "write");
     db2.validate(entityName, filteredBody);
     return {
       ...filteredBody,
@@ -256421,7 +256278,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, schema12, currentUser) => {
+  router.get("/:entityName/:id", withCollection(async (req, res, collection, schema11, currentUser) => {
     const { entityName, id: id2 } = req.params;
     try {
       const doc2 = await collection.findOneAsync({ id: id2 });
@@ -256429,27 +256286,27 @@ async function createEntityRoutes(db2, logger2, broadcast) {
         res.status(404).json({ error: `Record with id "${id2}" not found` });
         return;
       }
-      if (!checkRLS(schema12.rls?.read, doc2, currentUser)) {
+      if (!checkRLS(schema11.rls?.read, doc2, currentUser)) {
         res.status(404).json({
           message: `Entity ${entityName} with ID ${id2} not found`
         });
         return;
       }
-      const result = applyFLS(stripInternalFields(doc2), schema12, currentUser, "read");
+      const result = applyFLS(stripInternalFields(doc2), schema11, 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, schema12, currentUser) => {
+  router.get("/:entityName", withCollection(async (req, res, collection, schema11, currentUser) => {
     const { entityName } = req.params;
     try {
       let results = stripInternalFields(await queryEntity(collection, req.query));
-      if (schema12.rls?.read !== undefined && schema12.rls.read !== true) {
-        results = results.filter((doc2) => checkRLS(schema12.rls.read, doc2, currentUser));
+      if (schema11.rls?.read !== undefined && schema11.rls.read !== true) {
+        results = results.filter((doc2) => checkRLS(schema11.rls.read, doc2, currentUser));
       }
-      results = results.map((doc2) => applyFLS(doc2, schema12, currentUser, "read"));
+      results = results.map((doc2) => applyFLS(doc2, schema11, currentUser, "read"));
       res.json(results);
     } catch (error48) {
       if (error48 instanceof InvalidInputError) {
@@ -256460,16 +256317,16 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       }
     }
   }));
-  router.post("/:entityName", parseBody, withCollection(async (req, res, collection, schema12, currentUser) => {
+  router.post("/:entityName", parseBody, withCollection(async (req, res, collection, schema11, currentUser) => {
     const { appId, entityName } = req.params;
     try {
       const now = new Date().toISOString();
-      const record2 = prepareCreateRecord(entityName, req.body, schema12, currentUser, now);
+      const record2 = prepareCreateRecord(entityName, req.body, schema11, currentUser, now);
       if (!record2) {
         res.status(403).json({ error: "Permission denied" });
         return;
       }
-      const inserted = applyFLS(stripInternalFields(await collection.insertAsync(record2)), schema12, currentUser, "read");
+      const inserted = applyFLS(stripInternalFields(await collection.insertAsync(record2)), schema11, currentUser, "read");
       emit(appId, entityName, "create", inserted);
       res.status(201).json(inserted);
     } catch (error48) {
@@ -256481,7 +256338,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, schema12, currentUser) => {
+  router.post("/:entityName/bulk", parseBody, withCollection(async (req, res, collection, schema11, currentUser) => {
     const { appId, entityName } = req.params;
     if (!Array.isArray(req.body)) {
       res.status(400).json({ error: "Request body must be an array" });
@@ -256491,14 +256348,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, schema12, currentUser, now);
+        const record2 = prepareCreateRecord(entityName, body, schema11, currentUser, now);
         if (!record2) {
           res.status(403).json({ error: "Permission denied" });
           return;
         }
         records.push(record2);
       }
-      const inserted = applyFLS(stripInternalFields(await collection.insertAsync(records)), schema12, currentUser, "read");
+      const inserted = applyFLS(stripInternalFields(await collection.insertAsync(records)), schema11, currentUser, "read");
       emit(appId, entityName, "create", inserted);
       res.status(201).json(inserted);
     } catch (error48) {
@@ -256510,24 +256367,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, schema12, currentUser) => {
+  router.put("/:entityName/:id", parseBody, withCollection(async (req, res, collection, schema11, currentUser) => {
     const { appId, entityName, id: id2 } = req.params;
     const { id: _id, created_date: _created_date, ...body } = req.body;
     try {
-      if (schema12.rls?.update !== undefined) {
+      if (schema11.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(schema12.rls.update, existing, currentUser)) {
+        if (!checkRLS(schema11.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), schema12, currentUser, "write");
+      const filteredBody = applyFLS(db2.prepareRecord(entityName, body, true), schema11, currentUser, "write");
       db2.validate(entityName, filteredBody, true);
       const updateData = {
         ...filteredBody,
@@ -256538,7 +256395,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), schema12, currentUser, "read");
+      const updated = applyFLS(stripInternalFields(result.affectedDocuments), schema11, currentUser, "read");
       emit(appId, entityName, "update", updated);
       res.json(updated);
     } catch (error48) {
@@ -256550,7 +256407,7 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       res.status(500).json({ error: "Internal server error" });
     }
   }));
-  router.delete("/:entityName/:id", withCollection(async (req, res, collection, schema12, currentUser) => {
+  router.delete("/:entityName/:id", withCollection(async (req, res, collection, schema11, currentUser) => {
     const { appId, entityName, id: id2 } = req.params;
     try {
       const doc2 = await collection.findOneAsync({ id: id2 });
@@ -256558,7 +256415,7 @@ async function createEntityRoutes(db2, logger2, broadcast) {
         res.status(404).json({ error: `Record with id "${id2}" not found` });
         return;
       }
-      if (!checkRLS(schema12.rls?.delete, doc2, currentUser)) {
+      if (!checkRLS(schema11.rls?.delete, doc2, currentUser)) {
         res.status(404).json({
           message: `Entity ${entityName} with ID ${id2} not found`
         });
@@ -256572,11 +256429,11 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       res.status(500).json({ error: "Internal server error" });
     }
   }));
-  router.delete("/:entityName", parseBody, withCollection(async (req, res, collection, schema12, currentUser) => {
+  router.delete("/:entityName", parseBody, withCollection(async (req, res, collection, schema11, currentUser) => {
     const { entityName } = req.params;
     try {
       const query = req.body || {};
-      const rlsDelete = schema12?.rls?.delete;
+      const rlsDelete = schema11?.rls?.delete;
       if (rlsDelete !== undefined && rlsDelete !== true) {
         if (rlsDelete === false && currentUser?.is_service !== true) {
           res.status(403).json({ error: "Permission denied" });
@@ -257525,9 +257382,9 @@ class NodeFsHandler {
     if (this.fsw.closed) {
       return;
     }
-    const dirname21 = sp2.dirname(file2);
+    const dirname22 = sp2.dirname(file2);
     const basename7 = sp2.basename(file2);
-    const parent = this.fsw._getWatchedDir(dirname21);
+    const parent = this.fsw._getWatchedDir(dirname22);
     let prevStats = stats;
     if (parent.has(basename7))
       return;
@@ -257554,7 +257411,7 @@ class NodeFsHandler {
             prevStats = newStats2;
           }
         } catch (error48) {
-          this.fsw._remove(dirname21, basename7);
+          this.fsw._remove(dirname22, basename7);
         }
       } else if (parent.has(basename7)) {
         const at13 = newStats.atimeMs;
@@ -258587,8 +258444,8 @@ async function createDevServer(options8) {
     broadcastEntityEvent(io6, appId, entityName, event);
   };
   const base44ConfigWatcher = new WatchBase44({
-    functions: join29(dirname22(project2.configPath), project2.functionsDir),
-    entities: join29(dirname22(project2.configPath), project2.entitiesDir)
+    functions: join29(dirname23(project2.configPath), project2.functionsDir),
+    entities: join29(dirname23(project2.configPath), project2.entitiesDir)
   }, devLogger);
   base44ConfigWatcher.on("change", async (name2) => {
     try {
@@ -258965,7 +258822,6 @@ function createProgram(context) {
   program2.addCommand(getWorkspaceCommand());
   program2.addCommand(getEntitiesPushCommand());
   program2.addCommand(getAgentsCommand());
-  program2.addCommand(getAgentSkillsCommand());
   program2.addCommand(getConnectorsCommand());
   program2.addCommand(getFunctionsCommand());
   program2.addCommand(getSecretsCommand());
@@ -258984,7 +258840,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 dirname23, posix, sep } from "path";
+import { dirname as dirname24, posix, sep } from "path";
 function createModulerModifier() {
   const getModuleFromFileName = createGetModuleFromFilename();
   return async (frames) => {
@@ -258993,7 +258849,7 @@ function createModulerModifier() {
     return frames;
   };
 }
-function createGetModuleFromFilename(basePath = process.argv[1] ? dirname23(process.argv[1]) : process.cwd(), isWindows5 = sep === "\\") {
+function createGetModuleFromFilename(basePath = process.argv[1] ? dirname24(process.argv[1]) : process.cwd(), isWindows5 = sep === "\\") {
   const normalizedBase = isWindows5 ? normalizeWindowsPath2(basePath) : basePath;
   return (filename) => {
     if (!filename)
@@ -263182,7 +263038,7 @@ function addCommandInfoToErrorReporter(program2, errorReporter) {
   });
 }
 // src/cli/index.ts
-var __dirname4 = dirname24(fileURLToPath6(import.meta.url));
+var __dirname4 = dirname25(fileURLToPath6(import.meta.url));
 async function runCLI(options8) {
   ensureNpmAssets(join30(__dirname4, "../assets"));
   const errorReporter = new ErrorReporter;
@@ -263223,4 +263079,4 @@ export {
   CLIExitError
 };
 
-//# debugId=8336FC5974E395C864756E2164756E21
+//# debugId=81AA053654470EFC64756E2164756E21