@base44-preview/cli 0.1.1-pr.560.47e731b → 0.1.2-pr.555.3443d0b

package/dist/cli/index.js

@@ -12980,10 +12980,10 @@ var require_ejs = __commonJS((exports) => {
   exports.localsName = _DEFAULT_LOCALS_NAME;
   exports.promiseImpl = new Function("return this;")().Promise;
   exports.resolveInclude = function(name2, filename, isDir) {
-    var dirname9 = path11.dirname;
+    var dirname11 = path11.dirname;
     var extname = path11.extname;
     var resolve2 = path11.resolve;
-    var includePath = resolve2(isDir ? filename : dirname9(filename), name2);
+    var includePath = resolve2(isDir ? filename : dirname11(filename), name2);
     var ext = extname(name2);
     if (!ext) {
       includePath += ".ejs";
@@ -13361,10 +13361,10 @@ var require_ejs = __commonJS((exports) => {
       };
       if (opts.filename && typeof Object.defineProperty === "function") {
         var filename = opts.filename;
-        var basename4 = path11.basename(filename, path11.extname(filename));
+        var basename5 = path11.basename(filename, path11.extname(filename));
         try {
           Object.defineProperty(returnedFn, "name", {
-            value: basename4,
+            value: basename5,
             writable: false,
             enumerable: false,
             configurable: true
@@ -13718,12 +13718,12 @@ var require_schema = __commonJS((exports, module) => {
   var common = require_common3();
   var YAMLException = require_exception();
   var Type = require_type();
-  function compileList(schema7, name2, result) {
+  function compileList(schema8, name2, result) {
     var exclude = [];
-    schema7.include.forEach(function(includedSchema) {
+    schema8.include.forEach(function(includedSchema) {
       result = compileList(includedSchema, name2, result);
     });
-    schema7[name2].forEach(function(currentType) {
+    schema8[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(schema7) {
-      return schema7 instanceof Schema;
+    if (!schemas3.every(function(schema8) {
+      return schema8 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(schema7, map2) {
+  function compileStyleMap(schema8, 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 = schema7.compiledTypeMap["fallback"][tag];
+      type = schema8.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 join14(array2, separator) {
+      function join15(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 = join14;
+      lodash.join = join15;
       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: schema10, sourceObjects } = ctx;
+    const { aliasDuplicateObjects, onAnchor, onTagObj, schema: schema11, 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, schema10.tags);
+    let tagObj = findTagObject(value, tagName, schema11.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 ? schema10[identity3.MAP] : (Symbol.iterator in Object(value)) ? schema10[identity3.SEQ] : schema10[identity3.MAP];
+      tagObj = value instanceof Map ? schema11[identity3.MAP] : (Symbol.iterator in Object(value)) ? schema11[identity3.SEQ] : schema11[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(schema10, path16, value) {
+  function collectionFromPath(schema11, 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: schema10,
+      schema: schema11,
       sourceObjects: new Map
     });
   }
   var isEmptyPath = (path16) => path16 == null || typeof path16 === "object" && !!path16[Symbol.iterator]().next().done;
 
   class Collection extends Node2.NodeBase {
-    constructor(type, schema10) {
+    constructor(type, schema11) {
       super(type);
       Object.defineProperty(this, "schema", {
-        value: schema10,
+        value: schema11,
         configurable: true,
         enumerable: false,
         writable: true
       });
     }
-    clone(schema10) {
+    clone(schema11) {
       const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
-      if (schema10)
-        copy.schema = schema10;
-      copy.items = copy.items.map((it3) => identity3.isNode(it3) || identity3.isPair(it3) ? it3.clone(schema10) : it3);
+      if (schema11)
+        copy.schema = schema11;
+      copy.items = copy.items.map((it3) => identity3.isNode(it3) || identity3.isPair(it3) ? it3.clone(schema11) : 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(schema10) {
+    clone(schema11) {
       let { key, value } = this;
       if (identity3.isNode(key))
-        key = key.clone(schema10);
+        key = key.clone(schema11);
       if (identity3.isNode(value))
-        value = value.clone(schema10);
+        value = value.clone(schema11);
       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(schema10) {
-      super(identity3.MAP, schema10);
+    constructor(schema11) {
+      super(identity3.MAP, schema11);
       this.items = [];
     }
-    static from(schema10, obj, ctx) {
+    static from(schema11, obj, ctx) {
       const { keepUndefined, replacer } = ctx;
-      const map2 = new this(schema10);
+      const map2 = new this(schema11);
       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 schema10.sortMapEntries === "function") {
-        map2.items.sort(schema10.sortMapEntries);
+      if (typeof schema11.sortMapEntries === "function") {
+        map2.items.sort(schema11.sortMapEntries);
       }
       return map2;
     }
@@ -24325,7 +24325,7 @@ var require_map2 = __commonJS((exports) => {
         onError("Expected a mapping for this tag");
       return map3;
     },
-    createNode: (schema10, obj, ctx) => YAMLMap.YAMLMap.from(schema10, obj, ctx)
+    createNode: (schema11, obj, ctx) => YAMLMap.YAMLMap.from(schema11, obj, ctx)
   };
   exports.map = map2;
 });
@@ -24343,8 +24343,8 @@ var require_YAMLSeq = __commonJS((exports) => {
     static get tagName() {
       return "tag:yaml.org,2002:seq";
     }
-    constructor(schema10) {
-      super(identity3.SEQ, schema10);
+    constructor(schema11) {
+      super(identity3.SEQ, schema11);
       this.items = [];
     }
     add(value) {
@@ -24398,9 +24398,9 @@ var require_YAMLSeq = __commonJS((exports) => {
         onComment
       });
     }
-    static from(schema10, obj, ctx) {
+    static from(schema11, obj, ctx) {
       const { replacer } = ctx;
-      const seq = new this(schema10);
+      const seq = new this(schema11);
       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: (schema10, obj, ctx) => YAMLSeq.YAMLSeq.from(schema10, obj, ctx)
+    createNode: (schema11, obj, ctx) => YAMLSeq.YAMLSeq.from(schema11, 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 schema10 = [
+  var schema11 = [
     map2.map,
     seq.seq,
     string4.string,
@@ -24625,7 +24625,7 @@ var require_schema2 = __commonJS((exports) => {
     float.floatExp,
     float.float
   ];
-  exports.schema = schema10;
+  exports.schema = schema11;
 });
 
 // ../../node_modules/yaml/dist/schema/json/schema.js
@@ -24688,8 +24688,8 @@ var require_schema3 = __commonJS((exports) => {
       return str;
     }
   };
-  var schema10 = [map2.map, seq.seq].concat(jsonScalars, jsonError);
-  exports.schema = schema10;
+  var schema11 = [map2.map, seq.seq].concat(jsonScalars, jsonError);
+  exports.schema = schema11;
 });
 
 // ../../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(schema10, iterable, ctx) {
+  function createPairs(schema11, iterable, ctx) {
     const { replacer } = ctx;
-    const pairs2 = new YAMLSeq.YAMLSeq(schema10);
+    const pairs2 = new YAMLSeq.YAMLSeq(schema11);
     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(schema10, iterable, ctx) {
-      const pairs$1 = pairs.createPairs(schema10, iterable, ctx);
+    static from(schema11, iterable, ctx) {
+      const pairs$1 = pairs.createPairs(schema11, 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: (schema10, iterable, ctx) => YAMLOMap.from(schema10, iterable, ctx)
+    createNode: (schema11, iterable, ctx) => YAMLOMap.from(schema11, 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(schema10) {
-      super(schema10);
+    constructor(schema11) {
+      super(schema11);
       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(schema10, iterable, ctx) {
+    static from(schema11, iterable, ctx) {
       const { replacer } = ctx;
-      const set3 = new this(schema10);
+      const set3 = new this(schema11);
       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: (schema10, iterable, ctx) => YAMLSet.from(schema10, iterable, ctx),
+    createNode: (schema11, iterable, ctx) => YAMLSet.from(schema11, 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 schema10 = [
+  var schema11 = [
     map2.map,
     seq.seq,
     string4.string,
@@ -25248,7 +25248,7 @@ var require_schema4 = __commonJS((exports) => {
     timestamp.floatTime,
     timestamp.timestamp
   ];
-  exports.schema = schema10;
+  exports.schema = schema11;
 });
 
 // ../../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 schema10 = require_schema2();
+  var schema11 = 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", schema10.schema],
+    ["core", schema11.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: schema10, sortMapEntries, toStringDefaults }) {
+    constructor({ compat: compat2, customTags, merge: merge3, resolveKnownTags, schema: schema11, sortMapEntries, toStringDefaults }) {
       this.compat = Array.isArray(compat2) ? tags.getTags(compat2, "compat") : compat2 ? tags.getTags(null, compat2) : null;
-      this.name = typeof schema10 === "string" && schema10 || "core";
+      this.name = typeof schema11 === "string" && schema11 || "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(schema10, value, tagName, tagToken, onError) {
+  function findScalarTagByName(schema11, value, tagName, tagToken, onError) {
     if (tagName === "!")
-      return schema10[identity3.SCALAR];
+      return schema11[identity3.SCALAR];
     const matchWithTest = [];
-    for (const tag of schema10.tags) {
+    for (const tag of schema11.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 = schema10.knownTags[tagName];
+    const kt3 = schema11.knownTags[tagName];
     if (kt3 && !kt3.collection) {
-      schema10.tags.push(Object.assign({}, kt3, { default: false, test: undefined }));
+      schema11.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 schema10[identity3.SCALAR];
+    return 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];
+  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];
       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" ? join22(replacement, currentDoc.split(`
+  return mapDoc(doc2, (currentDoc) => typeof currentDoc === "string" ? join24(replacement, currentDoc.split(`
 `)) : currentDoc);
 }
 function canBreakFn(doc2) {
@@ -31238,7 +31238,7 @@ function indentIfBreak(contents, options) {
     negate: options.negate
   };
 }
-function join22(separator, docs) {
+function join24(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: join22,
+    join: join24,
     line,
     softline,
     hardline,
@@ -119560,11 +119560,11 @@ function chooseDescription(descriptions, printWidth) {
   return firstWidth > printWidth && firstWidth > secondWidth ? secondDescription : firstDescription;
 }
 function createSchema(SchemaConstructor, parameters) {
-  const schema10 = new SchemaConstructor(parameters);
-  const subSchema = Object.create(schema10);
+  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], schema10, 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 config12 = editorconfig_to_prettier_default(editorConfig);
-  return config12;
+  const config13 = editorconfig_to_prettier_default(editorConfig);
+  return config13;
 }
 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 config12 = await load2(configFile);
-  if (!config12) {
+  let config13 = await load2(configFile);
+  if (!config13) {
     return;
   }
-  if (typeof config12 === "string") {
-    config12 = await load_external_config_default(config12, configFile);
+  if (typeof config13 === "string") {
+    config13 = await load_external_config_default(config13, configFile);
   }
-  if (typeof config12 !== "object") {
-    throw new TypeError(`Config is only allowed to be an object, but received ${typeof config12} in "${configFile}"`);
+  if (typeof config13 !== "object") {
+    throw new TypeError(`Config is only allowed to be an object, but received ${typeof config13} in "${configFile}"`);
   }
-  delete config12.$schema;
-  return config12;
+  delete config13.$schema;
+  return config13;
 }
 function clearPrettierConfigCache() {
   loadCache.clear();
@@ -121873,8 +121873,8 @@ async function loadPrettierConfig2(file2, options8) {
     return;
   }
   configFile = toPath3(configFile);
-  const config12 = await loadPrettierConfig(configFile, { shouldCache });
-  return { config: config12, configFile };
+  const config13 = await loadPrettierConfig(configFile, { shouldCache });
+  return { config: config13, 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: config12, configFile } = configResult || {};
-  const { overrides, ...options8 } = config12 || {};
+  const { config: config13, configFile } = configResult || {};
+  const { overrides, ...options8 } = config13 || {};
   if (filePath && overrides) {
     const relativeFilePath = path102.relative(path102.dirname(configFile), filePath);
     for (const override of overrides) {
@@ -122718,12 +122718,12 @@ function getLanguageByFileName(languages2, file2) {
   if (!file2) {
     return;
   }
-  const basename6 = getFileBasename(file2).toLowerCase();
+  const basename7 = getFileBasename(file2).toLowerCase();
   return languages2.find(({
     filenames
-  }) => filenames?.some((name2) => name2.toLowerCase() === basename6)) ?? languages2.find(({
+  }) => filenames?.some((name2) => name2.toLowerCase() === basename7)) ?? languages2.find(({
     extensions
-  }) => extensions?.some((extension) => basename6.endsWith(extension)));
+  }) => extensions?.some((extension) => basename7.endsWith(extension)));
 }
 function getLanguageByLanguageName(languages2, languageName) {
   if (!languageName) {
@@ -122904,9 +122904,9 @@ function optionInfoToSchema(optionInfo, {
       throw new Error(`Unexpected type ${optionInfo.type}`);
   }
   if (optionInfo.exception) {
-    parameters.validate = (value, schema10, utils3) => optionInfo.exception(value) || schema10.validate(value, utils3);
+    parameters.validate = (value, schema11, utils3) => optionInfo.exception(value) || schema11.validate(value, utils3);
   } else {
-    parameters.validate = (value, schema10, utils3) => value === undefined || schema10.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, schema10, utils3) => schema10.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 config12;
+  let config13;
   if (options8.resolveConfig !== false) {
-    config12 = await resolveConfig(file2, {
+    config13 = await resolveConfig(file2, {
       editorconfig: false
     });
   }
-  if (config12?.parser) {
-    return config12.parser;
+  if (config13?.parser) {
+    return config13.parser;
   }
-  let plugins = options8.plugins ?? config12?.plugins ?? [];
+  let plugins = options8.plugins ?? config13?.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 schema10 = this._utils.schemas[key2];
+      const schema11 = this._utils.schemas[key2];
       if (!(key2 in newOptions)) {
-        const defaultResult = normalizeDefaultResult(schema10.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 schema10 = this._utils.schemas[key2];
+      const schema11 = this._utils.schemas[key2];
       const value = newOptions[key2];
-      const newValue = schema10.postprocess(value, this._utils);
+      const newValue = schema11.postprocess(value, this._utils);
       if (newValue === VALUE_UNCHANGED) {
         continue;
       }
-      this._applyValidation(newValue, key2, schema10);
+      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 schema10 = this._utils.schemas[key2];
-      const value = schema10.preprocess(options8[key2], this._utils);
-      this._applyValidation(value, key2, schema10);
+      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(schema10.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(schema10.forward(value, this._utils), value);
+      const forwardResult = normalizeForwardResult(schema11.forward(value, this._utils), value);
       forwardResult.forEach(appendTransferredOptions);
-      const redirectResult = normalizeRedirectResult(schema10.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 ? schema10.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, schema10) {
-    const validateResult = normalizeValidateResult(schema10.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 schema10 = this._utils.schemas[knownResultKey];
-          this._applyValidation(knownResultValue, knownResultKey, schema10);
+          const schema11 = this._utils.schemas[knownResultKey];
+          this._applyValidation(knownResultValue, knownResultKey, schema11);
           options8[knownResultKey] = knownResultValue;
         });
       }
@@ -127945,8 +127945,8 @@ var init_prettier = __esm(() => {
       }
       exports.endsWithSlashGlobStar = endsWithSlashGlobStar;
       function isAffectDepthOfReadingPattern(pattern) {
-        const basename6 = path152.basename(pattern);
-        return endsWithSlashGlobStar(pattern) || isStaticPattern(basename6);
+        const basename7 = path152.basename(pattern);
+        return endsWithSlashGlobStar(pattern) || isStaticPattern(basename7);
       }
       exports.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
       function expandPatternsWithBraceExpansion(patterns) {
@@ -136863,7 +136863,7 @@ Expected it to be ${EXPECTED_TYPE_VALUES}.`;
       return mapDoc2(doc2, (currentDoc) => cleanDocFn2(currentDoc));
     }
     function replaceEndOfLine2(doc2, replacement = literalline2) {
-      return mapDoc2(doc2, (currentDoc) => typeof currentDoc === "string" ? join24(replacement, currentDoc.split(`
+      return mapDoc2(doc2, (currentDoc) => typeof currentDoc === "string" ? join26(replacement, currentDoc.split(`
 `)) : currentDoc);
     }
     function canBreakFn2(doc2) {
@@ -136949,7 +136949,7 @@ Expected it to be ${EXPECTED_TYPE_VALUES}.`;
         negate: options8.negate
       };
     }
-    function join24(separator, docs) {
+    function join26(separator, docs) {
       assertDoc2(separator);
       assertDocArray2(docs);
       const parts = [];
@@ -137614,7 +137614,7 @@ Expected it to be ${EXPECTED_TYPE_VALUES}.`;
       }
     }
     var builders2 = {
-      join: join24,
+      join: join26,
       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)((schema10) => {
-    const parent = schema10[exports.Parent];
+  exports.getRootSchema = (0, lodash_1.memoize)((schema11) => {
+    const parent = schema11[exports.Parent];
     if (!parent) {
-      return schema10;
+      return schema11;
     }
     return (0, exports.getRootSchema)(parent);
   });
-  function isBoolean(schema10) {
-    return schema10 === true || schema10 === false;
+  function isBoolean(schema11) {
+    return schema11 === true || schema11 === false;
   }
   exports.isBoolean = isBoolean;
-  function isPrimitive(schema10) {
-    return !(0, lodash_1.isPlainObject)(schema10);
+  function isPrimitive(schema11) {
+    return !(0, lodash_1.isPlainObject)(schema11);
   }
   exports.isPrimitive = isPrimitive;
-  function isCompound(schema10) {
-    return Array.isArray(schema10.type) || "anyOf" in schema10 || "oneOf" in schema10;
+  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(schema10, name2) {
+  function compileList(schema11, name2) {
     var result = [];
-    schema10[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(schema10, 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 = schema10.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(schema10, callback, processed) {
-    if (typeof schema10 !== "object" || !schema10) {
+  function traverseIntersection(schema11, callback, processed) {
+    if (typeof schema11 !== "object" || !schema11) {
       return;
     }
-    const r5 = schema10;
+    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(schema10, callback, processed = new Set, key2) {
-    if (processed.has(schema10)) {
+  function traverse(schema11, callback, processed = new Set, key2) {
+    if (processed.has(schema11)) {
       return;
     }
-    processed.add(schema10);
-    callback(schema10, key2 !== null && key2 !== undefined ? key2 : null);
-    if (schema10.anyOf) {
-      traverseArray(schema10.anyOf, callback, processed);
+    processed.add(schema11);
+    callback(schema11, key2 !== null && key2 !== undefined ? key2 : null);
+    if (schema11.anyOf) {
+      traverseArray(schema11.anyOf, callback, processed);
     }
-    if (schema10.allOf) {
-      traverseArray(schema10.allOf, callback, processed);
+    if (schema11.allOf) {
+      traverseArray(schema11.allOf, callback, processed);
     }
-    if (schema10.oneOf) {
-      traverseArray(schema10.oneOf, callback, processed);
+    if (schema11.oneOf) {
+      traverseArray(schema11.oneOf, callback, processed);
     }
-    if (schema10.properties) {
-      traverseObjectKeys(schema10.properties, callback, processed);
+    if (schema11.properties) {
+      traverseObjectKeys(schema11.properties, callback, processed);
     }
-    if (schema10.patternProperties) {
-      traverseObjectKeys(schema10.patternProperties, callback, processed);
+    if (schema11.patternProperties) {
+      traverseObjectKeys(schema11.patternProperties, callback, processed);
     }
-    if (schema10.additionalProperties && typeof schema10.additionalProperties === "object") {
-      traverse(schema10.additionalProperties, callback, processed);
+    if (schema11.additionalProperties && typeof schema11.additionalProperties === "object") {
+      traverse(schema11.additionalProperties, callback, processed);
     }
-    if (schema10.items) {
-      const { items } = schema10;
+    if (schema11.items) {
+      const { items } = schema11;
       if (Array.isArray(items)) {
         traverseArray(items, callback, processed);
       } else {
         traverse(items, callback, processed);
       }
     }
-    if (schema10.additionalItems && typeof schema10.additionalItems === "object") {
-      traverse(schema10.additionalItems, callback, processed);
+    if (schema11.additionalItems && typeof schema11.additionalItems === "object") {
+      traverse(schema11.additionalItems, callback, processed);
     }
-    if (schema10.dependencies) {
-      if (Array.isArray(schema10.dependencies)) {
-        traverseArray(schema10.dependencies, callback, processed);
+    if (schema11.dependencies) {
+      if (Array.isArray(schema11.dependencies)) {
+        traverseArray(schema11.dependencies, callback, processed);
       } else {
-        traverseObjectKeys(schema10.dependencies, callback, processed);
+        traverseObjectKeys(schema11.dependencies, callback, processed);
       }
     }
-    if (schema10.definitions) {
-      traverseObjectKeys(schema10.definitions, callback, processed);
+    if (schema11.definitions) {
+      traverseObjectKeys(schema11.definitions, callback, processed);
     }
-    if (schema10.$defs) {
-      traverseObjectKeys(schema10.$defs, callback, processed);
+    if (schema11.$defs) {
+      traverseObjectKeys(schema11.$defs, callback, processed);
     }
-    if (schema10.not) {
-      traverse(schema10.not, callback, processed);
+    if (schema11.not) {
+      traverse(schema11.not, callback, processed);
     }
-    traverseIntersection(schema10, callback, processed);
-    Object.keys(schema10).filter((key3) => !BLACKLISTED_KEYS.has(key3)).forEach((key3) => {
-      const child = schema10[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(schema10) {
+  function escapeBlockComment(schema11) {
     const replacer = "* /";
-    if (schema10 === null || typeof schema10 !== "object") {
+    if (schema11 === null || typeof schema11 !== "object") {
       return;
     }
-    for (const key2 of Object.keys(schema10)) {
-      if (key2 === "description" && typeof schema10[key2] === "string") {
-        schema10[key2] = schema10[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(schema10) {
-    if (!("default" in schema10)) {
-      return schema10;
+  function maybeStripDefault(schema11) {
+    if (!("default" in schema11)) {
+      return schema11;
     }
-    switch (schema10.type) {
+    switch (schema11.type) {
       case "array":
-        if (Array.isArray(schema10.default)) {
-          return schema10;
+        if (Array.isArray(schema11.default)) {
+          return schema11;
         }
         break;
       case "boolean":
-        if (typeof schema10.default === "boolean") {
-          return schema10;
+        if (typeof schema11.default === "boolean") {
+          return schema11;
         }
         break;
       case "integer":
       case "number":
-        if (typeof schema10.default === "number") {
-          return schema10;
+        if (typeof schema11.default === "number") {
+          return schema11;
         }
         break;
       case "string":
-        if (typeof schema10.default === "string") {
-          return schema10;
+        if (typeof schema11.default === "string") {
+          return schema11;
         }
         break;
       case "null":
-        if (schema10.default === null) {
-          return schema10;
+        if (schema11.default === null) {
+          return schema11;
         }
         break;
       case "object":
-        if ((0, lodash_1.isPlainObject)(schema10.default)) {
-          return schema10;
+        if ((0, lodash_1.isPlainObject)(schema11.default)) {
+          return schema11;
         }
         break;
     }
-    delete schema10.default;
-    return schema10;
+    delete schema11.default;
+    return schema11;
   }
   exports.maybeStripDefault = maybeStripDefault;
   function appendToDescription(existingDescription, ...values) {
@@ -141424,11 +141424,11 @@ ${values.join(`
 `);
   }
   exports.appendToDescription = appendToDescription;
-  function isSchemaLike(schema10) {
-    if (!(0, lodash_1.isPlainObject)(schema10)) {
+  function isSchemaLike(schema11) {
+    if (!(0, lodash_1.isPlainObject)(schema11)) {
       return false;
     }
-    const parent = schema10[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] === schema10)) {
+    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(schema10) {
-    if (schema10.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(schema10)) {
+      if (f7(schema11)) {
         matchedTypes.add(schemaType);
       }
     }
@@ -141760,26 +141760,26 @@ var require_typesOfSchema = __commonJS((exports) => {
   }
   exports.typesOfSchema = typesOfSchema;
   var matchers = {
-    ALL_OF(schema10) {
-      return "allOf" in schema10;
+    ALL_OF(schema11) {
+      return "allOf" in schema11;
     },
-    ANY(schema10) {
-      if (Object.keys(schema10).length === 0) {
+    ANY(schema11) {
+      if (Object.keys(schema11).length === 0) {
         return true;
       }
-      return schema10.type === "any";
+      return schema11.type === "any";
     },
-    ANY_OF(schema10) {
-      return "anyOf" in schema10;
+    ANY_OF(schema11) {
+      return "anyOf" in schema11;
     },
-    BOOLEAN(schema10) {
-      if ("enum" in schema10) {
+    BOOLEAN(schema11) {
+      if ("enum" in schema11) {
         return false;
       }
-      if (schema10.type === "boolean") {
+      if (schema11.type === "boolean") {
         return true;
       }
-      if (!(0, JSONSchema_1.isCompound)(schema10) && typeof schema10.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(schema10) {
-      return "enum" in schema10 && "tsEnumNames" in schema10;
+    NAMED_ENUM(schema11) {
+      return "enum" in schema11 && "tsEnumNames" in schema11;
     },
-    NAMED_SCHEMA(schema10) {
-      return "$id" in schema10 && (("patternProperties" in schema10) || ("properties" in schema10));
+    NAMED_SCHEMA(schema11) {
+      return "$id" in schema11 && (("patternProperties" in schema11) || ("properties" in schema11));
     },
-    NEVER(schema10) {
-      return schema10 === false;
+    NEVER(schema11) {
+      return schema11 === false;
     },
-    NULL(schema10) {
-      return schema10.type === "null";
+    NULL(schema11) {
+      return schema11.type === "null";
     },
-    NUMBER(schema10) {
-      if ("enum" in schema10) {
+    NUMBER(schema11) {
+      if ("enum" in schema11) {
         return false;
       }
-      if (schema10.type === "integer" || schema10.type === "number") {
+      if (schema11.type === "integer" || schema11.type === "number") {
         return true;
       }
-      if (!(0, JSONSchema_1.isCompound)(schema10) && typeof schema10.default === "number") {
+      if (!(0, JSONSchema_1.isCompound)(schema11) && typeof schema11.default === "number") {
         return true;
       }
       return false;
     },
-    OBJECT(schema10) {
-      return schema10.type === "object" && !(0, lodash_1.isPlainObject)(schema10.additionalProperties) && !schema10.allOf && !schema10.anyOf && !schema10.oneOf && !schema10.patternProperties && !schema10.properties && !schema10.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(schema10) {
-      return "oneOf" in schema10;
+    ONE_OF(schema11) {
+      return "oneOf" in schema11;
     },
-    REFERENCE(schema10) {
-      return "$ref" in schema10;
+    REFERENCE(schema11) {
+      return "$ref" in schema11;
     },
-    STRING(schema10) {
-      if ("enum" in schema10) {
+    STRING(schema11) {
+      if ("enum" in schema11) {
         return false;
       }
-      if (schema10.type === "string") {
+      if (schema11.type === "string") {
         return true;
       }
-      if (!(0, JSONSchema_1.isCompound)(schema10) && typeof schema10.default === "string") {
+      if (!(0, JSONSchema_1.isCompound)(schema11) && typeof schema11.default === "string") {
         return true;
       }
       return false;
     },
-    TYPED_ARRAY(schema10) {
-      if (schema10.type && schema10.type !== "array") {
+    TYPED_ARRAY(schema11) {
+      if (schema11.type && schema11.type !== "array") {
         return false;
       }
-      return "items" in schema10;
+      return "items" in schema11;
     },
-    UNION(schema10) {
-      return Array.isArray(schema10.type);
+    UNION(schema11) {
+      return Array.isArray(schema11.type);
     },
-    UNNAMED_ENUM(schema10) {
-      if ("tsEnumNames" in schema10) {
+    UNNAMED_ENUM(schema11) {
+      if ("tsEnumNames" in schema11) {
         return false;
       }
-      if (schema10.type && schema10.type !== "boolean" && schema10.type !== "integer" && schema10.type !== "number" && schema10.type !== "string") {
+      if (schema11.type && schema11.type !== "boolean" && schema11.type !== "integer" && schema11.type !== "number" && schema11.type !== "string") {
         return false;
       }
-      return "enum" in schema10;
+      return "enum" in schema11;
     },
     UNNAMED_SCHEMA() {
       return false;
     },
-    UNTYPED_ARRAY(schema10) {
-      return schema10.type === "array" && !("items" in schema10);
+    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(schema10) {
+  function applySchemaTyping(schema11) {
     var _a7;
-    const types = (0, typesOfSchema_1.typesOfSchema)(schema10);
-    Object.defineProperty(schema10, 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]: schema10,
+      [JSONSchema_1.Parent]: schema11,
       [JSONSchema_1.Types]: new Set(["ALL_OF"]),
-      $id: schema10.$id,
-      description: schema10.description,
-      name: schema10.name,
-      title: schema10.title,
-      allOf: (_a7 = schema10.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 schema10.allOf;
-    delete schema10.$id;
-    delete schema10.description;
-    delete schema10.name;
-    delete schema10.title;
-    Object.defineProperty(schema10, 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(schema10, type) {
-    return schema10.type === type || Array.isArray(schema10.type) && schema10.type.includes(type);
+  function hasType(schema11, type) {
+    return schema11.type === type || Array.isArray(schema11.type) && schema11.type.includes(type);
   }
-  function isObjectType(schema10) {
-    return schema10.properties !== undefined || hasType(schema10, "object") || hasType(schema10, "any");
+  function isObjectType(schema11) {
+    return schema11.properties !== undefined || hasType(schema11, "object") || hasType(schema11, "any");
   }
-  function isArrayType(schema10) {
-    return schema10.items !== undefined || hasType(schema10, "array") || hasType(schema10, "any");
+  function isArrayType(schema11) {
+    return schema11.items !== undefined || hasType(schema11, "array") || hasType(schema11, "any");
   }
-  function isEnumTypeWithoutTsEnumNames(schema10) {
-    return schema10.type === "string" && schema10.enum !== undefined && schema10.tsEnumNames === undefined;
+  function isEnumTypeWithoutTsEnumNames(schema11) {
+    return schema11.type === "string" && schema11.enum !== undefined && schema11.tsEnumNames === undefined;
   }
-  rules.set('Remove `type=["null"]` if `enum=[null]`', (schema10) => {
-    if (Array.isArray(schema10.enum) && schema10.enum.some((e8) => e8 === null) && Array.isArray(schema10.type) && schema10.type.includes("null")) {
-      schema10.type = schema10.type.filter((type) => type !== "null");
+  rules.set('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", (schema10) => {
-    if (schema10.type && Array.isArray(schema10.type) && schema10.type.length === 1) {
-      schema10.type = schema10.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", (schema10) => {
-    if (isObjectType(schema10) && !("required" in schema10)) {
-      schema10.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`=[]", (schema10) => {
-    if (schema10.required === false) {
-      schema10.required = [];
+  rules.set("Transform `required`=false to `required`=[]", (schema11) => {
+    if (schema11.required === false) {
+      schema11.required = [];
     }
   });
-  rules.set("Default additionalProperties", (schema10, _10, options8) => {
-    if (isObjectType(schema10) && !("additionalProperties" in schema10) && schema10.patternProperties === undefined) {
-      schema10.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", (schema10, fileName) => {
-    if (!(0, utils_1.isSchemaLike)(schema10)) {
+  rules.set("Transform id to $id", (schema11, fileName) => {
+    if (!(0, utils_1.isSchemaLike)(schema11)) {
       return;
     }
-    if (schema10.id && schema10.$id && schema10.id !== schema10.$id) {
-      throw ReferenceError(`Schema must define either id or $id, not both. Given id=${schema10.id}, $id=${schema10.$id} in ${fileName}`);
+    if (schema11.id && schema11.$id && schema11.id !== schema11.$id) {
+      throw ReferenceError(`Schema must define either id or $id, not both. Given id=${schema11.id}, $id=${schema11.$id} in ${fileName}`);
     }
-    if (schema10.id) {
-      schema10.$id = schema10.id;
-      delete schema10.id;
+    if (schema11.id) {
+      schema11.$id = schema11.id;
+      delete schema11.id;
     }
   });
-  rules.set("Add an $id to anything that needs it", (schema10, fileName, _options, _key, dereferencedPaths) => {
-    if (!(0, utils_1.isSchemaLike)(schema10)) {
+  rules.set("Add an $id to anything that needs it", (schema11, fileName, _options, _key, dereferencedPaths) => {
+    if (!(0, utils_1.isSchemaLike)(schema11)) {
       return;
     }
-    if (!schema10.$id && !schema10[JSONSchema_1.Parent]) {
-      schema10.$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(schema10) && !isObjectType(schema10)) {
+    if (!isArrayType(schema11) && !isObjectType(schema11)) {
       return;
     }
-    const dereferencedName = dereferencedPaths.get(schema10);
-    if (!schema10.$id && !schema10.title && dereferencedName) {
-      schema10.$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(schema10);
+      dereferencedPaths.delete(schema11);
     }
   });
-  rules.set("Escape closing JSDoc comment", (schema10) => {
-    (0, utils_1.escapeBlockComment)(schema10);
+  rules.set("Escape closing JSDoc comment", (schema11) => {
+    (0, utils_1.escapeBlockComment)(schema11);
   });
-  rules.set("Add JSDoc comments for minItems and maxItems", (schema10) => {
-    if (!isArrayType(schema10)) {
+  rules.set("Add JSDoc comments for minItems and maxItems", (schema11) => {
+    if (!isArrayType(schema11)) {
       return;
     }
     const commentsToAppend = [
-      "minItems" in schema10 ? `@minItems ${schema10.minItems}` : "",
-      "maxItems" in schema10 ? `@maxItems ${schema10.maxItems}` : ""
+      "minItems" in schema11 ? `@minItems ${schema11.minItems}` : "",
+      "maxItems" in schema11 ? `@maxItems ${schema11.maxItems}` : ""
     ].filter(Boolean);
     if (commentsToAppend.length) {
-      schema10.description = (0, utils_1.appendToDescription)(schema10.description, ...commentsToAppend);
+      schema11.description = (0, utils_1.appendToDescription)(schema11.description, ...commentsToAppend);
     }
   });
-  rules.set("Optionally remove maxItems and minItems", (schema10, _fileName, options8) => {
-    if (!isArrayType(schema10)) {
+  rules.set("Optionally remove maxItems and minItems", (schema11, _fileName, options8) => {
+    if (!isArrayType(schema11)) {
       return;
     }
-    if ("minItems" in schema10 && options8.ignoreMinAndMaxItems) {
-      delete schema10.minItems;
+    if ("minItems" in schema11 && options8.ignoreMinAndMaxItems) {
+      delete schema11.minItems;
     }
-    if ("maxItems" in schema10 && (options8.ignoreMinAndMaxItems || options8.maxItems === -1)) {
-      delete schema10.maxItems;
+    if ("maxItems" in schema11 && (options8.ignoreMinAndMaxItems || options8.maxItems === -1)) {
+      delete schema11.maxItems;
     }
   });
-  rules.set("Normalize schema.minItems", (schema10, _fileName, options8) => {
+  rules.set("Normalize schema.minItems", (schema11, _fileName, options8) => {
     if (options8.ignoreMinAndMaxItems) {
       return;
     }
-    if (!isArrayType(schema10)) {
+    if (!isArrayType(schema11)) {
       return;
     }
-    const { minItems } = schema10;
-    schema10.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", (schema10, _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(schema10)) {
+    if (!isArrayType(schema11)) {
       return;
     }
-    const { maxItems, minItems } = schema10;
+    const { maxItems, minItems } = schema11;
     if (maxItems !== undefined && maxItems - minItems > options8.maxItems) {
-      delete schema10.maxItems;
+      delete schema11.maxItems;
     }
   });
-  rules.set("Normalize schema.items", (schema10, _fileName, options8) => {
+  rules.set("Normalize schema.items", (schema11, _fileName, options8) => {
     if (options8.ignoreMinAndMaxItems) {
       return;
     }
-    const { maxItems, minItems } = schema10;
+    const { maxItems, minItems } = schema11;
     const hasMaxItems = typeof maxItems === "number" && maxItems >= 0;
     const hasMinItems = typeof minItems === "number" && minItems > 0;
-    if (schema10.items && !Array.isArray(schema10.items) && (hasMaxItems || hasMinItems)) {
-      const items = schema10.items;
+    if (schema11.items && !Array.isArray(schema11.items) && (hasMaxItems || hasMinItems)) {
+      const items = schema11.items;
       const newItems = Array(maxItems || minItems || 0).fill(items);
       if (!hasMaxItems) {
-        schema10.additionalItems = items;
+        schema11.additionalItems = items;
       }
-      schema10.items = newItems;
+      schema11.items = newItems;
     }
-    if (Array.isArray(schema10.items) && hasMaxItems && maxItems < schema10.items.length) {
-      schema10.items = schema10.items.slice(0, maxItems);
+    if (Array.isArray(schema11.items) && hasMaxItems && maxItems < schema11.items.length) {
+      schema11.items = schema11.items.slice(0, maxItems);
     }
-    return schema10;
+    return schema11;
   });
-  rules.set("Remove extends, if it is empty", (schema10) => {
-    if (!schema10.hasOwnProperty("extends")) {
+  rules.set("Remove extends, if it is empty", (schema11) => {
+    if (!schema11.hasOwnProperty("extends")) {
       return;
     }
-    if (schema10.extends == null || Array.isArray(schema10.extends) && schema10.extends.length === 0) {
-      delete schema10.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", (schema10) => {
-    if (schema10.extends == null) {
+  rules.set("Make extends always an array, if it is defined", (schema11) => {
+    if (schema11.extends == null) {
       return;
     }
-    if (!Array.isArray(schema10.extends)) {
-      schema10.extends = [schema10.extends];
+    if (!Array.isArray(schema11.extends)) {
+      schema11.extends = [schema11.extends];
     }
   });
-  rules.set("Transform definitions to $defs", (schema10, fileName) => {
-    if (schema10.definitions && schema10.$defs && !(0, util_1.isDeepStrictEqual)(schema10.definitions, schema10.$defs)) {
-      throw ReferenceError(`Schema must define either definitions or $defs, not both. Given id=${schema10.id} in ${fileName}`);
+  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 (schema10.definitions) {
-      schema10.$defs = schema10.definitions;
-      delete schema10.definitions;
+    if (schema11.definitions) {
+      schema11.$defs = schema11.definitions;
+      delete schema11.definitions;
     }
   });
-  rules.set("Transform const to singleton enum", (schema10) => {
-    if (schema10.const !== undefined) {
-      schema10.enum = [schema10.const];
-      delete schema10.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", (schema10, _10, options8) => {
+  rules.set("Add tsEnumNames to enum types", (schema11, _10, options8) => {
     var _a7;
-    if (isEnumTypeWithoutTsEnumNames(schema10) && options8.inferStringEnumKeysFromValues) {
-      schema10.tsEnumNames = (_a7 = schema10.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", (schema10) => {
-    if (schema10 !== null && typeof schema10 === "object") {
-      (0, applySchemaTyping_1.applySchemaTyping)(schema10);
+  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, (schema10, key2) => rule(schema10, 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(schema10, options8, keyName, processed = new Map, usedNames = new Set) {
-    if ((0, JSONSchema_1.isPrimitive)(schema10)) {
-      if ((0, JSONSchema_1.isBoolean)(schema10)) {
-        return parseBooleanSchema(schema10, keyName, options8);
+  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(schema10, keyName);
+      return parseLiteral(schema11, keyName);
     }
-    const intersection2 = schema10[JSONSchema_1.Intersection];
-    const types = schema10[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(schema10, type, options8, keyName, processed, usedNames));
+        ast.params.push(parseAsTypeWithCache(schema11, type, options8, keyName, processed, usedNames));
       });
-      (0, utils_1.log)("blue", "parser", "Types:", [...types], "Input:", schema10, "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(schema10, type, options8, keyName, processed, usedNames);
-      (0, utils_1.log)("blue", "parser", "Type:", type, "Input:", schema10, "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(schema10, type, options8, keyName, processed = new Map, usedNames = new Set) {
-    let cachedTypeMap = processed.get(schema10);
+  function parseAsTypeWithCache(schema11, type, options8, keyName, processed = new Map, usedNames = new Set) {
+    let cachedTypeMap = processed.get(schema11);
     if (!cachedTypeMap) {
       cachedTypeMap = new Map;
-      processed.set(schema10, 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(schema10, type, options8, keyName, processed, usedNames));
+    return Object.assign(ast, parseNonLiteral(schema11, type, options8, keyName, processed, usedNames));
   }
-  function parseBooleanSchema(schema10, keyName, options8) {
-    if (schema10) {
+  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(schema10, keyName) {
+  function parseLiteral(schema11, keyName) {
     return {
       keyName,
-      params: schema10,
+      params: schema11,
       type: "LITERAL"
     };
   }
-  function parseNonLiteral(schema10, type, options8, keyName, processed, usedNames) {
-    const definitions = getDefinitionsMemoized((0, JSONSchema_1.getRootSchema)(schema10));
-    const keyNameFromDefinition = (0, lodash_1.findKey)(definitions, (_10) => _10 === schema10);
+  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: schema10.description,
-          deprecated: schema10.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
-          params: schema10.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: schema10.description, deprecated: schema10.deprecated, keyName, standaloneName: standaloneName(schema10, 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: schema10.description,
-          deprecated: schema10.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
-          params: schema10.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: schema10.description,
-          deprecated: schema10.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
           type: "BOOLEAN"
         };
       case "CUSTOM_TYPE":
         return {
-          comment: schema10.description,
-          deprecated: schema10.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          params: schema10.tsType,
-          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
+          params: schema11.tsType,
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
           type: "CUSTOM_TYPE"
         };
       case "NAMED_ENUM":
         return {
-          comment: schema10.description,
-          deprecated: schema10.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema10, keyNameFromDefinition !== null && keyNameFromDefinition !== undefined ? keyNameFromDefinition : keyName, usedNames, options8),
-          params: schema10.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: schema10.tsEnumNames[n5]
+            keyName: schema11.tsEnumNames[n5]
           })),
           type: "ENUM"
         };
       case "NAMED_SCHEMA":
-        return newInterface(schema10, options8, processed, usedNames, keyName);
+        return newInterface(schema11, options8, processed, usedNames, keyName);
       case "NEVER":
         return {
-          comment: schema10.description,
-          deprecated: schema10.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
           type: "NEVER"
         };
       case "NULL":
         return {
-          comment: schema10.description,
-          deprecated: schema10.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
           type: "NULL"
         };
       case "NUMBER":
         return {
-          comment: schema10.description,
-          deprecated: schema10.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
           type: "NUMBER"
         };
       case "OBJECT":
         return {
-          comment: schema10.description,
+          comment: schema11.description,
           keyName,
-          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
           type: "OBJECT",
-          deprecated: schema10.deprecated
+          deprecated: schema11.deprecated
         };
       case "ONE_OF":
         return {
-          comment: schema10.description,
-          deprecated: schema10.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
-          params: schema10.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!", schema10));
+        throw Error((0, util_1.format)("Refs should have been resolved by the resolver!", schema11));
       case "STRING":
         return {
-          comment: schema10.description,
-          deprecated: schema10.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
           type: "STRING"
         };
       case "TYPED_ARRAY":
-        if (Array.isArray(schema10.items)) {
-          const minItems2 = schema10.minItems;
-          const maxItems2 = schema10.maxItems;
+        if (Array.isArray(schema11.items)) {
+          const minItems2 = schema11.minItems;
+          const maxItems2 = schema11.maxItems;
           const arrayType = {
-            comment: schema10.description,
-            deprecated: schema10.deprecated,
+            comment: schema11.description,
+            deprecated: schema11.deprecated,
             keyName,
             maxItems: maxItems2,
             minItems: minItems2,
-            standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
-            params: schema10.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 (schema10.additionalItems === true) {
+          if (schema11.additionalItems === true) {
             arrayType.spreadParam = options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY;
-          } else if (schema10.additionalItems) {
-            arrayType.spreadParam = parse11(schema10.additionalItems, options8, undefined, processed, usedNames);
+          } else if (schema11.additionalItems) {
+            arrayType.spreadParam = parse11(schema11.additionalItems, options8, undefined, processed, usedNames);
           }
           return arrayType;
         } else {
           return {
-            comment: schema10.description,
-            deprecated: schema10.deprecated,
+            comment: schema11.description,
+            deprecated: schema11.deprecated,
             keyName,
-            standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
-            params: parse11(schema10.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: schema10.description,
-          deprecated: schema10.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
-          params: schema10.type.map((type2) => {
-            const member = Object.assign(Object.assign({}, (0, lodash_1.omit)(schema10, "$id", "description", "title")), { type: type2 });
+          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: schema10.description,
-          deprecated: schema10.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
-          params: schema10.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(schema10, options8, processed, usedNames, keyName, keyNameFromDefinition);
+        return newInterface(schema11, options8, processed, usedNames, keyName, keyNameFromDefinition);
       case "UNTYPED_ARRAY":
-        const minItems = schema10.minItems;
-        const maxItems = typeof schema10.maxItems === "number" ? schema10.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: schema10.description,
-            deprecated: schema10.deprecated,
+            comment: schema11.description,
+            deprecated: schema11.deprecated,
             keyName,
-            maxItems: schema10.maxItems,
+            maxItems: schema11.maxItems,
             minItems,
             params: Array(Math.max(maxItems, minItems) || 0).fill(params),
             spreadParam: maxItems >= 0 ? undefined : params,
-            standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
+            standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
             type: "TUPLE"
           };
         }
         return {
-          comment: schema10.description,
-          deprecated: schema10.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
           params,
-          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
           type: "ARRAY"
         };
     }
   }
-  function standaloneName(schema10, keyNameFromDefinition, usedNames, options8) {
+  function standaloneName(schema11, keyNameFromDefinition, usedNames, options8) {
     var _a7;
-    const name2 = ((_a7 = options8.customName) === null || _a7 === undefined ? undefined : _a7.call(options8, schema10, keyNameFromDefinition)) || schema10.title || schema10.$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(schema10, options8, processed, usedNames, keyName, keyNameFromDefinition) {
-    const name2 = standaloneName(schema10, keyNameFromDefinition, usedNames, options8);
+  function newInterface(schema11, options8, processed, usedNames, keyName, keyNameFromDefinition) {
+    const name2 = standaloneName(schema11, keyNameFromDefinition, usedNames, options8);
     return {
-      comment: schema10.description,
-      deprecated: schema10.deprecated,
+      comment: schema11.description,
+      deprecated: schema11.deprecated,
       keyName,
-      params: parseSchema(schema10, options8, processed, usedNames, name2),
+      params: parseSchema(schema11, options8, processed, usedNames, name2),
       standaloneName: name2,
-      superTypes: parseSuperTypes(schema10, options8, processed, usedNames),
+      superTypes: parseSuperTypes(schema11, options8, processed, usedNames),
       type: "INTERFACE"
     };
   }
-  function parseSuperTypes(schema10, options8, processed, usedNames) {
-    const superTypes = schema10.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(schema10, options8, processed, usedNames, parentSchemaName) {
-    let asts = (0, lodash_1.map)(schema10.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)(schema10.required || [], key2),
+      isRequired: (0, lodash_1.includes)(schema11.required || [], key2),
       isUnreachableDefinition: false,
       keyName: key2
     }));
     let singlePatternProperty = false;
-    if (schema10.patternProperties) {
-      singlePatternProperty = !schema10.additionalProperties && Object.keys(schema10.patternProperties).length === 1;
-      asts = asts.concat((0, lodash_1.map)(schema10.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)(schema10.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)(schema10.$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)(schema10.required || [], key2),
+          isRequired: (0, lodash_1.includes)(schema11.required || [], key2),
           isUnreachableDefinition: true,
           keyName: key2
         };
       }));
     }
-    switch (schema10.additionalProperties) {
+    switch (schema11.additionalProperties) {
       case undefined:
       case true:
         if (singlePatternProperty) {
@@ -142506,7 +142506,7 @@ ${comment}` : comment;
         return asts;
       default:
         return asts.concat({
-          ast: parse11(schema10.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(schema10, isSchema = true, processed = new Set) {
-    if (processed.has(schema10)) {
+  function getDefinitions(schema11, isSchema = true, processed = new Set) {
+    if (processed.has(schema11)) {
       return {};
     }
-    processed.add(schema10);
-    if (Array.isArray(schema10)) {
-      return schema10.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)(schema10)) {
-      return Object.assign(Object.assign({}, isSchema && hasDefinitions(schema10) ? schema10.$defs : {}), Object.keys(schema10).reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(schema10[cur], false, processed)), {}));
+    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(schema10) {
-    return "$defs" in schema10;
+  function hasDefinitions(schema11) {
+    return "$defs" in schema11;
   }
 });
 
@@ -142954,7 +142954,7 @@ var require_url = __commonJS((exports) => {
   exports.fromFileSystemPath = fromFileSystemPath;
   exports.toFileSystemPath = toFileSystemPath;
   exports.safePointerToPath = safePointerToPath;
-  exports.relative = relative4;
+  exports.relative = relative6;
   var convert_path_to_posix_1 = __importDefault(require_convert_path_to_posix());
   var path_1 = __importStar(__require("path"));
   var forwardSlashPattern = /\//g;
@@ -143104,7 +143104,7 @@ var require_url = __commonJS((exports) => {
       return decodeURIComponent(value).replace(jsonPointerSlash, "/").replace(jsonPointerTilde, "~");
     });
   }
-  function relative4(from, to5) {
+  function relative6(from, to5) {
     if (!isFileSystemPath(from) || !isFileSystemPath(to5)) {
       return resolve12(from, to5);
     }
@@ -144353,7 +144353,7 @@ var require_normalize_args = __commonJS((exports) => {
   var options_js_1 = require_options();
   function normalizeArgs(_args) {
     let path18;
-    let schema10;
+    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") {
-        schema10 = args[1];
+        schema11 = args[1];
         options8 = args[2];
       } else {
-        schema10 = undefined;
+        schema11 = undefined;
         options8 = args[1];
       }
     } else {
       path18 = "";
-      schema10 = 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 schema10 === "object") {
-      schema10 = JSON.parse(JSON.stringify(schema10));
+    if (!options8.mutateInputSchema && typeof schema11 === "object") {
+      schema11 = JSON.parse(JSON.stringify(schema11));
     }
     return {
       path: path18,
-      schema: schema10,
+      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* (schema10, { cwd, $refOptions }) {
-      (0, utils_1.log)("green", "dereferencer", "Dereferencing input schema:", cwd, schema10);
+    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, schema10, Object.assign(Object.assign({}, $refOptions), { dereference: Object.assign(Object.assign({}, $refOptions.dereference), { onDereference($ref, schema11) {
-        dereferencedPaths.set(schema11, $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", (schema10) => {
-    if (schema10.enum && schema10.tsEnumNames && schema10.enum.length !== schema10.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", (schema10) => {
-    if (schema10.tsEnumNames && schema10.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", (schema10) => {
-    const { maxItems, minItems } = schema10;
+  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", (schema10) => {
-    const { maxItems } = schema10;
+  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", (schema10) => {
-    const { minItems } = schema10;
+  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", (schema10) => {
-    const typeOfDeprecated = typeof schema10.deprecated;
+  rules.set("deprecated must be a boolean", (schema11) => {
+    const typeOfDeprecated = typeof schema11.deprecated;
     return typeOfDeprecated === "boolean" || typeOfDeprecated === "undefined";
   });
-  function validate2(schema10, filename) {
+  function validate2(schema11, filename) {
     const errors5 = [];
     rules.forEach((rule, ruleName) => {
-      (0, utils_1.traverse)(schema10, (schema11, key2) => {
-        if (rule(schema11) === false) {
+      (0, utils_1.traverse)(schema11, (schema12, key2) => {
+        if (rule(schema12) === false) {
           errors5.push(`Error at key "${key2}" in file "${filename}": ${ruleName}`);
         }
-        return schema11;
+        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(schema10, parent = null) {
-    if (!Array.isArray(schema10) && !(0, lodash_1.isPlainObject)(schema10)) {
-      return schema10;
+  function link2(schema11, parent = null) {
+    if (!Array.isArray(schema11) && !(0, lodash_1.isPlainObject)(schema11)) {
+      return schema11;
     }
-    if (schema10.hasOwnProperty(JSONSchema_1.Parent)) {
-      return schema10;
+    if (schema11.hasOwnProperty(JSONSchema_1.Parent)) {
+      return schema11;
     }
-    Object.defineProperty(schema10, JSONSchema_1.Parent, {
+    Object.defineProperty(schema11, JSONSchema_1.Parent, {
       enumerable: false,
       value: parent,
       writable: false
     });
-    if (Array.isArray(schema10)) {
-      schema10.forEach((child) => link2(child, schema10));
+    if (Array.isArray(schema11)) {
+      schema11.forEach((child) => link2(child, schema11));
     }
-    for (const key2 in schema10) {
-      link2(schema10[key2], schema10);
+    for (const key2 in schema11) {
+      link2(schema11[key2], schema11);
     }
-    return schema10;
+    return schema11;
   }
   exports.link = link2;
 });
@@ -145355,8 +145355,8 @@ var require_src3 = __commonJS((exports) => {
     unknownAny: true
   };
   function compileFromFile(filename, options8 = exports.DEFAULT_OPTIONS) {
-    const schema10 = parseAsJSONSchema(filename);
-    return compile(schema10, (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* (schema10, 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)(schema10);
+      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)) {
@@ -146286,7 +146286,7 @@ var require_depd = __commonJS((exports, module) => {
    * Copyright(c) 2014-2018 Douglas Christopher Wilson
    * MIT Licensed
    */
-  var relative4 = __require("path").relative;
+  var relative6 = __require("path").relative;
   module.exports = depd;
   var basePath = process.cwd();
   function containsNamespace(str, namespace) {
@@ -146482,7 +146482,7 @@ var require_depd = __commonJS((exports, module) => {
     return formatted;
   }
   function formatLocation(callSite) {
-    return relative4(basePath, callSite[0]) + ":" + callSite[1] + ":" + callSite[2];
+    return relative6(basePath, callSite[0]) + ":" + callSite[1] + ":" + callSite[2];
   }
   function getStack() {
     var limit = Error.stackTraceLimit;
@@ -163944,10 +163944,10 @@ var require_view = __commonJS((exports, module) => {
   var debug = require_src4()("express:view");
   var path18 = __require("node:path");
   var fs28 = __require("node:fs");
-  var dirname19 = path18.dirname;
-  var basename6 = path18.basename;
+  var dirname22 = path18.dirname;
+  var basename7 = path18.basename;
   var extname2 = path18.extname;
-  var join25 = path18.join;
+  var join28 = path18.join;
   var resolve12 = path18.resolve;
   module.exports = View;
   function View(name2, options8) {
@@ -163983,8 +163983,8 @@ var require_view = __commonJS((exports, module) => {
     for (var i5 = 0;i5 < roots.length && !path19; i5++) {
       var root2 = roots[i5];
       var loc = resolve12(root2, name2);
-      var dir = dirname19(loc);
-      var file2 = basename6(loc);
+      var dir = dirname22(loc);
+      var file2 = basename7(loc);
       path19 = this.resolve(dir, file2);
     }
     return path19;
@@ -164009,12 +164009,12 @@ var require_view = __commonJS((exports, module) => {
   };
   View.prototype.resolve = function resolve13(dir, file2) {
     var ext = this.ext;
-    var path19 = join25(dir, file2);
+    var path19 = join28(dir, file2);
     var stat2 = tryStat(path19);
     if (stat2 && stat2.isFile()) {
       return path19;
     }
-    path19 = join25(dir, basename6(file2, ext), "index" + ext);
+    path19 = join28(dir, basename7(file2, ext), "index" + ext);
     stat2 = tryStat(path19);
     if (stat2 && stat2.isFile()) {
       return path19;
@@ -167335,7 +167335,7 @@ var require_content_disposition = __commonJS((exports, module) => {
    */
   module.exports = contentDisposition;
   module.exports.parse = parse11;
-  var basename6 = __require("path").basename;
+  var basename7 = __require("path").basename;
   var ENCODE_URL_ATTR_CHAR_REGEXP = /[\x00-\x20"'()*,/:;<=>?@[\\\]{}\x7f]/g;
   var HEX_ESCAPE_REGEXP = /%[0-9A-Fa-f]{2}/;
   var HEX_ESCAPE_REPLACE_REGEXP = /%([0-9A-Fa-f]{2})/g;
@@ -167370,9 +167370,9 @@ var require_content_disposition = __commonJS((exports, module) => {
     if (typeof fallback === "string" && NON_LATIN1_REGEXP.test(fallback)) {
       throw new TypeError("fallback must be ISO-8859-1 string");
     }
-    var name2 = basename6(filename);
+    var name2 = basename7(filename);
     var isQuotedString = TEXT_REGEXP.test(name2);
-    var fallbackName = typeof fallback !== "string" ? fallback && getlatin1(name2) : basename6(fallback);
+    var fallbackName = typeof fallback !== "string" ? fallback && getlatin1(name2) : basename7(fallback);
     var hasFallback = typeof fallbackName === "string" && fallbackName !== name2;
     if (hasFallback || !isQuotedString || HEX_ESCAPE_REGEXP.test(name2)) {
       params["filename*"] = name2;
@@ -167709,7 +167709,7 @@ var require_send = __commonJS((exports, module) => {
   var Stream2 = __require("stream");
   var util2 = __require("util");
   var extname2 = path18.extname;
-  var join25 = path18.join;
+  var join28 = path18.join;
   var normalize2 = path18.normalize;
   var resolve12 = path18.resolve;
   var sep = path18.sep;
@@ -167881,7 +167881,7 @@ var require_send = __commonJS((exports, module) => {
         return res;
       }
       parts = path19.split(sep);
-      path19 = normalize2(join25(root2, path19));
+      path19 = normalize2(join28(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 = join25(path19, self2._index[i5]);
+      var p4 = join28(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, config12, property) {
+  common2.rewriteCookieProperty = function rewriteCookieProperty(header2, config13, property) {
     if (Array.isArray(header2)) {
       return header2.map(function(headerElement) {
-        return rewriteCookieProperty(headerElement, config12, property);
+        return rewriteCookieProperty(headerElement, config13, property);
       });
     }
     return header2.replace(new RegExp("(;\\s*" + property + "=)([^;]+)", "i"), function(match, prefix, previousValue) {
       var newValue;
-      if (previousValue in config12) {
-        newValue = config12[previousValue];
-      } else if ("*" in config12) {
-        newValue = config12["*"];
+      if (previousValue in config13) {
+        newValue = config13[previousValue];
+      } else if ("*" in config13) {
+        newValue = config13["*"];
       } else {
         return match;
       }
@@ -169630,8 +169630,8 @@ var require_follow_redirects = __commonJS((exports, module) => {
     }
     return parsed;
   }
-  function resolveUrl(relative4, base) {
-    return useNativeURL ? new URL2(relative4, base) : parseUrl(url3.resolve(base, relative4));
+  function resolveUrl(relative6, base) {
+    return useNativeURL ? new URL2(relative6, base) : parseUrl(url3.resolve(base, relative6));
   }
   function validateUrl(input) {
     if (/^\[/.test(input.hostname) && !/^\[[:0-9a-f]+\]$/i.test(input.hostname)) {
@@ -170495,9 +170495,9 @@ var require_router2 = __commonJS((exports) => {
   var is_plain_object_1 = require_is_plain_object();
   var debug_1 = require_debug4();
   var debug = debug_1.Debug.extend("router");
-  async function getTarget(req, config12) {
+  async function getTarget(req, config13) {
     let newTarget;
-    const router = config12.router;
+    const router = config13.router;
     if ((0, is_plain_object_1.isPlainObject)(router)) {
       newTarget = getTargetFromProxyTable(req, router);
     } else if (typeof router === "function") {
@@ -171269,8 +171269,8 @@ var require_tmp = __commonJS((exports, module) => {
       const name2 = options8.name;
       if (path18.isAbsolute(name2))
         throw new Error(`name option must not contain an absolute path, found "${name2}".`);
-      const basename6 = path18.basename(name2);
-      if (basename6 === ".." || basename6 === "." || basename6 !== name2)
+      const basename7 = path18.basename(name2);
+      if (basename7 === ".." || basename7 === "." || basename7 !== name2)
         throw new Error(`name option must not contain a path, found "${name2}".`);
     }
     if (!_isUndefined(options8.template) && !options8.template.match(TEMPLATE_PATTERN)) {
@@ -210550,7 +210550,7 @@ var require_utils12 = __commonJS((exports, module) => {
     if (decode4)
       return decode4(data, hint);
   }
-  function basename6(path18) {
+  function basename7(path18) {
     if (typeof path18 !== "string")
       return "";
     for (let i5 = path18.length - 1;i5 >= 0; --i5) {
@@ -211854,7 +211854,7 @@ var require_utils12 = __commonJS((exports, module) => {
     -1
   ];
   module.exports = {
-    basename: basename6,
+    basename: basename7,
     convertToUTF8,
     getDecoder,
     parseContentType,
@@ -212262,7 +212262,7 @@ var require_multipart = __commonJS((exports, module) => {
   var { Readable: Readable6, Writable: Writable4 } = __require("stream");
   var StreamSearch = require_sbmh();
   var {
-    basename: basename6,
+    basename: basename7,
     convertToUTF8,
     getDecoder,
     parseContentType,
@@ -212524,7 +212524,7 @@ var require_multipart = __commonJS((exports, module) => {
           else if (disp.params.filename)
             filename = disp.params.filename;
           if (filename !== undefined && !preservePath)
-            filename = basename6(filename);
+            filename = basename7(filename);
         }
         if (header2["content-type"]) {
           const conType = parseContentType(header2["content-type"][0]);
@@ -214616,7 +214616,7 @@ var require_buffer_list = __commonJS((exports, module) => {
       }
     }, {
       key: "join",
-      value: function join25(s5) {
+      value: function join28(s5) {
         if (this.length === 0)
           return "";
         var p4 = this.head;
@@ -234018,7 +234018,7 @@ function normalizeBase44Env() {
 loadProjectEnvFiles();
 
 // src/cli/index.ts
-import { dirname as dirname23, join as join28 } from "node:path";
+import { dirname as dirname26, join as join31 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 
 // ../../node_modules/@clack/core/dist/index.mjs
@@ -235225,8 +235225,15 @@ var {
   Help
 } = import__.default;
 
-// src/cli/commands/agents/pull.ts
-import { dirname as dirname10, join as join14 } from "node:path";
+// src/cli/errors.ts
+class CLIExitError extends Error {
+  code;
+  constructor(code) {
+    super(`CLI exited with code ${code}`);
+    this.code = code;
+    this.name = "CLIExitError";
+  }
+}
 // ../../node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
 var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
@@ -236038,6 +236045,7 @@ var ProjectConfigSchema = exports_external.object({
   site: SiteConfigSchema.optional(),
   entitiesDir: exports_external.string().optional().default("entities"),
   functionsDir: exports_external.string().optional().default("functions"),
+  actorsDir: exports_external.string().optional().default("actors"),
   agentsDir: exports_external.string().optional().default("agents"),
   connectorsDir: exports_external.string().optional().default("connectors"),
   authDir: exports_external.string().optional().default("auth"),
@@ -236102,19 +236110,7 @@ function getTestOverrides() {
 
 // src/core/auth/config.ts
 var TOKEN_REFRESH_BUFFER_MS = 60 * 1000;
-var WORKSPACE_API_KEY_PREFIX = "b44k_";
 var refreshPromise = null;
-function getWorkspaceApiKeyFromEnv() {
-  const key = process.env.BASE44_API_KEY?.trim();
-  return key ? key : null;
-}
-function isWorkspaceApiKey(value) {
-  return value.startsWith(WORKSPACE_API_KEY_PREFIX);
-}
-function hasWorkspaceApiKeyAuth() {
-  const key = getWorkspaceApiKeyFromEnv();
-  return key !== null && isWorkspaceApiKey(key);
-}
 async function seedAuthFromEnv() {
   const accessToken = process.env.BASE44_ACCESS_TOKEN;
   if (!accessToken) {
@@ -241906,7 +241902,7 @@ async function getSiteUrl() {
   return result.data.url;
 }
 // src/core/project/config.ts
-import { dirname as dirname8, join as join10 } from "node:path";
+import { dirname as dirname10, join as join11 } from "node:path";
 
 // src/core/project/plugins.ts
 import { createRequire as createRequire2 } from "node:module";
@@ -241944,6 +241940,165 @@ function markPluginEntities(entities, pluginNamespace) {
   }));
 }
 
+// src/core/resources/types.ts
+var ResourceSourceSchema = exports_external.discriminatedUnion("type", [
+  exports_external.object({
+    type: exports_external.literal("project")
+  }),
+  exports_external.object({
+    type: exports_external.literal("plugin"),
+    namespace: exports_external.string().min(1, "Plugin namespace cannot be empty")
+  })
+]);
+
+// src/core/resources/actor/schema.ts
+var ActorConfigSchema = exports_external.object({
+  name: exports_external.string().min(1),
+  entry: exports_external.string().min(1)
+});
+var ActorSchemaFileSchema = exports_external.object({
+  types: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
+  toClient: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
+  toServer: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
+});
+var DeployActorResponseSchema = exports_external.object({
+  status: exports_external.enum(["deployed", "unchanged"]),
+  handler_name: exports_external.string().optional()
+});
+var ActorSchema = ActorConfigSchema.extend({
+  entryPath: exports_external.string().min(1),
+  filePaths: exports_external.array(exports_external.string()).min(1),
+  source: ResourceSourceSchema,
+  messageSchema: exports_external.unknown().optional()
+});
+
+// src/core/resources/actor/api.ts
+async function deploySingleActor(name2, payload) {
+  const appClient = getAppClient();
+  let response;
+  try {
+    response = await appClient.put(`actors/${encodeURIComponent(name2)}`, {
+      json: payload,
+      timeout: false
+    });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, `deploying actor "${name2}"`);
+  }
+  const result = DeployActorResponseSchema.safeParse(await response.json());
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid response from server", result.error);
+  }
+  return result.data;
+}
+// src/core/resources/actor/config.ts
+import { basename as basename3, dirname as dirname6, join as join5, relative } from "node:path";
+async function readActor(entryFile, actorsDir) {
+  const actorDir = dirname6(entryFile);
+  const filePaths = await globby("**/*.ts", {
+    cwd: actorDir,
+    absolute: true
+  });
+  const name2 = relative(actorsDir, actorDir).split(/[/\\]/).join("/");
+  if (!name2) {
+    throw new InvalidInputError("entry.ts found directly in the actors directory — it must be inside a named subfolder", {
+      hints: [
+        {
+          message: `Move ${entryFile} into a subfolder (e.g. actors/MyActor/entry.ts)`
+        }
+      ]
+    });
+  }
+  const entry = basename3(entryFile);
+  const schemaPath = join5(actorDir, "schema.jsonc");
+  let messageSchema;
+  if (await pathExists(schemaPath)) {
+    const parsed = await readJsonFile(schemaPath);
+    const result = ActorSchemaFileSchema.safeParse(parsed);
+    if (result.success) {
+      messageSchema = {
+        types: result.data.types,
+        toClient: result.data.toClient,
+        toServer: result.data.toServer
+      };
+    }
+  }
+  return {
+    name: name2,
+    entry,
+    entryPath: entryFile,
+    filePaths,
+    source: { type: "project" },
+    messageSchema
+  };
+}
+async function readAllActors(actorsDir) {
+  if (!await pathExists(actorsDir)) {
+    return [];
+  }
+  const entryFiles = await globby(ENTRY_FILE_GLOB, {
+    cwd: actorsDir,
+    absolute: true,
+    ignore: ENTRY_IGNORE_DOT_PATHS
+  });
+  const actors = await Promise.all(entryFiles.map((entryFile) => readActor(entryFile, actorsDir)));
+  const names = new Set;
+  for (const actor of actors) {
+    if (names.has(actor.name)) {
+      throw new InvalidInputError(`Duplicate actor name "${actor.name}" in ${actorsDir}`);
+    }
+    names.add(actor.name);
+  }
+  return actors;
+}
+// src/core/resources/actor/deploy.ts
+import { dirname as dirname7, relative as relative2 } from "node:path";
+async function loadActorCode(actor) {
+  const actorDir = dirname7(actor.entryPath);
+  const resolvedFiles = await Promise.all(actor.filePaths.map(async (filePath) => {
+    const content = await readTextFile(filePath);
+    const path11 = relative2(actorDir, filePath).split(/[/\\]/).join("/");
+    return { path: path11, content };
+  }));
+  return { name: actor.name, entry: actor.entry, files: resolvedFiles };
+}
+async function deployOne(actor) {
+  const start = Date.now();
+  try {
+    const loaded = await loadActorCode(actor);
+    const response = await deploySingleActor(loaded.name, {
+      entry: loaded.entry,
+      files: loaded.files
+    });
+    return {
+      name: loaded.name,
+      status: response.status,
+      durationMs: Date.now() - start
+    };
+  } catch (error48) {
+    return {
+      name: actor.name,
+      status: "error",
+      error: error48 instanceof Error ? error48.message : String(error48)
+    };
+  }
+}
+async function deployActorsSequentially(actors, options) {
+  if (actors.length === 0)
+    return [];
+  const results = [];
+  for (const actor of actors) {
+    options?.onStart?.([actor.name]);
+    const result = await deployOne(actor);
+    results.push(result);
+    options?.onResult?.(result);
+  }
+  return results;
+}
+// src/core/resources/actor/resource.ts
+var actorResource = {
+  readAll: readAllActors,
+  push: (actors) => deployActorsSequentially(actors)
+};
 // src/core/resources/agent/schema.ts
 var EntityOperationSchema = exports_external.enum(["create", "update", "delete", "read"]);
 var EntityToolConfigSchema = exports_external.object({
@@ -242021,7 +242176,7 @@ async function fetchAgents() {
   return result.data;
 }
 // src/core/resources/agent/config.ts
-import { join as join5, normalize } from "node:path";
+import { join as join6, normalize } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 async function readAgentFile(agentPath) {
   const raw2 = await readJsonFile(agentPath);
@@ -242066,12 +242221,12 @@ async function readAllAgents(agentsDir) {
   return [...nameToEntry.values()].map((e2) => e2.data);
 }
 function findAvailablePath(agentsDir, name2, claimedPaths) {
-  const base = join5(agentsDir, `${name2}.${CONFIG_FILE_EXTENSION}`);
+  const base = join6(agentsDir, `${name2}.${CONFIG_FILE_EXTENSION}`);
   if (!claimedPaths.has(base)) {
     return base;
   }
   for (let i = 1;; i++) {
-    const candidate = join5(agentsDir, `${name2}_${i}.${CONFIG_FILE_EXTENSION}`);
+    const candidate = join6(agentsDir, `${name2}_${i}.${CONFIG_FILE_EXTENSION}`);
     if (!claimedPaths.has(candidate)) {
       return candidate;
     }
@@ -242154,8 +242309,8 @@ var AppAuthConfigResponseSchema = exports_external.object({
 }).transform((data) => ({
   authConfig: data.auth_config
 }));
-function hasAnyLoginMethod(config4) {
-  return config4.enableUsernamePassword || config4.enableGoogleLogin || config4.enableMicrosoftLogin || config4.enableFacebookLogin || config4.enableAppleLogin || config4.enableSSOLogin;
+function hasAnyLoginMethod(config5) {
+  return config5.enableUsernamePassword || config5.enableGoogleLogin || config5.enableMicrosoftLogin || config5.enableFacebookLogin || config5.enableAppleLogin || config5.enableSSOLogin;
 }
 var SOCIAL_PROVIDERS = {
   google: {
@@ -242170,18 +242325,18 @@ var SOCIAL_PROVIDERS = {
   facebook: { field: "enableFacebookLogin" },
   apple: { field: "enableAppleLogin" }
 };
-function toAuthConfigPayload(config4) {
+function toAuthConfigPayload(config5) {
   return {
-    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
+    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
   };
 }
 
@@ -242200,12 +242355,12 @@ async function getAuthConfig() {
   }
   return result.data.authConfig;
 }
-async function pushAuthConfigToApi(config4) {
+async function pushAuthConfigToApi(config5) {
   const { id } = getAppContext();
   let response;
   try {
     response = await base44Client.put(`api/apps/${id}`, {
-      json: { auth_config: toAuthConfigPayload(config4) }
+      json: { auth_config: toAuthConfigPayload(config5) }
     });
   } catch (error48) {
     throw await ApiError.fromHttpError(error48, "updating auth config");
@@ -242217,7 +242372,7 @@ async function pushAuthConfigToApi(config4) {
   return result.data.authConfig;
 }
 // src/core/resources/auth-config/config.ts
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "node:util";
 var AUTH_CONFIG_FILENAME = `config.${CONFIG_FILE_EXTENSION}`;
 var DEFAULT_AUTH_CONFIG = {
@@ -242233,7 +242388,7 @@ var DEFAULT_AUTH_CONFIG = {
   useWorkspaceSSO: false
 };
 function getAuthConfigPath(authDir) {
-  return join6(authDir, AUTH_CONFIG_FILENAME);
+  return join7(authDir, AUTH_CONFIG_FILENAME);
 }
 async function readAuthConfig(authDir) {
   const filePath = getAuthConfigPath(authDir);
@@ -242247,16 +242402,16 @@ async function readAuthConfig(authDir) {
   }
   return result.data;
 }
-async function writeAuthConfig(authDir, config4) {
+async function writeAuthConfig(authDir, config5) {
   const filePath = getAuthConfigPath(authDir);
   if (await pathExists(filePath)) {
     const existing = await readJsonFile(filePath);
     const existingResult = AuthConfigFileSchema.safeParse(existing);
-    if (existingResult.success && isDeepStrictEqual2(existingResult.data, config4)) {
+    if (existingResult.success && isDeepStrictEqual2(existingResult.data, config5)) {
       return { written: false };
     }
   }
-  await writeJsonFile(filePath, config4);
+  await writeJsonFile(filePath, config5);
   return { written: true };
 }
 // src/core/resources/auth-config/pull.ts
@@ -242264,17 +242419,17 @@ async function pullAuthConfig() {
   return await getAuthConfig();
 }
 // src/core/resources/auth-config/push.ts
-async function pushAuthConfig(config4) {
-  if (!config4) {
+async function pushAuthConfig(config5) {
+  if (!config5) {
     return;
   }
-  await pushAuthConfigToApi(config4);
+  await pushAuthConfigToApi(config5);
 }
 // src/core/resources/auth-config/resource.ts
 var authConfigResource = {
   readAll: async (dir) => {
-    const config4 = await readAuthConfig(dir);
-    return config4 ? [config4] : [];
+    const config5 = await readAuthConfig(dir);
+    return config5 ? [config5] : [];
   },
   push: async (items) => {
     await pushAuthConfig(items[0] ?? null);
@@ -242514,7 +242669,7 @@ class MissingSSOFieldsError extends InvalidInputError {
   }
 }
 function buildSSOSecrets(provider, options) {
-  const schema3 = SSO_PROVIDER_SCHEMAS[provider];
+  const schema4 = SSO_PROVIDER_SCHEMAS[provider];
   const secrets = {};
   secrets["sso_name" /* Name */] = options.ssoName ?? provider;
   secrets["sso_client_id" /* ClientId */] = options.clientId;
@@ -242525,21 +242680,21 @@ function buildSSOSecrets(provider, options) {
       secrets[secretKey] = value;
     }
   }
-  if (schema3.deriveDefaults) {
-    const derived = schema3.deriveDefaults(secrets);
+  if (schema4.deriveDefaults) {
+    const derived = schema4.deriveDefaults(secrets);
     for (const [key, val] of Object.entries(derived)) {
       if (!secrets[key]) {
         secrets[key] = val;
       }
     }
   }
-  for (const [key, val] of Object.entries(schema3.defaults)) {
+  for (const [key, val] of Object.entries(schema4.defaults)) {
     if (!secrets[key]) {
       secrets[key] = val;
     }
   }
   const missing = [];
-  for (const key of schema3.requiredKeys) {
+  for (const key of schema4.requiredKeys) {
     if (!secrets[key]) {
       missing.push(key);
     }
@@ -242885,7 +243040,7 @@ async function removeStripe() {
   return result.data;
 }
 // src/core/resources/connector/config.ts
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 import { isDeepStrictEqual as isDeepStrictEqual3 } from "node:util";
 async function readConnectorFile(connectorPath) {
   const parsed = await readJsonFile(connectorPath);
@@ -242946,7 +243101,7 @@ async function writeConnectors(connectorsDir, remoteConnectors) {
     if (existing && isDeepStrictEqual3(existing.data, connector)) {
       continue;
     }
-    const filePath = existing?.filePath ?? join7(connectorsDir, `${connector.type}.${CONFIG_FILE_EXTENSION}`);
+    const filePath = existing?.filePath ?? join8(connectorsDir, `${connector.type}.${CONFIG_FILE_EXTENSION}`);
     await writeJsonFile(filePath, connector);
     written.push(connector.type);
   }
@@ -243101,17 +243256,6 @@ var connectorResource = {
   readAll: readAllConnectors,
   push: pushConnectors
 };
-// src/core/resources/types.ts
-var ResourceSourceSchema = exports_external.discriminatedUnion("type", [
-  exports_external.object({
-    type: exports_external.literal("project")
-  }),
-  exports_external.object({
-    type: exports_external.literal("plugin"),
-    namespace: exports_external.string().min(1, "Plugin namespace cannot be empty")
-  })
-]);
-
 // src/core/resources/entity/schema.ts
 var FieldConditionSchema = exports_external.union([
   exports_external.string(),
@@ -243548,7 +243692,7 @@ async function fetchFunctionLogs(functionName, filters = {}) {
   return result.data;
 }
 // src/core/resources/function/config.ts
-import { basename as basename3, dirname as dirname6, join as join8, relative } from "node:path";
+import { basename as basename4, dirname as dirname8, join as join9, relative as relative3 } from "node:path";
 async function readFunctionConfig(configPath) {
   const parsed = await readJsonFile(configPath);
   const result = FunctionConfigSchema.safeParse(parsed);
@@ -243558,9 +243702,9 @@ async function readFunctionConfig(configPath) {
   return result.data;
 }
 async function readFunction(configPath) {
-  const config7 = await readFunctionConfig(configPath);
-  const functionDir = dirname6(configPath);
-  const entryPath = join8(functionDir, config7.entry);
+  const config8 = await readFunctionConfig(configPath);
+  const functionDir = dirname8(configPath);
+  const entryPath = join9(functionDir, config8.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" }]
@@ -243571,7 +243715,7 @@ async function readFunction(configPath) {
     absolute: true
   });
   const functionData = {
-    ...config7,
+    ...config8,
     entryPath,
     filePaths,
     source: { type: "project" }
@@ -243591,16 +243735,16 @@ async function readAllFunctions(functionsDir) {
     absolute: true,
     ignore: ENTRY_IGNORE_DOT_PATHS
   });
-  const configFilesDirs = new Set(configFiles.map((f) => dirname6(f)));
-  const entryFilesWithoutConfig = entryFiles.filter((entryFile) => !configFilesDirs.has(dirname6(entryFile)));
+  const configFilesDirs = new Set(configFiles.map((f) => dirname8(f)));
+  const entryFilesWithoutConfig = entryFiles.filter((entryFile) => !configFilesDirs.has(dirname8(entryFile)));
   const functionsFromConfig = await Promise.all(configFiles.map((configPath) => readFunction(configPath)));
   const functionsWithoutConfig = await Promise.all(entryFilesWithoutConfig.map(async (entryFile) => {
-    const functionDir = dirname6(entryFile);
+    const functionDir = dirname8(entryFile);
     const filePaths = await globby("**/*.{js,ts,json}", {
       cwd: functionDir,
       absolute: true
     });
-    const name2 = relative(functionsDir, functionDir).split(/[/\\]/).join("/");
+    const name2 = relative3(functionsDir, functionDir).split(/[/\\]/).join("/");
     if (!name2) {
       throw new InvalidInputError("entry.ts found directly in the functions directory — it must be inside a named subfolder", {
         hints: [
@@ -243610,7 +243754,7 @@ async function readAllFunctions(functionsDir) {
         ]
       });
     }
-    const entry = basename3(entryFile);
+    const entry = basename4(entryFile);
     const functionData = {
       name: name2,
       entry,
@@ -243637,17 +243781,17 @@ async function readAllFunctions(functionsDir) {
   return functions;
 }
 // src/core/resources/function/deploy.ts
-import { dirname as dirname7, relative as relative2 } from "node:path";
+import { dirname as dirname9, relative as relative4 } from "node:path";
 async function loadFunctionCode(fn) {
-  const functionDir = dirname7(fn.entryPath);
+  const functionDir = dirname9(fn.entryPath);
   const resolvedFiles = await Promise.all(fn.filePaths.map(async (filePath) => {
     const content = await readTextFile(filePath);
-    const path11 = relative2(functionDir, filePath).split(/[/\\]/).join("/");
+    const path11 = relative4(functionDir, filePath).split(/[/\\]/).join("/");
     return { path: path11, content };
   }));
   return { ...fn, files: resolvedFiles };
 }
-async function deployOne(fn) {
+async function deployOne2(fn) {
   const start = Date.now();
   try {
     const functionWithCode = await loadFunctionCode(fn);
@@ -243675,7 +243819,7 @@ async function deployFunctionsSequentially(functions, options) {
   const results = [];
   for (const fn of functions) {
     options?.onStart?.([fn.name]);
-    const result = await deployOne(fn);
+    const result = await deployOne2(fn);
     results.push(result);
     options?.onResult?.(result);
   }
@@ -243706,28 +243850,28 @@ async function pruneRemovedFunctions(localFunctionNames, options) {
   return results;
 }
 // src/core/resources/function/pull.ts
-import { join as join9 } from "node:path";
+import { join as join10 } 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 = join9(functionsDir, fn.name);
-    const configPath = join9(functionDir, "function.jsonc");
+    const functionDir = join10(functionsDir, fn.name);
+    const configPath = join10(functionDir, "function.jsonc");
     if (await isFunctionUnchanged(functionDir, fn)) {
       skipped.push(fn.name);
       continue;
     }
-    const config7 = {
+    const config8 = {
       name: fn.name,
       entry: fn.entry
     };
     if (fn.automations.length > 0) {
-      config7.automations = fn.automations;
+      config8.automations = fn.automations;
     }
-    await writeJsonFile(configPath, config7);
+    await writeJsonFile(configPath, config8);
     for (const file2 of fn.files) {
-      await writeFile(join9(functionDir, file2.path), file2.content);
+      await writeFile(join10(functionDir, file2.path), file2.content);
     }
     written.push(fn.name);
   }
@@ -243737,7 +243881,7 @@ async function isFunctionUnchanged(functionDir, fn) {
   if (!await pathExists(functionDir)) {
     return false;
   }
-  const configPath = join9(functionDir, "function.jsonc");
+  const configPath = join10(functionDir, "function.jsonc");
   try {
     const localConfig = await readJsonFile(configPath);
     if (localConfig.entry !== fn.entry) {
@@ -243750,7 +243894,7 @@ async function isFunctionUnchanged(functionDir, fn) {
     return false;
   }
   for (const file2 of fn.files) {
-    const filePath = join9(functionDir, file2.path);
+    const filePath = join10(functionDir, file2.path);
     if (!await pathExists(filePath)) {
       return false;
     }
@@ -243789,6 +243933,7 @@ class ProjectConfigReader {
       project: { ...project, root, configPath },
       entities,
       functions,
+      actors: localResources.actors,
       agents: localResources.agents,
       connectors: localResources.connectors,
       authConfig: localResources.authConfig
@@ -243816,15 +243961,23 @@ class ProjectConfigReader {
     return result.data;
   }
   async readProjectResources(configPath, project) {
-    const configDir = dirname8(configPath);
-    const [entities, functions, agents, connectors, authConfig] = await Promise.all([
-      entityResource.readAll(join10(configDir, project.entitiesDir)),
-      functionResource.readAll(join10(configDir, project.functionsDir)),
-      agentResource.readAll(join10(configDir, project.agentsDir)),
-      connectorResource.readAll(join10(configDir, project.connectorsDir)),
-      authConfigResource.readAll(join10(configDir, project.authDir))
+    const configDir = dirname10(configPath);
+    const [entities, functions, actors, agents, connectors, authConfig] = await Promise.all([
+      entityResource.readAll(join11(configDir, project.entitiesDir)),
+      functionResource.readAll(join11(configDir, project.functionsDir)),
+      actorResource.readAll(join11(configDir, project.actorsDir)),
+      agentResource.readAll(join11(configDir, project.agentsDir)),
+      connectorResource.readAll(join11(configDir, project.connectorsDir)),
+      authConfigResource.readAll(join11(configDir, project.authDir))
     ]);
-    return { entities, functions, agents, connectors, authConfig };
+    return {
+      entities,
+      functions,
+      actors,
+      agents,
+      connectors,
+      authConfig
+    };
   }
   assertPluginProjectDoesNotLoadPlugins(project, configPath) {
     if (project.plugin && project.plugins.length > 0) {
@@ -243845,7 +243998,7 @@ class ProjectConfigReader {
     this.pluginSourceByNamespace.set(namespace, source);
   }
   async readPluginConfig(plugin, hostConfigPath) {
-    const pluginRoot = resolvePluginRoot(plugin.source, dirname8(hostConfigPath));
+    const pluginRoot = resolvePluginRoot(plugin.source, dirname10(hostConfigPath));
     const { configPath } = await this.findConfigOrThrow(pluginRoot);
     const project = await this.readConfigFile(configPath);
     const namespace = requirePluginNamespace(project, plugin.source, configPath);
@@ -243857,6 +244010,7 @@ class ProjectConfigReader {
     return {
       entities: markPluginEntities(resources.entities, namespace),
       functions: namespacePluginFunctions(resources.functions, namespace),
+      actors: [],
       agents: [],
       connectors: [],
       authConfig: []
@@ -243894,6 +244048,7 @@ class ProjectConfigReader {
     return {
       entities,
       functions,
+      actors: [],
       agents: [],
       connectors: [],
       authConfig: []
@@ -243923,16 +244078,16 @@ 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 join12 } from "node:path";
+import { dirname as dirname11, join as join13 } from "node:path";
 
 // src/core/assets.ts
 import { cpSync, existsSync } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 // package.json
 var package_default = {
   name: "base44",
-  version: "0.1.1",
+  version: "0.1.2",
   description: "Base44 CLI - Unified interface for managing Base44 applications",
   type: "module",
   bin: {
@@ -244029,18 +244184,18 @@ var package_default = {
 };
 
 // src/core/assets.ts
-var ASSETS_DIR = join11(homedir2(), ".base44", "assets", package_default.version);
+var ASSETS_DIR = join12(homedir2(), ".base44", "assets", package_default.version);
 function getTemplatesDir() {
-  return join11(ASSETS_DIR, "templates");
+  return join12(ASSETS_DIR, "templates");
 }
 function getTemplatesIndexPath() {
-  return join11(ASSETS_DIR, "templates", "templates.json");
+  return join12(ASSETS_DIR, "templates", "templates.json");
 }
 function getDenoWrapperPath() {
-  return join11(ASSETS_DIR, "deno-runtime", "main.ts");
+  return join12(ASSETS_DIR, "deno-runtime", "main.ts");
 }
 function getExecWrapperPath() {
-  return join11(ASSETS_DIR, "deno-runtime", "exec.ts");
+  return join12(ASSETS_DIR, "deno-runtime", "exec.ts");
 }
 function ensureNpmAssets(sourceDir) {
   if (existsSync(ASSETS_DIR))
@@ -244062,7 +244217,7 @@ async function listTemplates() {
 }
 async function renderTemplate(template, destPath, data, options = {}) {
   const { skipExisting = false } = options;
-  const templateDir = join12(getTemplatesDir(), template.path);
+  const templateDir = join13(getTemplatesDir(), template.path);
   const files = await globby("**/*", {
     cwd: templateDir,
     dot: true,
@@ -244070,20 +244225,20 @@ async function renderTemplate(template, destPath, data, options = {}) {
   });
   const skipped = [];
   for (const file2 of files) {
-    const srcPath = join12(templateDir, file2);
+    const srcPath = join13(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 ? join12(dirname9(file2), attributes.outputFileName) : file2.replace(/\.ejs$/, "");
-        const destFilePath = join12(destPath, destFile);
+        const destFile = attributes.outputFileName ? join13(dirname11(file2), attributes.outputFileName) : file2.replace(/\.ejs$/, "");
+        const destFilePath = join13(destPath, destFile);
         if (skipExisting && await pathExists(destFilePath)) {
           skipped.push(destFile);
           continue;
         }
         await writeFile(destFilePath, body);
       } else {
-        const destFilePath = join12(destPath, file2);
+        const destFilePath = join13(destPath, file2);
         if (skipExisting && await pathExists(destFilePath)) {
           skipped.push(file2);
           continue;
@@ -244177,7 +244332,7 @@ async function getSiteFilePaths(outputDir) {
 // src/core/site/deploy.ts
 import { randomUUID } from "node:crypto";
 import { tmpdir } from "node:os";
-import { join as join13 } from "node:path";
+import { join as join14 } 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.`, {
@@ -244194,7 +244349,7 @@ async function deploySite(siteOutputDir) {
       ]
     });
   }
-  const archivePath = join13(tmpdir(), `base44-site-${randomUUID()}.tar.gz`);
+  const archivePath = join14(tmpdir(), `base44-site-${randomUUID()}.tar.gz`);
   try {
     await createArchive(siteOutputDir, archivePath);
     return await uploadSite(archivePath);
@@ -244211,25 +244366,43 @@ async function createArchive(pathToArchive, targetArchivePath) {
 }
 // src/core/project/deploy.ts
 function hasResourcesToDeploy(projectData) {
-  const { project, entities, functions, agents, connectors, authConfig } = projectData;
+  const {
+    project,
+    entities,
+    functions,
+    actors,
+    agents,
+    connectors,
+    authConfig
+  } = projectData;
   const hasSite = Boolean(project.site?.outputDirectory);
   const hasEntities = entities.length > 0;
   const hasFunctions = functions.length > 0;
+  const hasActors = actors.length > 0;
   const hasAgents = agents.length > 0;
   const hasConnectors = connectors.length > 0;
   const hasAuthConfig = authConfig.length > 0;
-  return hasEntities || hasFunctions || hasAgents || hasConnectors || hasAuthConfig || hasSite;
+  return hasEntities || hasFunctions || hasActors || hasAgents || hasConnectors || hasAuthConfig || hasSite;
 }
 async function deployAll(projectData, options) {
-  const { project, entities, functions, agents, connectors, authConfig } = projectData;
+  const {
+    project,
+    entities,
+    functions,
+    actors,
+    agents,
+    connectors,
+    authConfig
+  } = projectData;
   await entityResource.push(entities);
   await deployFunctionsSequentially(functions, {
     onStart: options?.onFunctionStart,
     onResult: options?.onFunctionResult
   });
+  await deployActorsSequentially(actors);
   await agentResource.push(agents);
   await authConfigResource.push(authConfig);
-  const connectorResults = connectors.length > 0 ? (await pushConnectors(connectors)).results : [];
+  const { results: connectorResults } = await pushConnectors(connectors);
   if (project.site?.outputDirectory) {
     const outputDir = resolve2(project.root, project.site.outputDirectory);
     const { appUrl } = await deploySite(outputDir);
@@ -244253,9 +244426,6 @@ async function handleUnauthorized(request, _options, response) {
   if (response.status !== 401) {
     return;
   }
-  if (hasWorkspaceApiKeyAuth()) {
-    return;
-  }
   if (retriedRequests.has(request)) {
     return;
   }
@@ -244284,11 +244454,6 @@ var base44Client = distribution_default.create({
       },
       captureRequestBody,
       async (request) => {
-        const workspaceApiKey = getWorkspaceApiKeyFromEnv();
-        if (workspaceApiKey && isWorkspaceApiKey(workspaceApiKey)) {
-          request.headers.set("api_key", workspaceApiKey);
-          return;
-        }
         try {
           const auth = await readAuth();
           if (isTokenExpired(auth)) {
@@ -244494,12 +244659,6 @@ async function login({
 
 // src/cli/utils/command/middleware.ts
 async function ensureAuth(ctx) {
-  if (hasWorkspaceApiKeyAuth()) {
-    ctx.errorReporter.setContext({
-      user: { email: "workspace-api-key", name: "Workspace API key" }
-    });
-    return;
-  }
   await seedAuthFromEnv();
   const loggedIn = await isLoggedIn();
   if (!loggedIn) {
@@ -251250,16 +251409,6 @@ class Base44Command extends Command {
     });
   }
 }
-// src/cli/errors.ts
-class CLIExitError extends Error {
-  code;
-  constructor(code2) {
-    super(`CLI exited with code ${code2}`);
-    this.code = code2;
-    this.name = "CLIExitError";
-  }
-}
-
 // src/cli/utils/prompts.ts
 var onPromptCancel = () => {
   Ne("Operation cancelled.");
@@ -251431,14 +251580,136 @@ function verifyDenoInstalled(context) {
     });
   }
 }
+// src/cli/commands/actor/deploy.ts
+function parseNames(args) {
+  return args.flatMap((arg) => arg.split(",")).map((n2) => n2.trim()).filter(Boolean);
+}
+function resolveActorsToDeploy(names, allActors) {
+  if (names.length === 0)
+    return allActors;
+  const notFound = names.filter((n2) => !allActors.some((a2) => a2.name === n2));
+  if (notFound.length > 0) {
+    throw new InvalidInputError(`Actor${notFound.length > 1 ? "s" : ""} not found in project: ${notFound.join(", ")}`);
+  }
+  return allActors.filter((a2) => names.includes(a2.name));
+}
+function formatDeployResult(result, log) {
+  const label = result.name.padEnd(25);
+  if (result.status === "deployed") {
+    const timing = result.durationMs ? theme.styles.dim(` (${(result.durationMs / 1000).toFixed(1)}s)`) : "";
+    log.success(`${label} deployed${timing}`);
+  } else if (result.status === "unchanged") {
+    log.success(`${label} unchanged`);
+  } else {
+    log.error(`${label} error: ${result.error}`);
+  }
+}
+function buildDeploySummary(results) {
+  const deployed = results.filter((r) => r.status === "deployed").length;
+  const unchanged = results.filter((r) => r.status === "unchanged").length;
+  const failed = results.filter((r) => r.status === "error").length;
+  const parts = [];
+  if (deployed > 0)
+    parts.push(`${deployed} deployed`);
+  if (unchanged > 0)
+    parts.push(`${unchanged} unchanged`);
+  if (failed > 0)
+    parts.push(`${failed} error${failed !== 1 ? "s" : ""}`);
+  return parts.join(", ") || "No actors deployed";
+}
+async function deployActorAction({ log }, names) {
+  const { actors } = await readProjectConfig();
+  const toDeploy = resolveActorsToDeploy(names, actors);
+  if (toDeploy.length === 0) {
+    return {
+      outroMessage: "No actors found. Create actors in the 'actors' directory."
+    };
+  }
+  log.info(`Found ${toDeploy.length} ${toDeploy.length === 1 ? "actor" : "actors"} to deploy`);
+  let completed = 0;
+  const total = toDeploy.length;
+  const results = await deployActorsSequentially(toDeploy, {
+    onStart: (startNames) => {
+      const label = startNames.length === 1 ? startNames[0] : `${startNames.length} actors`;
+      log.step(theme.styles.dim(`[${completed + 1}/${total}] Deploying ${label}...`));
+    },
+    onResult: (result) => {
+      completed++;
+      formatDeployResult(result, log);
+    }
+  });
+  const hasFailures = results.some((r) => r.status === "error");
+  if (hasFailures) {
+    log.message(buildDeploySummary(results));
+    throw new CLIExitError(1);
+  }
+  return { outroMessage: buildDeploySummary(results) };
+}
+function getDeployCommand() {
+  return new Base44Command("deploy").description("Deploy actors to Base44").argument("[names...]", "Actor names to deploy (deploys all if omitted)").action(async (ctx, rawNames) => {
+    const names = parseNames(rawNames);
+    return deployActorAction(ctx, names);
+  });
+}
+
+// src/cli/commands/actor/new.ts
+import { dirname as dirname12, join as join15 } from "node:path";
+function buildActorScaffold(actorName) {
+  return `import { Actor, type Conn } from "@base44/sdk";
+
+interface State {
+  // shared state broadcast to all clients
+}
+
+interface Message {
+  // messages sent from clients
+}
+
+export class ${actorName} extends Actor<State, Message> {
+  handleConnect(conn: Conn) {
+    console.log("Connected:", conn.userId);
+  }
+  handleMessage(conn: Conn, msg: Message) {
+    console.log("Message:", msg);
+  }
+  handleTick() {}
+  handleClose(conn: Conn) {}
+}
+`;
+}
+async function newActorAction(_ctx, actorName) {
+  const { project: project2 } = await readProjectConfig();
+  const actorsDir = join15(dirname12(project2.configPath), project2.actorsDir);
+  const actorDir = join15(actorsDir, actorName);
+  if (await pathExists(actorDir)) {
+    throw new InvalidInputError(`Actor "${actorName}" already exists at ${actorDir}`);
+  }
+  const entryPath = join15(actorDir, "entry.ts");
+  await writeFile(entryPath, buildActorScaffold(actorName));
+  return {
+    outroMessage: `Created actor "${actorName}" at ${entryPath}`
+  };
+}
+function getNewCommand() {
+  return new Base44Command("new").description("Create a new actor scaffold").argument("<ActorName>", "Name of the actor class").action(async (ctx, actorName) => {
+    return newActorAction(ctx, actorName);
+  });
+}
+
+// src/cli/commands/actor/index.ts
+function getActorCommand() {
+  return new Command("actor").description("Manage actors").addCommand(getNewCommand()).addCommand(getDeployCommand());
+}
+
 // src/cli/commands/agents/pull.ts
+import { dirname as dirname13, join as join16 } from "node:path";
 async function pullAgentsAction({
   log,
   runTask: runTask2
 }) {
   const { project: project2 } = await readProjectConfig();
-  const configDir = dirname10(project2.configPath);
-  const agentsDir = join14(configDir, project2.agentsDir);
+  const configDir = dirname13(project2.configPath);
+  const agentsDir = join16(configDir, project2.agentsDir);
   const remoteAgents = await runTask2("Fetching agents from Base44", async () => {
     return await fetchAgents();
   }, {
@@ -251502,12 +251773,12 @@ function getAgentsCommand() {
 }
 
 // src/cli/commands/auth/password-login.ts
-import { dirname as dirname11, join as join15 } from "node:path";
+import { dirname as dirname14, join as join17 } from "node:path";
 async function passwordLoginAction({ log, runTask: runTask2 }, action) {
   const shouldEnable = action === "enable";
   const { project: project2 } = await readProjectConfig();
-  const configDir = dirname11(project2.configPath);
-  const authDir = join15(configDir, project2.authDir);
+  const configDir = dirname14(project2.configPath);
+  const authDir = join17(configDir, project2.authDir);
   const updated = await runTask2("Updating local auth config", async () => {
     const current = await readAuthConfig(authDir) ?? DEFAULT_AUTH_CONFIG;
     const merged = { ...current, enableUsernamePassword: shouldEnable };
@@ -251527,14 +251798,14 @@ function getPasswordLoginCommand() {
 }
 
 // src/cli/commands/auth/pull.ts
-import { dirname as dirname12, join as join16 } from "node:path";
+import { dirname as dirname15, join as join18 } from "node:path";
 async function pullAuthAction({
   log,
   runTask: runTask2
 }) {
   const { project: project2 } = await readProjectConfig();
-  const configDir = dirname12(project2.configPath);
-  const authDir = join16(configDir, project2.authDir);
+  const configDir = dirname15(project2.configPath);
+  const authDir = join18(configDir, project2.authDir);
   const remoteConfig = await runTask2("Fetching auth config from Base44", async () => {
     return await pullAuthConfig();
   }, {
@@ -251598,7 +251869,7 @@ function getAuthPushCommand() {
 }
 
 // src/cli/commands/auth/social-login.ts
-import { dirname as dirname13, join as join17, resolve as resolve3 } from "node:path";
+import { dirname as dirname16, join as join19, resolve as resolve3 } from "node:path";
 var PROVIDER_LABELS = {
   google: "Google",
   microsoft: "Microsoft",
@@ -251668,8 +251939,8 @@ async function socialLoginAction({ log, isNonInteractive, runTask: runTask2 }, p
     }
   }
   const { project: project2 } = await readProjectConfig();
-  const configDir = dirname13(project2.configPath);
-  const authDir = join17(configDir, project2.authDir);
+  const configDir = dirname16(project2.configPath);
+  const authDir = join19(configDir, project2.authDir);
   const { config: updated } = await runTask2("Updating local auth config", async () => updateSocialLoginConfig(authDir, provider, shouldEnable, useCustomOAuth && options.clientId ? { clientId: options.clientId } : undefined));
   if (clientSecret) {
     await runTask2("Saving client secret", async () => pushCustomOAuthSecret(provider, clientSecret));
@@ -251694,7 +251965,7 @@ function getSocialLoginCommand() {
 }
 
 // src/cli/commands/auth/sso.ts
-import { dirname as dirname14, join as join18, resolve as resolve4 } from "node:path";
+import { dirname as dirname17, join as join20, resolve as resolve4 } from "node:path";
 var SSOConfigFileSchema = exports_external.object({
   provider: exports_external.enum(Object.values(KNOWN_SSO_PROVIDERS)),
   clientId: exports_external.string(),
@@ -251857,8 +252128,8 @@ async function ssoEnableAction({ isNonInteractive, runTask: runTask2 }, options)
     throw error48;
   }
   const { project: project2 } = await readProjectConfig();
-  const configDir = dirname14(project2.configPath);
-  const authDir = join18(configDir, project2.authDir);
+  const configDir = dirname17(project2.configPath);
+  const authDir = join20(configDir, project2.authDir);
   await runTask2("Updating local auth config", async () => updateSSOConfig(authDir, provider, true));
   await runTask2("Saving SSO credentials", async () => pushSSOSecrets(secrets));
   return {
@@ -251873,8 +252144,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 = dirname14(project2.configPath);
-  const authDir = join18(configDir, project2.authDir);
+  const configDir = dirname17(project2.configPath);
+  const authDir = join20(configDir, project2.authDir);
   const updated = await runTask2("Updating local auth config", async () => updateSSOConfig(authDir, null, false));
   await runTask2("Removing SSO credentials", async () => deleteSSOSecrets());
   if (!hasAnyLoginMethod(updated)) {
@@ -251924,12 +252195,6 @@ function getLogoutCommand() {
 
 // src/cli/commands/auth/whoami.ts
 async function whoami(_ctx) {
-  const workspaceApiKey = getWorkspaceApiKeyFromEnv();
-  if (workspaceApiKey && isWorkspaceApiKey(workspaceApiKey)) {
-    return {
-      outroMessage: `Using workspace API key: ${theme.styles.bold(workspaceApiKey.slice(0, 10))}`
-    };
-  }
   const auth2 = await readAuth();
   return { outroMessage: `Logged in as: ${theme.styles.bold(auth2.email)}` };
 }
@@ -252731,13 +252996,13 @@ function getConnectorsListAvailableCommand() {
 }
 
 // src/cli/commands/connectors/pull.ts
-import { dirname as dirname15, join as join19, resolve as resolve5 } from "node:path";
+import { dirname as dirname18, join as join21, resolve as resolve5 } from "node:path";
 async function resolveConnectorsDir(options) {
   if (!getAppContext().projectRoot) {
     return resolve5(options.dir ?? "connectors");
   }
   const { project: project2 } = await readProjectConfig();
-  return join19(dirname15(project2.configPath), project2.connectorsDir);
+  return join21(dirname18(project2.configPath), project2.connectorsDir);
 }
 async function pullConnectorsAction({ log, runTask: runTask2, jsonMode }, options) {
   const connectorsDir = await resolveConnectorsDir(options);
@@ -252977,18 +253242,18 @@ async function deleteFunctionsAction({ runTask: runTask2 }, names) {
     parts.push(`${errors5} error${errors5 !== 1 ? "s" : ""}`);
   return { outroMessage: parts.join(", ") };
 }
-function parseNames(args) {
+function parseNames2(args) {
   return args.flatMap((arg) => arg.split(",")).map((n2) => n2.trim()).filter(Boolean);
 }
 function validateNames(command2) {
-  const names = parseNames(command2.args);
+  const names = parseNames2(command2.args);
   if (names.length === 0) {
     command2.error("At least one function name is required");
   }
 }
 function getDeleteCommand() {
   return new Base44Command("delete").description("Delete deployed functions").argument("<names...>", "Function names to delete").hook("preAction", validateNames).action(async (ctx, rawNames) => {
-    const names = parseNames(rawNames);
+    const names = parseNames2(rawNames);
     return deleteFunctionsAction(ctx, names);
   });
 }
@@ -252997,7 +253262,7 @@ function getDeleteCommand() {
 function formatDuration(ms) {
   return `${(ms / 1000).toFixed(1)}s`;
 }
-function formatDeployResult(result, log) {
+function formatDeployResult2(result, log) {
   const label = result.name.padEnd(25);
   if (result.status === "deployed") {
     const timing = result.durationMs ? theme.styles.dim(` (${formatDuration(result.durationMs)})`) : "";
@@ -253010,7 +253275,7 @@ function formatDeployResult(result, log) {
 }
 
 // src/cli/commands/functions/parseNames.ts
-function parseNames2(args) {
+function parseNames3(args) {
   return args.flatMap((arg) => arg.split(",")).map((n2) => n2.trim()).filter(Boolean);
 }
 
@@ -253037,7 +253302,7 @@ function formatPruneSummary(pruneResults, log) {
     log.info(`${pruned} deleted`);
   }
 }
-function buildDeploySummary(results) {
+function buildDeploySummary2(results) {
   const deployed = results.filter((r) => r.status === "deployed").length;
   const unchanged = results.filter((r) => r.status === "unchanged").length;
   const failed = results.filter((r) => r.status === "error").length;
@@ -253071,12 +253336,12 @@ async function deployFunctionsAction({ log }, names, options) {
     },
     onResult: (result) => {
       completed++;
-      formatDeployResult(result, log);
+      formatDeployResult2(result, log);
     }
   });
   const hasFailures = results.some((r) => r.status === "error");
   if (hasFailures) {
-    log.message(buildDeploySummary(results));
+    log.message(buildDeploySummary2(results));
     throw new CLIExitError(1);
   }
   if (options.force) {
@@ -253098,11 +253363,11 @@ async function deployFunctionsAction({ log }, names, options) {
     });
     formatPruneSummary(pruneResults, log);
   }
-  return { outroMessage: buildDeploySummary(results) };
+  return { outroMessage: buildDeploySummary2(results) };
 }
-function getDeployCommand() {
+function getDeployCommand2() {
   return new Base44Command("deploy").description("Deploy functions to Base44").argument("[names...]", "Function names to deploy (deploys all if omitted)").option("--force", "Delete remote functions not found locally").action(async (ctx, rawNames, options) => {
-    const names = parseNames2(rawNames);
+    const names = parseNames3(rawNames);
     return deployFunctionsAction(ctx, names, options);
   });
 }
@@ -253130,11 +253395,11 @@ function getListCommand() {
 }
 
 // src/cli/commands/functions/pull.ts
-import { dirname as dirname16, join as join20 } from "node:path";
+import { dirname as dirname19, join as join22 } from "node:path";
 async function pullFunctionsAction({ log, runTask: runTask2 }, name2) {
   const { project: project2, functions } = await readProjectConfig();
-  const configDir = dirname16(project2.configPath);
-  const functionsDir = join20(configDir, project2.functionsDir);
+  const configDir = dirname19(project2.configPath);
+  const functionsDir = join22(configDir, project2.functionsDir);
   const pluginFunctionNames = new Set(functions.filter((fn) => fn.source.type === "plugin").map((fn) => fn.name));
   const remoteFunctions = await runTask2("Fetching functions from Base44", async () => {
     const { functions: functions2 } = await listDeployedFunctions();
@@ -253189,15 +253454,15 @@ function getPullCommand() {
 
 // src/cli/commands/functions/index.ts
 function getFunctionsCommand() {
-  return new Command("functions").description("Manage backend functions").addCommand(getDeployCommand()).addCommand(getDeleteCommand()).addCommand(getListCommand()).addCommand(getPullCommand());
+  return new Command("functions").description("Manage backend functions").addCommand(getDeployCommand2()).addCommand(getDeleteCommand()).addCommand(getListCommand()).addCommand(getPullCommand());
 }
 
 // src/cli/commands/project/create.ts
-import { basename as basename4, resolve as resolve7 } from "node:path";
+import { basename as basename5, resolve as resolve7 } from "node:path";
 var import_kebabCase = __toESM(require_kebabCase(), 1);
 
 // src/cli/commands/project/scaffold-shared.ts
-import { join as join21 } from "node:path";
+import { join as join23 } from "node:path";
 var DEFAULT_TEMPLATE_ID = "backend-only";
 async function getTemplateById(templateId) {
   const templates = await listTemplates();
@@ -253214,7 +253479,7 @@ async function completeProjectSetup({
   projectId,
   name: name2,
   resolvedPath,
-  deploy: deploy5,
+  deploy: deploy6,
   skills,
   isInteractive
 }, { runTask: runTask2 }) {
@@ -253228,7 +253493,7 @@ async function completeProjectSetup({
       });
       shouldPushEntities = !Ct(result) && result;
     } else {
-      shouldPushEntities = !!deploy5;
+      shouldPushEntities = !!deploy6;
     }
     if (shouldPushEntities) {
       await runTask2(`Pushing ${entities.length} data models to Base44...`, async () => {
@@ -253248,7 +253513,7 @@ async function completeProjectSetup({
       });
       shouldDeploy = !Ct(result) && result;
     } else {
-      shouldDeploy = !!deploy5;
+      shouldDeploy = !!deploy6;
     }
     if (shouldDeploy && installCommand && buildCommand && outputDirectory) {
       const { appUrl } = await runTask2("Installing dependencies...", async (updateMessage) => {
@@ -253256,7 +253521,7 @@ async function completeProjectSetup({
         updateMessage("Building project...");
         await execa({ cwd: resolvedPath, shell: true })`${buildCommand}`;
         updateMessage("Deploying site...");
-        return await deploySite(join21(resolvedPath, outputDirectory));
+        return await deploySite(join23(resolvedPath, outputDirectory));
       }, {
         successMessage: theme.colors.base44Orange("Site deployed successfully"),
         errorMessage: "Failed to deploy site"
@@ -253317,8 +253582,8 @@ async function createInteractive(options, ctx) {
     name: () => {
       return options.name ? Promise.resolve(options.name) : Ze({
         message: "What is the name of your project?",
-        placeholder: basename4(process.cwd()),
-        initialValue: basename4(process.cwd()),
+        placeholder: basename5(process.cwd()),
+        initialValue: basename5(process.cwd()),
         validate: (value) => {
           if (!value || value.trim().length === 0) {
             return "Every project deserves a name";
@@ -253363,7 +253628,7 @@ async function executeCreate({
   name: rawName,
   description,
   projectPath,
-  deploy: deploy5,
+  deploy: deploy6,
   skills,
   isInteractive
 }, ctx) {
@@ -253382,7 +253647,7 @@ async function executeCreate({
     errorMessage: "Failed to create project"
   });
   setAppContext({ id: projectId, projectRoot: resolvedPath });
-  const summary = await completeProjectSetup({ projectId, name: name2, resolvedPath, deploy: deploy5, skills, isInteractive }, ctx);
+  const summary = await completeProjectSetup({ projectId, name: name2, resolvedPath, deploy: deploy6, skills, isInteractive }, ctx);
   printProjectSummary(summary, log);
   return { outroMessage: "Your project is set up and ready to use" };
 }
@@ -253427,7 +253692,15 @@ async function deployAction({ isNonInteractive, log }, options = {}) {
       outroMessage: "No resources found to deploy"
     };
   }
-  const { project: project2, entities, functions, agents, connectors, authConfig } = projectData;
+  const {
+    project: project2,
+    entities,
+    functions,
+    actors,
+    agents,
+    connectors,
+    authConfig
+  } = projectData;
   const summaryLines = [];
   if (entities.length > 0) {
     summaryLines.push(`  - ${entities.length} ${entities.length === 1 ? "entity" : "entities"}`);
@@ -253435,6 +253708,9 @@ async function deployAction({ isNonInteractive, log }, options = {}) {
   if (functions.length > 0) {
     summaryLines.push(`  - ${functions.length} ${functions.length === 1 ? "function" : "functions"}`);
   }
+  if (actors.length > 0) {
+    summaryLines.push(`  - ${actors.length} ${actors.length === 1 ? "actor" : "actors"}`);
+  }
   if (agents.length > 0) {
     summaryLines.push(`  - ${agents.length} ${agents.length === 1 ? "agent" : "agents"}`);
   }
@@ -253471,7 +253747,7 @@ ${summaryLines.join(`
     },
     onFunctionResult: (r) => {
       functionCompleted++;
-      formatDeployResult(r, log);
+      formatDeployResult2(r, log);
     }
   });
   const connectorResults = result.connectorResults ?? [];
@@ -253486,7 +253762,7 @@ ${summaryLines.join(`
   }
   return { outroMessage: "App deployed successfully" };
 }
-function getDeployCommand2() {
+function getDeployCommand3() {
   return new Base44Command("deploy").description("Deploy all project resources (entities, functions, agents, connectors, and site)").option("-y, --yes", "Skip confirmation prompt").action(deployAction);
 }
 async function handleOAuthConnectors(connectorResults, isNonInteractive, options, log) {
@@ -253878,7 +254154,7 @@ function getLogsCommand() {
 }
 
 // src/cli/commands/project/scaffold.ts
-import { basename as basename5, resolve as resolve8 } from "node:path";
+import { basename as basename6, resolve as resolve8 } from "node:path";
 function resolveAppId(options) {
   const appId = options.appId;
   if (!appId) {
@@ -253895,7 +254171,7 @@ async function scaffoldAction(ctx, name2, options, command2) {
   const { log, runTask: runTask2 } = ctx;
   const appId = resolveAppId(command2.optsWithGlobals());
   const resolvedPath = resolve8("./");
-  const projectName = (name2 ?? basename5(resolvedPath)).trim();
+  const projectName = (name2 ?? basename6(resolvedPath)).trim();
   const template2 = await getTemplateById("backend-only");
   log.info(`Scaffolding project at ${resolvedPath}`);
   const { projectId } = await runTask2("Setting up your project...", async () => {
@@ -254049,7 +254325,7 @@ function withSandboxAuthHint(error48) {
     cause: error48
   });
 }
-async function callTool(appId, tool, payload, schema10, context, timeout2 = 60000) {
+async function callTool(appId, tool, payload, schema11, context, timeout2 = 60000) {
   const client = getSandboxClient(appId);
   let response;
   try {
@@ -254057,7 +254333,7 @@ async function callTool(appId, tool, payload, schema10, context, timeout2 = 6000
   } catch (error48) {
     throw withSandboxAuthHint(await ApiError.fromHttpError(error48, context));
   }
-  const result = schema10.safeParse(await response.json());
+  const result = schema11.safeParse(await response.json());
   if (!result.success) {
     throw new SchemaValidationError("Invalid response from server", result.error);
   }
@@ -254402,6 +254678,7 @@ function getSiteCommand() {
 // src/core/types/generator.ts
 var import_common_tags = __toESM(require_lib2(), 1);
 var import_json_schema_to_typescript = __toESM(require_src3(), 1);
+import { join as join26 } from "node:path";
 var HEADER2 = import_common_tags.stripIndent`
   // Auto-generated by Base44 CLI - DO NOT EDIT
   // Regenerate with: base44 types generate
@@ -254410,24 +254687,43 @@ var EMPTY_TEMPLATE = import_common_tags.stripIndent`
   // Auto-generated by Base44 CLI - DO NOT EDIT
   // Regenerate with: base44 types
   //
-  // No entities, functions, agents, or connectors found in project.
-  // Add resources to base44/entities/, base44/functions/, base44/agents/, or base44/connectors/
+  // No entities, functions, agents, connectors, or actors found in project.
+  // Add resources to base44/entities/, base44/functions/, base44/agents/, base44/connectors/, or base44/actors/
   // and run \`base44 types generate\` again.
 
   declare module '@base44/sdk' {
     // No types to augment - add resources and regenerate
   }
 `;
+var SDK_PACKAGE_NAMES = ["@base44/sdk", "@base44-preview/sdk"];
+async function detectSdkPackageName(projectRoot) {
+  try {
+    const pkg = await readJsonFile(join26(projectRoot, "package.json"));
+    const deps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies
+    };
+    for (const name2 of SDK_PACKAGE_NAMES) {
+      if (name2 in deps)
+        return name2;
+    }
+  } catch {}
+  return "@base44/sdk";
+}
 async function generateTypesFile(input) {
   const content = await generateContent(input);
   await writeFile(getTypesOutputPath(input.projectRoot), content);
 }
 async function generateContent(input) {
-  const { entities, functions, agents, connectors } = input;
-  if (!entities.length && !functions.length && !agents.length && !connectors.length) {
+  const { entities, functions, agents, connectors, actors } = input;
+  const sdkPackage = await detectSdkPackageName(input.projectRoot);
+  if (!entities.length && !functions.length && !agents.length && !connectors.length && !actors.length) {
     return EMPTY_TEMPLATE;
   }
-  const entityInterfaces = await Promise.all(entities.map((e8) => compileEntity(e8)));
+  const [entityInterfaces, actorResults] = await Promise.all([
+    Promise.all(entities.map((e8) => compileEntity(e8))),
+    Promise.all(actors.map((a5) => compileActor(a5)))
+  ]);
   const registryEntries = [
     [
       "EntityTypeRegistry",
@@ -254435,16 +254731,29 @@ async function generateContent(input) {
     ],
     ["FunctionNameRegistry", functions.map((f7) => `"${f7.name}": true;`)],
     ["AgentNameRegistry", agents.map((a5) => `"${a5.name}": true;`)],
-    ["ConnectorTypeRegistry", connectors.map((c8) => `"${c8.type}": true;`)]
+    ["ConnectorTypeRegistry", connectors.map((c8) => `"${c8.type}": true;`)],
+    ["ActorNameRegistry", actors.map((a5) => `"${a5.name}": true;`)],
+    [
+      "ActorRegistry",
+      actors.filter((a5) => a5.messageSchema).map((a5) => {
+        const idx = actors.indexOf(a5);
+        return `"${a5.name}": ${actorResults[idx].entry};`;
+      })
+    ]
   ];
   const registries2 = registryEntries.filter(([, entries]) => entries.length > 0).map(([name2, entries]) => registry2(name2, entries));
+  const actorInterfaces = actorResults.map((r5) => r5.decls).filter(Boolean);
   return [
     HEADER2,
+    "export {};",
     entityInterfaces.join(`
 
+`),
+    actorInterfaces.join(`
+
 `),
     import_common_tags.source`
-      declare module '@base44/sdk' {
+      declare module '${sdkPackage}' {
         ${registries2.join(`
 
 `)}
@@ -254455,9 +254764,9 @@ async function generateContent(input) {
 `);
 }
 async function compileEntity(entity2) {
-  const { name: name2, source: _source, ...schema10 } = entity2;
+  const { name: name2, source: _source, ...schema11 } = entity2;
   const jsonSchema = {
-    ...schema10,
+    ...schema11,
     title: name2,
     additionalProperties: false
   };
@@ -254472,6 +254781,81 @@ async function compileEntity(entity2) {
     throw new TypeGenerationError(`Failed to generate types for entity "${name2}"`, name2, error48);
   }
 }
+async function compileActor(actor) {
+  const { messageSchema } = actor;
+  if (!messageSchema) {
+    return { decls: "", entry: "{ toClient: unknown; toServer: unknown }" };
+  }
+  const prefix = toPascalCase(actor.name);
+  const types = messageSchema.types ?? {};
+  const toClient = messageSchema.toClient ?? {};
+  const toServer = messageSchema.toServer ?? {};
+  const typeName = (key2) => `${prefix}${toPascalCase(key2)}`;
+  const msgName = (dir, key2) => `${prefix}${dir}${toPascalCase(key2)}`;
+  const defs = {};
+  const add = (name2, schema11) => {
+    if (name2 in defs) {
+      throw new TypeGenerationError(`Duplicate generated type "${name2}" in actor "${actor.name}" — a shared type and a message resolve to the same name.`, actor.name);
+    }
+    defs[name2] = { ...schema11, title: name2 };
+  };
+  for (const [key2, schema11] of Object.entries(types)) {
+    add(typeName(key2), rewriteTypeRefs(schema11, typeName));
+  }
+  const compileMessages = (msgs, dir) => Object.entries(msgs).map(([key2, schema11]) => {
+    const name2 = msgName(dir, key2);
+    const rewritten = rewriteTypeRefs(schema11, typeName);
+    add(name2, {
+      type: "object",
+      ...rewritten,
+      properties: { type: { const: key2 }, ...rewritten.properties ?? {} },
+      required: [
+        "type",
+        ...rewritten.required ?? []
+      ],
+      additionalProperties: false
+    });
+    return name2;
+  });
+  const toClientNames = compileMessages(toClient, "ToClient");
+  const toServerNames = compileMessages(toServer, "ToServer");
+  const allNames = [...toClientNames, ...toServerNames];
+  const rootName = `${prefix}Message`;
+  const rootSchema = {
+    title: rootName,
+    $defs: defs,
+    oneOf: allNames.map((n5) => ({ $ref: `#/$defs/${n5}` }))
+  };
+  let decls = "";
+  try {
+    decls = (await import_json_schema_to_typescript.compile(rootSchema, rootName, {
+      bannerComment: "",
+      additionalProperties: false,
+      strictIndexSignatures: true
+    })).trim();
+  } catch (error48) {
+    throw new TypeGenerationError(`Failed to generate types for actor "${actor.name}"`, actor.name, error48);
+  }
+  const union2 = (names) => names.length ? names.join(" | ") : "never";
+  return {
+    decls,
+    entry: `{ toClient: ${union2(toClientNames)}; toServer: ${union2(toServerNames)} }`
+  };
+}
+function rewriteTypeRefs(node, defName) {
+  if (Array.isArray(node)) {
+    return node.map((n5) => rewriteTypeRefs(n5, defName));
+  }
+  if (node && typeof node === "object") {
+    const out = {};
+    for (const [key2, value] of Object.entries(node)) {
+      const match = key2 === "$ref" && typeof value === "string" ? value.match(/^#\/types\/(.+)$/) : null;
+      out[key2] = match ? `#/$defs/${defName(match[1])}` : rewriteTypeRefs(value, defName);
+    }
+    return out;
+  }
+  return node;
+}
 function registry2(name2, entries) {
   return import_common_tags.source`
     interface ${name2} {
@@ -254484,10 +254868,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 join24 } from "node:path";
+import { join as join27 } from "node:path";
 var TYPES_INCLUDE_PATH = `${PROJECT_SUBDIR}/${TYPES_OUTPUT_SUBDIR}/*.d.ts`;
 async function updateProjectConfig(projectRoot) {
-  const tsconfigPath = join24(projectRoot, "tsconfig.json");
+  const tsconfigPath = join27(projectRoot, "tsconfig.json");
   if (!await pathExists(tsconfigPath)) {
     return false;
   }
@@ -254511,14 +254895,15 @@ var TYPES_FILE_PATH = "base44/.types/types.d.ts";
 async function generateTypesAction({
   runTask: runTask2
 }) {
-  const { entities, functions, agents, connectors, project: project2 } = await readProjectConfig();
+  const { entities, functions, agents, connectors, actors, project: project2 } = await readProjectConfig();
   await runTask2("Generating types", async () => {
     await generateTypesFile({
       projectRoot: project2.root,
       entities,
       functions,
       agents,
-      connectors
+      connectors,
+      actors
     });
   });
   const tsconfigUpdated = await updateProjectConfig(project2.root);
@@ -254538,7 +254923,7 @@ function getTypesCommand() {
 // src/cli/dev/dev-server/main.ts
 var import_cors = __toESM(require_lib4(), 1);
 var import_express6 = __toESM(require_express(), 1);
-import { dirname as dirname21, join as join27 } from "node:path";
+import { dirname as dirname24, join as join30 } from "node:path";
 
 // ../../node_modules/get-port/index.js
 import net from "node:net";
@@ -254559,8 +254944,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 config12 of _interface) {
-      results.add(config12.address);
+    for (const config13 of _interface) {
+      results.add(config13.address);
     }
   }
   return results;
@@ -255200,22 +255585,22 @@ class Database {
     this.schemas.clear();
   }
   validate(entityName, record2, partial2 = false) {
-    const schema10 = this.schemas.get(this.normalizeName(entityName));
-    if (!schema10) {
+    const schema11 = this.schemas.get(this.normalizeName(entityName));
+    if (!schema11) {
       throw new Error(`Entity "${entityName}" not found`);
     }
-    return this.validator.validate(record2, schema10, partial2);
+    return this.validator.validate(record2, schema11, partial2);
   }
   prepareRecord(entityName, record2, partial2 = false) {
-    const schema10 = this.schemas.get(this.normalizeName(entityName));
-    if (!schema10) {
+    const schema11 = this.schemas.get(this.normalizeName(entityName));
+    if (!schema11) {
       throw new Error(`Entity "${entityName}" not found`);
     }
-    const filteredRecord = this.validator.filterFields(record2, schema10);
+    const filteredRecord = this.validator.filterFields(record2, schema11);
     if (partial2) {
       return filteredRecord;
     }
-    return this.validator.applyDefaults(filteredRecord, schema10);
+    return this.validator.applyDefaults(filteredRecord, schema11);
   }
   normalizeName(entityName) {
     return entityName.toLowerCase();
@@ -255509,13 +255894,13 @@ function checkRLS(rule, record2, user) {
     return false;
   return evaluateCondition(rule, record2, user);
 }
-function applyFLS(record2, schema10, user, operation) {
+function applyFLS(record2, schema11, user, operation) {
   if (Array.isArray(record2)) {
-    return record2.map((r5) => applyFLS(r5, schema10, user, operation));
+    return record2.map((r5) => applyFLS(r5, schema11, user, operation));
   }
   const result = {};
   for (const [key2, value] of Object.entries(record2)) {
-    const rule = schema10.properties[key2]?.rls?.[operation];
+    const rule = schema11.properties[key2]?.rls?.[operation];
     if (rule === undefined || checkRLS(rule, record2, user)) {
       result[key2] = value;
     }
@@ -255743,14 +256128,14 @@ async function createEntityRoutes(db2, logger2, broadcast) {
         res.status(404).json({ error: `Entity "${entityName}" not found` });
         return;
       }
-      const schema10 = db2.getSchema(entityName);
-      if (!schema10) {
+      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, schema10, currentUser);
+      await handler(req, res, collection, schema11, currentUser);
     };
   }
   function emit(appId, entityName, type, data) {
@@ -255768,19 +256153,19 @@ async function createEntityRoutes(db2, logger2, broadcast) {
     }
     broadcast(appId, entityName, createData(data));
   }
-  function prepareCreateRecord(entityName, body, schema10, 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(schema10.rls?.create, {
+    if (!checkRLS(schema11.rls?.create, {
       ...recordBody,
       ...ownerFields
     }, currentUser)) {
       return;
     }
-    const filteredBody = applyFLS(db2.prepareRecord(entityName, recordBody), schema10, currentUser, "write");
+    const filteredBody = applyFLS(db2.prepareRecord(entityName, recordBody), schema11, currentUser, "write");
     db2.validate(entityName, filteredBody);
     return {
       ...filteredBody,
@@ -255792,7 +256177,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, schema10, 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 });
@@ -255800,27 +256185,27 @@ async function createEntityRoutes(db2, logger2, broadcast) {
         res.status(404).json({ error: `Record with id "${id2}" not found` });
         return;
       }
-      if (!checkRLS(schema10.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), schema10, 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, schema10, 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 (schema10.rls?.read !== undefined && schema10.rls.read !== true) {
-        results = results.filter((doc2) => checkRLS(schema10.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, schema10, currentUser, "read"));
+      results = results.map((doc2) => applyFLS(doc2, schema11, currentUser, "read"));
       res.json(results);
     } catch (error48) {
       if (error48 instanceof InvalidInputError) {
@@ -255831,16 +256216,16 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       }
     }
   }));
-  router.post("/:entityName", parseBody, withCollection(async (req, res, collection, schema10, 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, schema10, 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)), schema10, 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) {
@@ -255852,7 +256237,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, schema10, 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" });
@@ -255862,14 +256247,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, schema10, 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)), schema10, 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) {
@@ -255881,24 +256266,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, schema10, 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 (schema10.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(schema10.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), schema10, currentUser, "write");
+      const filteredBody = applyFLS(db2.prepareRecord(entityName, body, true), schema11, currentUser, "write");
       db2.validate(entityName, filteredBody, true);
       const updateData = {
         ...filteredBody,
@@ -255909,7 +256294,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), schema10, currentUser, "read");
+      const updated = applyFLS(stripInternalFields(result.affectedDocuments), schema11, currentUser, "read");
       emit(appId, entityName, "update", updated);
       res.json(updated);
     } catch (error48) {
@@ -255921,7 +256306,7 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       res.status(500).json({ error: "Internal server error" });
     }
   }));
-  router.delete("/:entityName/:id", withCollection(async (req, res, collection, schema10, 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 });
@@ -255929,7 +256314,7 @@ async function createEntityRoutes(db2, logger2, broadcast) {
         res.status(404).json({ error: `Record with id "${id2}" not found` });
         return;
       }
-      if (!checkRLS(schema10.rls?.delete, doc2, currentUser)) {
+      if (!checkRLS(schema11.rls?.delete, doc2, currentUser)) {
         res.status(404).json({
           message: `Entity ${entityName} with ID ${id2} not found`
         });
@@ -255943,11 +256328,11 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       res.status(500).json({ error: "Internal server error" });
     }
   }));
-  router.delete("/:entityName", parseBody, withCollection(async (req, res, collection, schema10, currentUser) => {
+  router.delete("/:entityName", parseBody, withCollection(async (req, res, collection, schema11, currentUser) => {
     const { entityName } = req.params;
     try {
       const query = req.body || {};
-      const rlsDelete = schema10?.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" });
@@ -256166,7 +256551,7 @@ class ServeRunner {
 
 // src/cli/dev/dev-server/watcher.ts
 import { EventEmitter as EventEmitter4 } from "node:events";
-import { relative as relative6 } from "node:path";
+import { relative as relative8 } from "node:path";
 
 // ../../node_modules/chokidar/index.js
 import { EventEmitter as EventEmitter3 } from "node:events";
@@ -256336,10 +256721,10 @@ class ReaddirpStream extends Readable6 {
   }
   async _formatEntry(dirent, path19) {
     let entry;
-    const basename6 = this._isDirent ? dirent.name : dirent;
+    const basename7 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path19, basename6));
-      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename6 };
+      const fullPath = presolve(pjoin(path19, basename7));
+      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename7 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
       this._onError(err);
@@ -256866,9 +257251,9 @@ class NodeFsHandler {
   _watchWithNodeFs(path19, listener) {
     const opts = this.fsw.options;
     const directory = sp2.dirname(path19);
-    const basename7 = sp2.basename(path19);
+    const basename8 = sp2.basename(path19);
     const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename7);
+    parent.add(basename8);
     const absolutePath = sp2.resolve(path19);
     const options8 = {
       persistent: opts.persistent
@@ -256878,7 +257263,7 @@ class NodeFsHandler {
     let closer;
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
-      options8.interval = enableBin && isBinaryPath(basename7) ? opts.binaryInterval : opts.interval;
+      options8.interval = enableBin && isBinaryPath(basename8) ? opts.binaryInterval : opts.interval;
       closer = setFsWatchFileListener(path19, absolutePath, options8, {
         listener,
         rawEmitter: this.fsw._emitRaw
@@ -256896,11 +257281,11 @@ class NodeFsHandler {
     if (this.fsw.closed) {
       return;
     }
-    const dirname20 = sp2.dirname(file2);
-    const basename7 = sp2.basename(file2);
-    const parent = this.fsw._getWatchedDir(dirname20);
+    const dirname23 = sp2.dirname(file2);
+    const basename8 = sp2.basename(file2);
+    const parent = this.fsw._getWatchedDir(dirname23);
     let prevStats = stats;
-    if (parent.has(basename7))
+    if (parent.has(basename8))
       return;
     const listener = async (path19, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
@@ -256925,9 +257310,9 @@ class NodeFsHandler {
             prevStats = newStats2;
           }
         } catch (error48) {
-          this.fsw._remove(dirname20, basename7);
+          this.fsw._remove(dirname23, basename8);
         }
-      } else if (parent.has(basename7)) {
+      } else if (parent.has(basename8)) {
         const at13 = newStats.atimeMs;
         const mt12 = newStats.mtimeMs;
         if (!at13 || at13 <= mt12 || mt12 !== prevStats.mtimeMs) {
@@ -257148,11 +257533,11 @@ function createPattern(matcher) {
       if (matcher.path === string4)
         return true;
       if (matcher.recursive) {
-        const relative6 = sp3.relative(matcher.path, string4);
-        if (!relative6) {
+        const relative8 = sp3.relative(matcher.path, string4);
+        if (!relative8) {
           return false;
         }
-        return !relative6.startsWith("..") && !sp3.isAbsolute(relative6);
+        return !relative8.startsWith("..") && !sp3.isAbsolute(relative8);
       }
       return false;
     };
@@ -257851,7 +258236,7 @@ class WatchBase44 extends EventEmitter4 {
       ignoreInitial: true
     });
     watcher.on("all", import_debounce.default(async (_event, path19) => {
-      this.emit("change", name2, relative6(targetPath, path19));
+      this.emit("change", name2, relative8(targetPath, path19));
     }, WATCH_DEBOUNCE_MS));
     watcher.on("error", (err) => {
       this.logger.error(`Watch handler failed for ${targetPath}`, err);
@@ -257958,8 +258343,8 @@ async function createDevServer(options8) {
     broadcastEntityEvent(io6, appId, entityName, event);
   };
   const base44ConfigWatcher = new WatchBase44({
-    functions: join27(dirname21(project2.configPath), project2.functionsDir),
-    entities: join27(dirname21(project2.configPath), project2.entitiesDir)
+    functions: join30(dirname24(project2.configPath), project2.functionsDir),
+    entities: join30(dirname24(project2.configPath), project2.entitiesDir)
   }, devLogger);
   base44ConfigWatcher.on("change", async (name2) => {
     try {
@@ -258301,13 +258686,14 @@ function createProgram(context) {
   program2.addCommand(getCreateCommand());
   program2.addCommand(getScaffoldCommand());
   program2.addCommand(getDashboardCommand());
-  program2.addCommand(getDeployCommand2());
+  program2.addCommand(getDeployCommand3());
   program2.addCommand(getLinkCommand());
   program2.addCommand(getEjectCommand());
   program2.addCommand(getEntitiesPushCommand());
   program2.addCommand(getAgentsCommand());
   program2.addCommand(getConnectorsCommand());
   program2.addCommand(getFunctionsCommand());
+  program2.addCommand(getActorCommand());
   program2.addCommand(getSecretsCommand());
   program2.addCommand(getSandboxCommand());
   program2.addCommand(getAuthCommand());
@@ -258324,7 +258710,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 dirname22, posix, sep } from "path";
+import { dirname as dirname25, posix, sep } from "path";
 function createModulerModifier() {
   const getModuleFromFileName = createGetModuleFromFilename();
   return async (frames) => {
@@ -258333,7 +258719,7 @@ function createModulerModifier() {
     return frames;
   };
 }
-function createGetModuleFromFilename(basePath = process.argv[1] ? dirname22(process.argv[1]) : process.cwd(), isWindows5 = sep === "\\") {
+function createGetModuleFromFilename(basePath = process.argv[1] ? dirname25(process.argv[1]) : process.cwd(), isWindows5 = sep === "\\") {
   const normalizedBase = isWindows5 ? normalizeWindowsPath2(basePath) : basePath;
   return (filename) => {
     if (!filename)
@@ -262522,9 +262908,9 @@ function addCommandInfoToErrorReporter(program2, errorReporter) {
   });
 }
 // src/cli/index.ts
-var __dirname4 = dirname23(fileURLToPath6(import.meta.url));
+var __dirname4 = dirname26(fileURLToPath6(import.meta.url));
 async function runCLI(options8) {
-  ensureNpmAssets(join28(__dirname4, "../assets"));
+  ensureNpmAssets(join31(__dirname4, "../assets"));
   const errorReporter = new ErrorReporter;
   errorReporter.registerProcessErrorHandlers();
   const jsonMode = process.argv.includes("--json");
@@ -262563,4 +262949,4 @@ export {
   CLIExitError
 };
 
-//# debugId=E0C3AB7A49E7E6F964756E2164756E21
+//# debugId=D5262A0753D9292864756E2164756E21