@base44-preview/cli 0.1.8-pr.589.9d22ef2 → 0.1.9-pr.555.465f5ca

package/dist/cli/index.js

@@ -12978,12 +12978,12 @@ var require_schema = __commonJS((exports, module) => {
   var common = require_common3();
   var YAMLException = require_exception();
   var Type = require_type();
-  function compileList(schema2, name2, result) {
+  function compileList(schema3, name2, result) {
     var exclude = [];
-    schema2.include.forEach(function(includedSchema) {
+    schema3.include.forEach(function(includedSchema) {
       result = compileList(includedSchema, name2, result);
     });
-    schema2[name2].forEach(function(currentType) {
+    schema3[name2].forEach(function(currentType) {
       result.forEach(function(previousType, previousIndex) {
         if (previousType.tag === currentType.tag && previousType.kind === currentType.kind) {
           exclude.push(previousIndex);
@@ -13040,8 +13040,8 @@ var require_schema = __commonJS((exports, module) => {
     }
     schemas3 = common.toArray(schemas3);
     types = common.toArray(types);
-    if (!schemas3.every(function(schema2) {
-      return schema2 instanceof Schema;
+    if (!schemas3.every(function(schema3) {
+      return schema3 instanceof Schema;
     })) {
       throw new YAMLException("Specified list of super schemas (or a single Schema object) contains a non-Schema object.");
     }
@@ -15062,7 +15062,7 @@ var require_dumper = __commonJS((exports, module) => {
     "Off",
     "OFF"
   ];
-  function compileStyleMap(schema2, map2) {
+  function compileStyleMap(schema3, map2) {
     var result, keys, index, length, tag, style, type;
     if (map2 === null)
       return {};
@@ -15074,7 +15074,7 @@ var require_dumper = __commonJS((exports, module) => {
       if (tag.slice(0, 2) === "!!") {
         tag = "tag:yaml.org,2002:" + tag.slice(2);
       }
-      type = schema2.compiledTypeMap["fallback"][tag];
+      type = schema3.compiledTypeMap["fallback"][tag];
       if (type && _hasOwnProperty.call(type.styleAliases, style)) {
         style = type.styleAliases[style];
       }
@@ -16369,7 +16369,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: schema2, sourceObjects } = ctx;
+    const { aliasDuplicateObjects, onAnchor, onTagObj, schema: schema3, sourceObjects } = ctx;
     let ref = undefined;
     if (aliasDuplicateObjects && value && typeof value === "object") {
       ref = sourceObjects.get(value);
@@ -16383,7 +16383,7 @@ var require_createNode = __commonJS((exports) => {
     }
     if (tagName?.startsWith("!!"))
       tagName = defaultTagPrefix + tagName.slice(2);
-    let tagObj = findTagObject(value, tagName, schema2.tags);
+    let tagObj = findTagObject(value, tagName, schema3.tags);
     if (!tagObj) {
       if (value && typeof value.toJSON === "function") {
         value = value.toJSON();
@@ -16394,7 +16394,7 @@ var require_createNode = __commonJS((exports) => {
           ref.node = node2;
         return node2;
       }
-      tagObj = value instanceof Map ? schema2[identity.MAP] : (Symbol.iterator in Object(value)) ? schema2[identity.SEQ] : schema2[identity.MAP];
+      tagObj = value instanceof Map ? schema3[identity.MAP] : (Symbol.iterator in Object(value)) ? schema3[identity.SEQ] : schema3[identity.MAP];
     }
     if (onTagObj) {
       onTagObj(tagObj);
@@ -16417,7 +16417,7 @@ var require_Collection = __commonJS((exports) => {
   var createNode = require_createNode();
   var identity = require_identity();
   var Node2 = require_Node();
-  function collectionFromPath(schema2, path11, value) {
+  function collectionFromPath(schema3, path11, value) {
     let v = value;
     for (let i = path11.length - 1;i >= 0; --i) {
       const k2 = path11[i];
@@ -16435,27 +16435,27 @@ var require_Collection = __commonJS((exports) => {
       onAnchor: () => {
         throw new Error("This should not happen, please report a bug.");
       },
-      schema: schema2,
+      schema: schema3,
       sourceObjects: new Map
     });
   }
   var isEmptyPath = (path11) => path11 == null || typeof path11 === "object" && !!path11[Symbol.iterator]().next().done;
 
   class Collection extends Node2.NodeBase {
-    constructor(type, schema2) {
+    constructor(type, schema3) {
       super(type);
       Object.defineProperty(this, "schema", {
-        value: schema2,
+        value: schema3,
         configurable: true,
         enumerable: false,
         writable: true
       });
     }
-    clone(schema2) {
+    clone(schema3) {
       const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
-      if (schema2)
-        copy.schema = schema2;
-      copy.items = copy.items.map((it3) => identity.isNode(it3) || identity.isPair(it3) ? it3.clone(schema2) : it3);
+      if (schema3)
+        copy.schema = schema3;
+      copy.items = copy.items.map((it3) => identity.isNode(it3) || identity.isPair(it3) ? it3.clone(schema3) : it3);
       if (this.range)
         copy.range = this.range.slice();
       return copy;
@@ -17387,12 +17387,12 @@ var require_Pair = __commonJS((exports) => {
       this.key = key;
       this.value = value;
     }
-    clone(schema2) {
+    clone(schema3) {
       let { key, value } = this;
       if (identity.isNode(key))
-        key = key.clone(schema2);
+        key = key.clone(schema3);
       if (identity.isNode(value))
-        value = value.clone(schema2);
+        value = value.clone(schema3);
       return new Pair(key, value);
     }
     toJSON(_2, ctx) {
@@ -17577,13 +17577,13 @@ var require_YAMLMap = __commonJS((exports) => {
     static get tagName() {
       return "tag:yaml.org,2002:map";
     }
-    constructor(schema2) {
-      super(identity.MAP, schema2);
+    constructor(schema3) {
+      super(identity.MAP, schema3);
       this.items = [];
     }
-    static from(schema2, obj, ctx) {
+    static from(schema3, obj, ctx) {
       const { keepUndefined, replacer } = ctx;
-      const map2 = new this(schema2);
+      const map2 = new this(schema3);
       const add = (key, value) => {
         if (typeof replacer === "function")
           value = replacer.call(obj, key, value);
@@ -17599,8 +17599,8 @@ var require_YAMLMap = __commonJS((exports) => {
         for (const key of Object.keys(obj))
           add(key, obj[key]);
       }
-      if (typeof schema2.sortMapEntries === "function") {
-        map2.items.sort(schema2.sortMapEntries);
+      if (typeof schema3.sortMapEntries === "function") {
+        map2.items.sort(schema3.sortMapEntries);
       }
       return map2;
     }
@@ -17693,7 +17693,7 @@ var require_map2 = __commonJS((exports) => {
         onError("Expected a mapping for this tag");
       return map3;
     },
-    createNode: (schema2, obj, ctx) => YAMLMap.YAMLMap.from(schema2, obj, ctx)
+    createNode: (schema3, obj, ctx) => YAMLMap.YAMLMap.from(schema3, obj, ctx)
   };
   exports.map = map2;
 });
@@ -17711,8 +17711,8 @@ var require_YAMLSeq = __commonJS((exports) => {
     static get tagName() {
       return "tag:yaml.org,2002:seq";
     }
-    constructor(schema2) {
-      super(identity.SEQ, schema2);
+    constructor(schema3) {
+      super(identity.SEQ, schema3);
       this.items = [];
     }
     add(value) {
@@ -17766,9 +17766,9 @@ var require_YAMLSeq = __commonJS((exports) => {
         onComment
       });
     }
-    static from(schema2, obj, ctx) {
+    static from(schema3, obj, ctx) {
       const { replacer } = ctx;
-      const seq = new this(schema2);
+      const seq = new this(schema3);
       if (obj && Symbol.iterator in Object(obj)) {
         let i = 0;
         for (let it3 of obj) {
@@ -17805,7 +17805,7 @@ var require_seq2 = __commonJS((exports) => {
         onError("Expected a sequence for this tag");
       return seq2;
     },
-    createNode: (schema2, obj, ctx) => YAMLSeq.YAMLSeq.from(schema2, obj, ctx)
+    createNode: (schema3, obj, ctx) => YAMLSeq.YAMLSeq.from(schema3, obj, ctx)
   };
   exports.seq = seq;
 });
@@ -17980,7 +17980,7 @@ var require_schema2 = __commonJS((exports) => {
   var bool = require_bool2();
   var float = require_float2();
   var int2 = require_int2();
-  var schema2 = [
+  var schema3 = [
     map2.map,
     seq.seq,
     string4.string,
@@ -17993,7 +17993,7 @@ var require_schema2 = __commonJS((exports) => {
     float.floatExp,
     float.float
   ];
-  exports.schema = schema2;
+  exports.schema = schema3;
 });
 
 // ../../node_modules/yaml/dist/schema/json/schema.js
@@ -18056,8 +18056,8 @@ var require_schema3 = __commonJS((exports) => {
       return str;
     }
   };
-  var schema2 = [map2.map, seq.seq].concat(jsonScalars, jsonError);
-  exports.schema = schema2;
+  var schema3 = [map2.map, seq.seq].concat(jsonScalars, jsonError);
+  exports.schema = schema3;
 });
 
 // ../../node_modules/yaml/dist/schema/yaml-1.1/binary.js
@@ -18147,9 +18147,9 @@ ${cn.comment}` : item.comment;
       onError("Expected a sequence for this tag");
     return seq;
   }
-  function createPairs(schema2, iterable, ctx) {
+  function createPairs(schema3, iterable, ctx) {
     const { replacer } = ctx;
-    const pairs2 = new YAMLSeq.YAMLSeq(schema2);
+    const pairs2 = new YAMLSeq.YAMLSeq(schema3);
     pairs2.tag = "tag:yaml.org,2002:pairs";
     let i = 0;
     if (iterable && Symbol.iterator in Object(iterable))
@@ -18228,8 +18228,8 @@ var require_omap2 = __commonJS((exports) => {
       }
       return map2;
     }
-    static from(schema2, iterable, ctx) {
-      const pairs$1 = pairs.createPairs(schema2, iterable, ctx);
+    static from(schema3, iterable, ctx) {
+      const pairs$1 = pairs.createPairs(schema3, iterable, ctx);
       const omap2 = new this;
       omap2.items = pairs$1.items;
       return omap2;
@@ -18256,7 +18256,7 @@ var require_omap2 = __commonJS((exports) => {
       }
       return Object.assign(new YAMLOMap, pairs$1);
     },
-    createNode: (schema2, iterable, ctx) => YAMLOMap.from(schema2, iterable, ctx)
+    createNode: (schema3, iterable, ctx) => YAMLOMap.from(schema3, iterable, ctx)
   };
   exports.YAMLOMap = YAMLOMap;
   exports.omap = omap;
@@ -18420,8 +18420,8 @@ var require_set2 = __commonJS((exports) => {
   var YAMLMap = require_YAMLMap();
 
   class YAMLSet extends YAMLMap.YAMLMap {
-    constructor(schema2) {
-      super(schema2);
+    constructor(schema3) {
+      super(schema3);
       this.tag = YAMLSet.tag;
     }
     add(key) {
@@ -18461,9 +18461,9 @@ var require_set2 = __commonJS((exports) => {
       else
         throw new Error("Set items must all have null values");
     }
-    static from(schema2, iterable, ctx) {
+    static from(schema3, iterable, ctx) {
       const { replacer } = ctx;
-      const set3 = new this(schema2);
+      const set3 = new this(schema3);
       if (iterable && Symbol.iterator in Object(iterable))
         for (let value of iterable) {
           if (typeof replacer === "function")
@@ -18480,7 +18480,7 @@ var require_set2 = __commonJS((exports) => {
     nodeClass: YAMLSet,
     default: false,
     tag: "tag:yaml.org,2002:set",
-    createNode: (schema2, iterable, ctx) => YAMLSet.from(schema2, iterable, ctx),
+    createNode: (schema3, iterable, ctx) => YAMLSet.from(schema3, iterable, ctx),
     resolve(map2, onError) {
       if (identity.isMap(map2)) {
         if (map2.hasAllNullValues(true))
@@ -18593,7 +18593,7 @@ var require_schema4 = __commonJS((exports) => {
   var pairs = require_pairs2();
   var set2 = require_set2();
   var timestamp = require_timestamp2();
-  var schema2 = [
+  var schema3 = [
     map2.map,
     seq.seq,
     string4.string,
@@ -18616,7 +18616,7 @@ var require_schema4 = __commonJS((exports) => {
     timestamp.floatTime,
     timestamp.timestamp
   ];
-  exports.schema = schema2;
+  exports.schema = schema3;
 });
 
 // ../../node_modules/yaml/dist/schema/tags.js
@@ -18628,7 +18628,7 @@ var require_tags = __commonJS((exports) => {
   var bool = require_bool2();
   var float = require_float2();
   var int2 = require_int2();
-  var schema2 = require_schema2();
+  var schema3 = require_schema2();
   var schema$1 = require_schema3();
   var binary = require_binary2();
   var merge3 = require_merge3();
@@ -18638,7 +18638,7 @@ var require_tags = __commonJS((exports) => {
   var set2 = require_set2();
   var timestamp = require_timestamp2();
   var schemas3 = new Map([
-    ["core", schema2.schema],
+    ["core", schema3.schema],
     ["failsafe", [map2.map, seq.seq, string4.string]],
     ["json", schema$1.schema],
     ["yaml11", schema$2.schema],
@@ -18720,9 +18720,9 @@ var require_Schema = __commonJS((exports) => {
   var sortMapEntriesByKey = (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
 
   class Schema {
-    constructor({ compat: compat2, customTags, merge: merge3, resolveKnownTags, schema: schema2, sortMapEntries, toStringDefaults }) {
+    constructor({ compat: compat2, customTags, merge: merge3, resolveKnownTags, schema: schema3, sortMapEntries, toStringDefaults }) {
       this.compat = Array.isArray(compat2) ? tags.getTags(compat2, "compat") : compat2 ? tags.getTags(null, compat2) : null;
-      this.name = typeof schema2 === "string" && schema2 || "core";
+      this.name = typeof schema3 === "string" && schema3 || "core";
       this.knownTags = resolveKnownTags ? tags.coreKnownTags : {};
       this.tags = tags.getTags(customTags, this.name, merge3);
       this.toStringOptions = toStringDefaults ?? null;
@@ -20214,11 +20214,11 @@ var require_compose_scalar = __commonJS((exports) => {
       scalar.comment = comment;
     return scalar;
   }
-  function findScalarTagByName(schema2, value, tagName, tagToken, onError) {
+  function findScalarTagByName(schema3, value, tagName, tagToken, onError) {
     if (tagName === "!")
-      return schema2[identity.SCALAR];
+      return schema3[identity.SCALAR];
     const matchWithTest = [];
-    for (const tag of schema2.tags) {
+    for (const tag of schema3.tags) {
       if (!tag.collection && tag.tag === tagName) {
         if (tag.default && tag.test)
           matchWithTest.push(tag);
@@ -20229,18 +20229,18 @@ var require_compose_scalar = __commonJS((exports) => {
     for (const tag of matchWithTest)
       if (tag.test?.test(value))
         return tag;
-    const kt3 = schema2.knownTags[tagName];
+    const kt3 = schema3.knownTags[tagName];
     if (kt3 && !kt3.collection) {
-      schema2.tags.push(Object.assign({}, kt3, { default: false, test: undefined }));
+      schema3.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 schema2[identity.SCALAR];
+    return schema3[identity.SCALAR];
   }
-  function findScalarTagByTest({ atKey, directives, schema: schema2 }, value, token, onError) {
-    const tag = schema2.tags.find((tag2) => (tag2.default === true || atKey && tag2.default === "key") && tag2.test?.test(value)) || schema2[identity.SCALAR];
-    if (schema2.compat) {
-      const compat2 = schema2.compat.find((tag2) => tag2.default && tag2.test?.test(value)) ?? schema2[identity.SCALAR];
+  function findScalarTagByTest({ atKey, directives, schema: schema3 }, value, token, onError) {
+    const tag = schema3.tags.find((tag2) => (tag2.default === true || atKey && tag2.default === "key") && tag2.test?.test(value)) || schema3[identity.SCALAR];
+    if (schema3.compat) {
+      const compat2 = schema3.compat.find((tag2) => tag2.default && tag2.test?.test(value)) ?? schema3[identity.SCALAR];
       if (tag.tag !== compat2.tag) {
         const ts = directives.tagString(tag.tag);
         const cs = directives.tagString(compat2.tag);
@@ -22784,10 +22784,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 resolve3 = path11.resolve;
-    var includePath = resolve3(isDir ? filename : dirname9(filename), name2);
+    var includePath = resolve3(isDir ? filename : dirname11(filename), name2);
     var ext = extname(name2);
     if (!ext) {
       includePath += ".ejs";
@@ -23165,10 +23165,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
@@ -119578,11 +119578,11 @@ function chooseDescription(descriptions, printWidth) {
   return firstWidth > printWidth && firstWidth > secondWidth ? secondDescription : firstDescription;
 }
 function createSchema(SchemaConstructor, parameters) {
-  const schema12 = new SchemaConstructor(parameters);
-  const subSchema = Object.create(schema12);
+  const schema13 = new SchemaConstructor(parameters);
+  const subSchema = Object.create(schema13);
   for (const handlerKey of HANDLER_KEYS) {
     if (handlerKey in parameters) {
-      subSchema[handlerKey] = normalizeHandler(parameters[handlerKey], schema12, Schema2.prototype[handlerKey].length);
+      subSchema[handlerKey] = normalizeHandler(parameters[handlerKey], schema13, Schema2.prototype[handlerKey].length);
     }
   }
   return subSchema;
@@ -119839,8 +119839,8 @@ async function loadEditorconfigInternal(file2, { shouldCache }) {
   const directory = path52.dirname(file2);
   const root2 = await findProjectRoot2(directory, { shouldCache });
   const editorConfig = await import_editorconfig.default.parse(file2, { root: root2 });
-  const config13 = editorconfig_to_prettier_default(editorConfig);
-  return config13;
+  const config14 = editorconfig_to_prettier_default(editorConfig);
+  return config14;
 }
 function loadEditorconfig(file2, { shouldCache }) {
   file2 = path52.resolve(file2);
@@ -121830,18 +121830,18 @@ async function loadConfig(configFile) {
   if (!load2) {
     throw new Error(`No loader specified for extension "${extension || "noExt"}"`);
   }
-  let config13 = await load2(configFile);
-  if (!config13) {
+  let config14 = await load2(configFile);
+  if (!config14) {
     return;
   }
-  if (typeof config13 === "string") {
-    config13 = await load_external_config_default(config13, configFile);
+  if (typeof config14 === "string") {
+    config14 = await load_external_config_default(config14, configFile);
   }
-  if (typeof config13 !== "object") {
-    throw new TypeError(`Config is only allowed to be an object, but received ${typeof config13} in "${configFile}"`);
+  if (typeof config14 !== "object") {
+    throw new TypeError(`Config is only allowed to be an object, but received ${typeof config14} in "${configFile}"`);
   }
-  delete config13.$schema;
-  return config13;
+  delete config14.$schema;
+  return config14;
 }
 function clearPrettierConfigCache() {
   loadCache.clear();
@@ -121891,8 +121891,8 @@ async function loadPrettierConfig2(file2, options8) {
     return;
   }
   configFile = toPath3(configFile);
-  const config13 = await loadPrettierConfig(configFile, { shouldCache });
-  return { config: config13, configFile };
+  const config14 = await loadPrettierConfig(configFile, { shouldCache });
+  return { config: config14, configFile };
 }
 async function resolveConfig(fileUrlOrPath, options8) {
   options8 = { useCache: true, ...options8 };
@@ -121919,8 +121919,8 @@ async function resolveConfigFile(fileUrlOrPath) {
   return result ?? null;
 }
 function mergeOverrides(configResult, filePath) {
-  const { config: config13, configFile } = configResult || {};
-  const { overrides, ...options8 } = config13 || {};
+  const { config: config14, configFile } = configResult || {};
+  const { overrides, ...options8 } = config14 || {};
   if (filePath && overrides) {
     const relativeFilePath = path102.relative(path102.dirname(configFile), filePath);
     for (const override of overrides) {
@@ -122736,12 +122736,12 @@ function getLanguageByFileName(languages2, file2) {
   if (!file2) {
     return;
   }
-  const basename7 = getFileBasename(file2).toLowerCase();
+  const basename8 = getFileBasename(file2).toLowerCase();
   return languages2.find(({
     filenames
-  }) => filenames?.some((name2) => name2.toLowerCase() === basename7)) ?? languages2.find(({
+  }) => filenames?.some((name2) => name2.toLowerCase() === basename8)) ?? languages2.find(({
     extensions
-  }) => extensions?.some((extension) => basename7.endsWith(extension)));
+  }) => extensions?.some((extension) => basename8.endsWith(extension)));
 }
 function getLanguageByLanguageName(languages2, languageName) {
   if (!languageName) {
@@ -122922,9 +122922,9 @@ function optionInfoToSchema(optionInfo, {
       throw new Error(`Unexpected type ${optionInfo.type}`);
   }
   if (optionInfo.exception) {
-    parameters.validate = (value, schema12, utils3) => optionInfo.exception(value) || schema12.validate(value, utils3);
+    parameters.validate = (value, schema13, utils3) => optionInfo.exception(value) || schema13.validate(value, utils3);
   } else {
-    parameters.validate = (value, schema12, utils3) => value === undefined || schema12.validate(value, utils3);
+    parameters.validate = (value, schema13, utils3) => value === undefined || schema13.validate(value, utils3);
   }
   if (optionInfo.redirect) {
     handlers.redirect = (value) => !value ? undefined : {
@@ -122939,7 +122939,7 @@ function optionInfoToSchema(optionInfo, {
   }
   if (isCLI && !optionInfo.array) {
     const originalPreprocess = parameters.preprocess || ((x10) => x10);
-    parameters.preprocess = (value, schema12, utils3) => schema12.preprocess(originalPreprocess(Array.isArray(value) ? method_at_default2(0, value, -1) : value), utils3);
+    parameters.preprocess = (value, schema13, utils3) => schema13.preprocess(originalPreprocess(Array.isArray(value) ? method_at_default2(0, value, -1) : value), utils3);
   }
   return optionInfo.array ? ArraySchema.create({
     ...isCLI ? {
@@ -124029,16 +124029,16 @@ async function getFileInfo(file2, options8 = {}) {
   };
 }
 async function getParser(file2, options8) {
-  let config13;
+  let config14;
   if (options8.resolveConfig !== false) {
-    config13 = await resolveConfig(file2, {
+    config14 = await resolveConfig(file2, {
       editorconfig: false
     });
   }
-  if (config13?.parser) {
-    return config13.parser;
+  if (config14?.parser) {
+    return config14.parser;
   }
-  let plugins = options8.plugins ?? config13?.plugins ?? [];
+  let plugins = options8.plugins ?? config14?.plugins ?? [];
   plugins = (await Promise.all([load_builtin_plugins_default(), load_plugins_default(plugins)])).flat();
   return infer_parser_default({ plugins }, { physicalFile: file2 });
 }
@@ -124516,9 +124516,9 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc2,
     };
     applyNormalization();
     for (const key2 of Object.keys(this._utils.schemas)) {
-      const schema12 = this._utils.schemas[key2];
+      const schema13 = this._utils.schemas[key2];
       if (!(key2 in newOptions)) {
-        const defaultResult = normalizeDefaultResult(schema12.default(this._utils));
+        const defaultResult = normalizeDefaultResult(schema13.default(this._utils));
         if ("value" in defaultResult) {
           restOptionsArray.push({ [key2]: defaultResult.value });
         }
@@ -124529,13 +124529,13 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc2,
       if (!(key2 in newOptions)) {
         continue;
       }
-      const schema12 = this._utils.schemas[key2];
+      const schema13 = this._utils.schemas[key2];
       const value = newOptions[key2];
-      const newValue = schema12.postprocess(value, this._utils);
+      const newValue = schema13.postprocess(value, this._utils);
       if (newValue === VALUE_UNCHANGED) {
         continue;
       }
-      this._applyValidation(newValue, key2, schema12);
+      this._applyValidation(newValue, key2, schema13);
       newOptions[key2] = newValue;
     }
     this._applyPostprocess(newOptions);
@@ -124546,14 +124546,14 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc2,
     const transferredOptionsArray = [];
     const { knownKeys, unknownKeys } = this._partitionOptionKeys(options8);
     for (const key2 of knownKeys) {
-      const schema12 = this._utils.schemas[key2];
-      const value = schema12.preprocess(options8[key2], this._utils);
-      this._applyValidation(value, key2, schema12);
+      const schema13 = this._utils.schemas[key2];
+      const value = schema13.preprocess(options8[key2], this._utils);
+      this._applyValidation(value, key2, schema13);
       const appendTransferredOptions = ({ from, to: to5 }) => {
         transferredOptionsArray.push(typeof to5 === "string" ? { [to5]: from } : { [to5.key]: to5.value });
       };
       const warnDeprecated = ({ value: currentValue, redirectTo }) => {
-        const deprecatedResult = normalizeDeprecatedResult(schema12.deprecated(currentValue, this._utils), value, true);
+        const deprecatedResult = normalizeDeprecatedResult(schema13.deprecated(currentValue, this._utils), value, true);
         if (deprecatedResult === false) {
           return;
         }
@@ -124571,13 +124571,13 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc2,
           }
         }
       };
-      const forwardResult = normalizeForwardResult(schema12.forward(value, this._utils), value);
+      const forwardResult = normalizeForwardResult(schema13.forward(value, this._utils), value);
       forwardResult.forEach(appendTransferredOptions);
-      const redirectResult = normalizeRedirectResult(schema12.redirect(value, this._utils), value);
+      const redirectResult = normalizeRedirectResult(schema13.redirect(value, this._utils), value);
       redirectResult.redirect.forEach(appendTransferredOptions);
       if ("remain" in redirectResult) {
         const remainingValue = redirectResult.remain;
-        newOptions[key2] = key2 in newOptions ? schema12.overlap(newOptions[key2], remainingValue, this._utils) : remainingValue;
+        newOptions[key2] = key2 in newOptions ? schema13.overlap(newOptions[key2], remainingValue, this._utils) : remainingValue;
         warnDeprecated({ value: remainingValue });
       }
       for (const { from, to: to5 } of redirectResult.redirect) {
@@ -124605,8 +124605,8 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc2,
     const [knownKeys, unknownKeys] = partition(Object.keys(options8).filter((key2) => !this._identifyMissing(key2, options8)), (key2) => (key2 in this._utils.schemas));
     return { knownKeys, unknownKeys };
   }
-  _applyValidation(value, key2, schema12) {
-    const validateResult = normalizeValidateResult(schema12.validate(value, this._utils), value);
+  _applyValidation(value, key2, schema13) {
+    const validateResult = normalizeValidateResult(schema13.validate(value, this._utils), value);
     if (validateResult !== true) {
       throw this._invalidHandler(key2, validateResult.value, this._utils);
     }
@@ -124648,8 +124648,8 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc2,
       for (const key2 of unknownKeys) {
         const value = postprocessed.override[key2];
         this._applyUnknownHandler(key2, value, options8, (knownResultKey, knownResultValue) => {
-          const schema12 = this._utils.schemas[knownResultKey];
-          this._applyValidation(knownResultValue, knownResultKey, schema12);
+          const schema13 = this._utils.schemas[knownResultKey];
+          this._applyValidation(knownResultValue, knownResultKey, schema13);
           options8[knownResultKey] = knownResultValue;
         });
       }
@@ -127963,8 +127963,8 @@ var init_prettier = __esm(() => {
       }
       exports.endsWithSlashGlobStar = endsWithSlashGlobStar;
       function isAffectDepthOfReadingPattern(pattern) {
-        const basename7 = path152.basename(pattern);
-        return endsWithSlashGlobStar(pattern) || isStaticPattern(basename7);
+        const basename8 = path152.basename(pattern);
+        return endsWithSlashGlobStar(pattern) || isStaticPattern(basename8);
       }
       exports.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
       function expandPatternsWithBraceExpansion(patterns) {
@@ -138362,23 +138362,23 @@ var require_JSONSchema = __commonJS((exports) => {
   exports.Parent = Symbol("Parent");
   exports.Types = Symbol("Types");
   exports.Intersection = Symbol("Intersection");
-  exports.getRootSchema = (0, lodash_1.memoize)((schema12) => {
-    const parent = schema12[exports.Parent];
+  exports.getRootSchema = (0, lodash_1.memoize)((schema13) => {
+    const parent = schema13[exports.Parent];
     if (!parent) {
-      return schema12;
+      return schema13;
     }
     return (0, exports.getRootSchema)(parent);
   });
-  function isBoolean(schema12) {
-    return schema12 === true || schema12 === false;
+  function isBoolean(schema13) {
+    return schema13 === true || schema13 === false;
   }
   exports.isBoolean = isBoolean;
-  function isPrimitive(schema12) {
-    return !(0, lodash_1.isPlainObject)(schema12);
+  function isPrimitive(schema13) {
+    return !(0, lodash_1.isPlainObject)(schema13);
   }
   exports.isPrimitive = isPrimitive;
-  function isCompound(schema12) {
-    return Array.isArray(schema12.type) || "anyOf" in schema12 || "oneOf" in schema12;
+  function isCompound(schema13) {
+    return Array.isArray(schema13.type) || "anyOf" in schema13 || "oneOf" in schema13;
   }
   exports.isCompound = isCompound;
 });
@@ -138605,9 +138605,9 @@ var require_type2 = __commonJS((exports, module) => {
 var require_schema5 = __commonJS((exports, module) => {
   var YAMLException = require_exception2();
   var Type = require_type2();
-  function compileList(schema12, name2) {
+  function compileList(schema13, name2) {
     var result = [];
-    schema12[name2].forEach(function(currentType) {
+    schema13[name2].forEach(function(currentType) {
       var newIndex = result.length;
       result.forEach(function(previousType, previousIndex) {
         if (previousType.tag === currentType.tag && previousType.kind === currentType.kind && previousType.multi === currentType.multi) {
@@ -140552,7 +140552,7 @@ var require_dumper2 = __commonJS((exports, module) => {
     "OFF"
   ];
   var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;
-  function compileStyleMap(schema12, map2) {
+  function compileStyleMap(schema13, map2) {
     var result, keys, index, length, tag, style, type;
     if (map2 === null)
       return {};
@@ -140564,7 +140564,7 @@ var require_dumper2 = __commonJS((exports, module) => {
       if (tag.slice(0, 2) === "!!") {
         tag = "tag:yaml.org,2002:" + tag.slice(2);
       }
-      type = schema12.compiledTypeMap["fallback"][tag];
+      type = schema13.compiledTypeMap["fallback"][tag];
       if (type && _hasOwnProperty.call(type.styleAliases, style)) {
         style = type.styleAliases[style];
       }
@@ -141223,11 +141223,11 @@ var require_utils7 = __commonJS((exports) => {
   function traverseArray(arr, callback, processed) {
     arr.forEach((s5, k9) => traverse(s5, callback, processed, k9.toString()));
   }
-  function traverseIntersection(schema12, callback, processed) {
-    if (typeof schema12 !== "object" || !schema12) {
+  function traverseIntersection(schema13, callback, processed) {
+    if (typeof schema13 !== "object" || !schema13) {
       return;
     }
-    const r5 = schema12;
+    const r5 = schema13;
     const intersection2 = r5[JSONSchema_1.Intersection];
     if (!intersection2) {
       return;
@@ -141236,60 +141236,60 @@ var require_utils7 = __commonJS((exports) => {
       traverseArray(intersection2.allOf, callback, processed);
     }
   }
-  function traverse(schema12, callback, processed = new Set, key2) {
-    if (processed.has(schema12)) {
+  function traverse(schema13, callback, processed = new Set, key2) {
+    if (processed.has(schema13)) {
       return;
     }
-    processed.add(schema12);
-    callback(schema12, key2 !== null && key2 !== undefined ? key2 : null);
-    if (schema12.anyOf) {
-      traverseArray(schema12.anyOf, callback, processed);
+    processed.add(schema13);
+    callback(schema13, key2 !== null && key2 !== undefined ? key2 : null);
+    if (schema13.anyOf) {
+      traverseArray(schema13.anyOf, callback, processed);
     }
-    if (schema12.allOf) {
-      traverseArray(schema12.allOf, callback, processed);
+    if (schema13.allOf) {
+      traverseArray(schema13.allOf, callback, processed);
     }
-    if (schema12.oneOf) {
-      traverseArray(schema12.oneOf, callback, processed);
+    if (schema13.oneOf) {
+      traverseArray(schema13.oneOf, callback, processed);
     }
-    if (schema12.properties) {
-      traverseObjectKeys(schema12.properties, callback, processed);
+    if (schema13.properties) {
+      traverseObjectKeys(schema13.properties, callback, processed);
     }
-    if (schema12.patternProperties) {
-      traverseObjectKeys(schema12.patternProperties, callback, processed);
+    if (schema13.patternProperties) {
+      traverseObjectKeys(schema13.patternProperties, callback, processed);
     }
-    if (schema12.additionalProperties && typeof schema12.additionalProperties === "object") {
-      traverse(schema12.additionalProperties, callback, processed);
+    if (schema13.additionalProperties && typeof schema13.additionalProperties === "object") {
+      traverse(schema13.additionalProperties, callback, processed);
     }
-    if (schema12.items) {
-      const { items } = schema12;
+    if (schema13.items) {
+      const { items } = schema13;
       if (Array.isArray(items)) {
         traverseArray(items, callback, processed);
       } else {
         traverse(items, callback, processed);
       }
     }
-    if (schema12.additionalItems && typeof schema12.additionalItems === "object") {
-      traverse(schema12.additionalItems, callback, processed);
+    if (schema13.additionalItems && typeof schema13.additionalItems === "object") {
+      traverse(schema13.additionalItems, callback, processed);
     }
-    if (schema12.dependencies) {
-      if (Array.isArray(schema12.dependencies)) {
-        traverseArray(schema12.dependencies, callback, processed);
+    if (schema13.dependencies) {
+      if (Array.isArray(schema13.dependencies)) {
+        traverseArray(schema13.dependencies, callback, processed);
       } else {
-        traverseObjectKeys(schema12.dependencies, callback, processed);
+        traverseObjectKeys(schema13.dependencies, callback, processed);
       }
     }
-    if (schema12.definitions) {
-      traverseObjectKeys(schema12.definitions, callback, processed);
+    if (schema13.definitions) {
+      traverseObjectKeys(schema13.definitions, callback, processed);
     }
-    if (schema12.$defs) {
-      traverseObjectKeys(schema12.$defs, callback, processed);
+    if (schema13.$defs) {
+      traverseObjectKeys(schema13.$defs, callback, processed);
     }
-    if (schema12.not) {
-      traverse(schema12.not, callback, processed);
+    if (schema13.not) {
+      traverse(schema13.not, callback, processed);
     }
-    traverseIntersection(schema12, callback, processed);
-    Object.keys(schema12).filter((key3) => !BLACKLISTED_KEYS.has(key3)).forEach((key3) => {
-      const child = schema12[key3];
+    traverseIntersection(schema13, callback, processed);
+    Object.keys(schema13).filter((key3) => !BLACKLISTED_KEYS.has(key3)).forEach((key3) => {
+      const child = schema13[key3];
       if (child && typeof child === "object") {
         traverseObjectKeys(child, callback, processed);
       }
@@ -141371,14 +141371,14 @@ var require_utils7 = __commonJS((exports) => {
         return (_g2 = color()) === null || _g2 === undefined ? undefined : _g2.whiteBright.bgYellow;
     }
   }
-  function escapeBlockComment(schema12) {
+  function escapeBlockComment(schema13) {
     const replacer = "* /";
-    if (schema12 === null || typeof schema12 !== "object") {
+    if (schema13 === null || typeof schema13 !== "object") {
       return;
     }
-    for (const key2 of Object.keys(schema12)) {
-      if (key2 === "description" && typeof schema12[key2] === "string") {
-        schema12[key2] = schema12[key2].replace(/\*\//g, replacer);
+    for (const key2 of Object.keys(schema13)) {
+      if (key2 === "description" && typeof schema13[key2] === "string") {
+        schema13[key2] = schema13[key2].replace(/\*\//g, replacer);
       }
     }
   }
@@ -141390,45 +141390,45 @@ var require_utils7 = __commonJS((exports) => {
     return path_1.posix.join(path_1.posix.normalize(outputPath), ...filePathRel);
   }
   exports.pathTransform = pathTransform;
-  function maybeStripDefault(schema12) {
-    if (!("default" in schema12)) {
-      return schema12;
+  function maybeStripDefault(schema13) {
+    if (!("default" in schema13)) {
+      return schema13;
     }
-    switch (schema12.type) {
+    switch (schema13.type) {
       case "array":
-        if (Array.isArray(schema12.default)) {
-          return schema12;
+        if (Array.isArray(schema13.default)) {
+          return schema13;
         }
         break;
       case "boolean":
-        if (typeof schema12.default === "boolean") {
-          return schema12;
+        if (typeof schema13.default === "boolean") {
+          return schema13;
         }
         break;
       case "integer":
       case "number":
-        if (typeof schema12.default === "number") {
-          return schema12;
+        if (typeof schema13.default === "number") {
+          return schema13;
         }
         break;
       case "string":
-        if (typeof schema12.default === "string") {
-          return schema12;
+        if (typeof schema13.default === "string") {
+          return schema13;
         }
         break;
       case "null":
-        if (schema12.default === null) {
-          return schema12;
+        if (schema13.default === null) {
+          return schema13;
         }
         break;
       case "object":
-        if ((0, lodash_1.isPlainObject)(schema12.default)) {
-          return schema12;
+        if ((0, lodash_1.isPlainObject)(schema13.default)) {
+          return schema13;
         }
         break;
     }
-    delete schema12.default;
-    return schema12;
+    delete schema13.default;
+    return schema13;
   }
   exports.maybeStripDefault = maybeStripDefault;
   function appendToDescription(existingDescription, ...values) {
@@ -141442,11 +141442,11 @@ ${values.join(`
 `);
   }
   exports.appendToDescription = appendToDescription;
-  function isSchemaLike(schema12) {
-    if (!(0, lodash_1.isPlainObject)(schema12)) {
+  function isSchemaLike(schema13) {
+    if (!(0, lodash_1.isPlainObject)(schema13)) {
       return false;
     }
-    const parent = schema12[JSONSchema_1.Parent];
+    const parent = schema13[JSONSchema_1.Parent];
     if (parent === null) {
       return true;
     }
@@ -141463,7 +141463,7 @@ ${values.join(`
       "properties",
       "required"
     ];
-    if (JSON_SCHEMA_KEYWORDS.some((_10) => parent[_10] === schema12)) {
+    if (JSON_SCHEMA_KEYWORDS.some((_10) => parent[_10] === schema13)) {
       return false;
     }
     return true;
@@ -141761,13 +141761,13 @@ var require_typesOfSchema = __commonJS((exports) => {
   exports.typesOfSchema = undefined;
   var lodash_1 = require_lodash8();
   var JSONSchema_1 = require_JSONSchema();
-  function typesOfSchema(schema12) {
-    if (schema12.tsType) {
+  function typesOfSchema(schema13) {
+    if (schema13.tsType) {
       return new Set(["CUSTOM_TYPE"]);
     }
     const matchedTypes = new Set;
     for (const [schemaType, f7] of Object.entries(matchers)) {
-      if (f7(schema12)) {
+      if (f7(schema13)) {
         matchedTypes.add(schemaType);
       }
     }
@@ -141778,26 +141778,26 @@ var require_typesOfSchema = __commonJS((exports) => {
   }
   exports.typesOfSchema = typesOfSchema;
   var matchers = {
-    ALL_OF(schema12) {
-      return "allOf" in schema12;
+    ALL_OF(schema13) {
+      return "allOf" in schema13;
     },
-    ANY(schema12) {
-      if (Object.keys(schema12).length === 0) {
+    ANY(schema13) {
+      if (Object.keys(schema13).length === 0) {
         return true;
       }
-      return schema12.type === "any";
+      return schema13.type === "any";
     },
-    ANY_OF(schema12) {
-      return "anyOf" in schema12;
+    ANY_OF(schema13) {
+      return "anyOf" in schema13;
     },
-    BOOLEAN(schema12) {
-      if ("enum" in schema12) {
+    BOOLEAN(schema13) {
+      if ("enum" in schema13) {
         return false;
       }
-      if (schema12.type === "boolean") {
+      if (schema13.type === "boolean") {
         return true;
       }
-      if (!(0, JSONSchema_1.isCompound)(schema12) && typeof schema12.default === "boolean") {
+      if (!(0, JSONSchema_1.isCompound)(schema13) && typeof schema13.default === "boolean") {
         return true;
       }
       return false;
@@ -141805,74 +141805,74 @@ var require_typesOfSchema = __commonJS((exports) => {
     CUSTOM_TYPE() {
       return false;
     },
-    NAMED_ENUM(schema12) {
-      return "enum" in schema12 && "tsEnumNames" in schema12;
+    NAMED_ENUM(schema13) {
+      return "enum" in schema13 && "tsEnumNames" in schema13;
     },
-    NAMED_SCHEMA(schema12) {
-      return "$id" in schema12 && (("patternProperties" in schema12) || ("properties" in schema12));
+    NAMED_SCHEMA(schema13) {
+      return "$id" in schema13 && (("patternProperties" in schema13) || ("properties" in schema13));
     },
-    NEVER(schema12) {
-      return schema12 === false;
+    NEVER(schema13) {
+      return schema13 === false;
     },
-    NULL(schema12) {
-      return schema12.type === "null";
+    NULL(schema13) {
+      return schema13.type === "null";
     },
-    NUMBER(schema12) {
-      if ("enum" in schema12) {
+    NUMBER(schema13) {
+      if ("enum" in schema13) {
         return false;
       }
-      if (schema12.type === "integer" || schema12.type === "number") {
+      if (schema13.type === "integer" || schema13.type === "number") {
         return true;
       }
-      if (!(0, JSONSchema_1.isCompound)(schema12) && typeof schema12.default === "number") {
+      if (!(0, JSONSchema_1.isCompound)(schema13) && typeof schema13.default === "number") {
         return true;
       }
       return false;
     },
-    OBJECT(schema12) {
-      return schema12.type === "object" && !(0, lodash_1.isPlainObject)(schema12.additionalProperties) && !schema12.allOf && !schema12.anyOf && !schema12.oneOf && !schema12.patternProperties && !schema12.properties && !schema12.required;
+    OBJECT(schema13) {
+      return schema13.type === "object" && !(0, lodash_1.isPlainObject)(schema13.additionalProperties) && !schema13.allOf && !schema13.anyOf && !schema13.oneOf && !schema13.patternProperties && !schema13.properties && !schema13.required;
     },
-    ONE_OF(schema12) {
-      return "oneOf" in schema12;
+    ONE_OF(schema13) {
+      return "oneOf" in schema13;
     },
-    REFERENCE(schema12) {
-      return "$ref" in schema12;
+    REFERENCE(schema13) {
+      return "$ref" in schema13;
     },
-    STRING(schema12) {
-      if ("enum" in schema12) {
+    STRING(schema13) {
+      if ("enum" in schema13) {
         return false;
       }
-      if (schema12.type === "string") {
+      if (schema13.type === "string") {
         return true;
       }
-      if (!(0, JSONSchema_1.isCompound)(schema12) && typeof schema12.default === "string") {
+      if (!(0, JSONSchema_1.isCompound)(schema13) && typeof schema13.default === "string") {
         return true;
       }
       return false;
     },
-    TYPED_ARRAY(schema12) {
-      if (schema12.type && schema12.type !== "array") {
+    TYPED_ARRAY(schema13) {
+      if (schema13.type && schema13.type !== "array") {
         return false;
       }
-      return "items" in schema12;
+      return "items" in schema13;
     },
-    UNION(schema12) {
-      return Array.isArray(schema12.type);
+    UNION(schema13) {
+      return Array.isArray(schema13.type);
     },
-    UNNAMED_ENUM(schema12) {
-      if ("tsEnumNames" in schema12) {
+    UNNAMED_ENUM(schema13) {
+      if ("tsEnumNames" in schema13) {
         return false;
       }
-      if (schema12.type && schema12.type !== "boolean" && schema12.type !== "integer" && schema12.type !== "number" && schema12.type !== "string") {
+      if (schema13.type && schema13.type !== "boolean" && schema13.type !== "integer" && schema13.type !== "number" && schema13.type !== "string") {
         return false;
       }
-      return "enum" in schema12;
+      return "enum" in schema13;
     },
     UNNAMED_SCHEMA() {
       return false;
     },
-    UNTYPED_ARRAY(schema12) {
-      return schema12.type === "array" && !("items" in schema12);
+    UNTYPED_ARRAY(schema13) {
+      return schema13.type === "array" && !("items" in schema13);
     }
   };
 });
@@ -141883,10 +141883,10 @@ var require_applySchemaTyping = __commonJS((exports) => {
   exports.applySchemaTyping = undefined;
   var JSONSchema_1 = require_JSONSchema();
   var typesOfSchema_1 = require_typesOfSchema();
-  function applySchemaTyping(schema12) {
+  function applySchemaTyping(schema13) {
     var _a7;
-    const types = (0, typesOfSchema_1.typesOfSchema)(schema12);
-    Object.defineProperty(schema12, JSONSchema_1.Types, {
+    const types = (0, typesOfSchema_1.typesOfSchema)(schema13);
+    Object.defineProperty(schema13, JSONSchema_1.Types, {
       enumerable: false,
       value: types,
       writable: false
@@ -141895,23 +141895,23 @@ var require_applySchemaTyping = __commonJS((exports) => {
       return;
     }
     const intersection2 = {
-      [JSONSchema_1.Parent]: schema12,
+      [JSONSchema_1.Parent]: schema13,
       [JSONSchema_1.Types]: new Set(["ALL_OF"]),
-      $id: schema12.$id,
-      description: schema12.description,
-      name: schema12.name,
-      title: schema12.title,
-      allOf: (_a7 = schema12.allOf) !== null && _a7 !== undefined ? _a7 : [],
+      $id: schema13.$id,
+      description: schema13.description,
+      name: schema13.name,
+      title: schema13.title,
+      allOf: (_a7 = schema13.allOf) !== null && _a7 !== undefined ? _a7 : [],
       required: [],
       additionalProperties: false
     };
     types.delete("ALL_OF");
-    delete schema12.allOf;
-    delete schema12.$id;
-    delete schema12.description;
-    delete schema12.name;
-    delete schema12.title;
-    Object.defineProperty(schema12, JSONSchema_1.Intersection, {
+    delete schema13.allOf;
+    delete schema13.$id;
+    delete schema13.description;
+    delete schema13.name;
+    delete schema13.title;
+    Object.defineProperty(schema13, JSONSchema_1.Intersection, {
       enumerable: false,
       value: intersection2,
       writable: false
@@ -141929,186 +141929,186 @@ var require_normalizer = __commonJS((exports) => {
   var applySchemaTyping_1 = require_applySchemaTyping();
   var util_1 = __require("util");
   var rules = new Map;
-  function hasType(schema12, type) {
-    return schema12.type === type || Array.isArray(schema12.type) && schema12.type.includes(type);
+  function hasType(schema13, type) {
+    return schema13.type === type || Array.isArray(schema13.type) && schema13.type.includes(type);
   }
-  function isObjectType(schema12) {
-    return schema12.properties !== undefined || hasType(schema12, "object") || hasType(schema12, "any");
+  function isObjectType(schema13) {
+    return schema13.properties !== undefined || hasType(schema13, "object") || hasType(schema13, "any");
   }
-  function isArrayType(schema12) {
-    return schema12.items !== undefined || hasType(schema12, "array") || hasType(schema12, "any");
+  function isArrayType(schema13) {
+    return schema13.items !== undefined || hasType(schema13, "array") || hasType(schema13, "any");
   }
-  function isEnumTypeWithoutTsEnumNames(schema12) {
-    return schema12.type === "string" && schema12.enum !== undefined && schema12.tsEnumNames === undefined;
+  function isEnumTypeWithoutTsEnumNames(schema13) {
+    return schema13.type === "string" && schema13.enum !== undefined && schema13.tsEnumNames === undefined;
   }
-  rules.set('Remove `type=["null"]` if `enum=[null]`', (schema12) => {
-    if (Array.isArray(schema12.enum) && schema12.enum.some((e8) => e8 === null) && Array.isArray(schema12.type) && schema12.type.includes("null")) {
-      schema12.type = schema12.type.filter((type) => type !== "null");
+  rules.set('Remove `type=["null"]` if `enum=[null]`', (schema13) => {
+    if (Array.isArray(schema13.enum) && schema13.enum.some((e8) => e8 === null) && Array.isArray(schema13.type) && schema13.type.includes("null")) {
+      schema13.type = schema13.type.filter((type) => type !== "null");
     }
   });
-  rules.set("Destructure unary types", (schema12) => {
-    if (schema12.type && Array.isArray(schema12.type) && schema12.type.length === 1) {
-      schema12.type = schema12.type[0];
+  rules.set("Destructure unary types", (schema13) => {
+    if (schema13.type && Array.isArray(schema13.type) && schema13.type.length === 1) {
+      schema13.type = schema13.type[0];
     }
   });
-  rules.set("Add empty `required` property if none is defined", (schema12) => {
-    if (isObjectType(schema12) && !("required" in schema12)) {
-      schema12.required = [];
+  rules.set("Add empty `required` property if none is defined", (schema13) => {
+    if (isObjectType(schema13) && !("required" in schema13)) {
+      schema13.required = [];
     }
   });
-  rules.set("Transform `required`=false to `required`=[]", (schema12) => {
-    if (schema12.required === false) {
-      schema12.required = [];
+  rules.set("Transform `required`=false to `required`=[]", (schema13) => {
+    if (schema13.required === false) {
+      schema13.required = [];
     }
   });
-  rules.set("Default additionalProperties", (schema12, _10, options8) => {
-    if (isObjectType(schema12) && !("additionalProperties" in schema12) && schema12.patternProperties === undefined) {
-      schema12.additionalProperties = options8.additionalProperties;
+  rules.set("Default additionalProperties", (schema13, _10, options8) => {
+    if (isObjectType(schema13) && !("additionalProperties" in schema13) && schema13.patternProperties === undefined) {
+      schema13.additionalProperties = options8.additionalProperties;
     }
   });
-  rules.set("Transform id to $id", (schema12, fileName) => {
-    if (!(0, utils_1.isSchemaLike)(schema12)) {
+  rules.set("Transform id to $id", (schema13, fileName) => {
+    if (!(0, utils_1.isSchemaLike)(schema13)) {
       return;
     }
-    if (schema12.id && schema12.$id && schema12.id !== schema12.$id) {
-      throw ReferenceError(`Schema must define either id or $id, not both. Given id=${schema12.id}, $id=${schema12.$id} in ${fileName}`);
+    if (schema13.id && schema13.$id && schema13.id !== schema13.$id) {
+      throw ReferenceError(`Schema must define either id or $id, not both. Given id=${schema13.id}, $id=${schema13.$id} in ${fileName}`);
     }
-    if (schema12.id) {
-      schema12.$id = schema12.id;
-      delete schema12.id;
+    if (schema13.id) {
+      schema13.$id = schema13.id;
+      delete schema13.id;
     }
   });
-  rules.set("Add an $id to anything that needs it", (schema12, fileName, _options, _key, dereferencedPaths) => {
-    if (!(0, utils_1.isSchemaLike)(schema12)) {
+  rules.set("Add an $id to anything that needs it", (schema13, fileName, _options, _key, dereferencedPaths) => {
+    if (!(0, utils_1.isSchemaLike)(schema13)) {
       return;
     }
-    if (!schema12.$id && !schema12[JSONSchema_1.Parent]) {
-      schema12.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(fileName));
+    if (!schema13.$id && !schema13[JSONSchema_1.Parent]) {
+      schema13.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(fileName));
       return;
     }
-    if (!isArrayType(schema12) && !isObjectType(schema12)) {
+    if (!isArrayType(schema13) && !isObjectType(schema13)) {
       return;
     }
-    const dereferencedName = dereferencedPaths.get(schema12);
-    if (!schema12.$id && !schema12.title && dereferencedName) {
-      schema12.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(dereferencedName));
+    const dereferencedName = dereferencedPaths.get(schema13);
+    if (!schema13.$id && !schema13.title && dereferencedName) {
+      schema13.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(dereferencedName));
     }
     if (dereferencedName) {
-      dereferencedPaths.delete(schema12);
+      dereferencedPaths.delete(schema13);
     }
   });
-  rules.set("Escape closing JSDoc comment", (schema12) => {
-    (0, utils_1.escapeBlockComment)(schema12);
+  rules.set("Escape closing JSDoc comment", (schema13) => {
+    (0, utils_1.escapeBlockComment)(schema13);
   });
-  rules.set("Add JSDoc comments for minItems and maxItems", (schema12) => {
-    if (!isArrayType(schema12)) {
+  rules.set("Add JSDoc comments for minItems and maxItems", (schema13) => {
+    if (!isArrayType(schema13)) {
       return;
     }
     const commentsToAppend = [
-      "minItems" in schema12 ? `@minItems ${schema12.minItems}` : "",
-      "maxItems" in schema12 ? `@maxItems ${schema12.maxItems}` : ""
+      "minItems" in schema13 ? `@minItems ${schema13.minItems}` : "",
+      "maxItems" in schema13 ? `@maxItems ${schema13.maxItems}` : ""
     ].filter(Boolean);
     if (commentsToAppend.length) {
-      schema12.description = (0, utils_1.appendToDescription)(schema12.description, ...commentsToAppend);
+      schema13.description = (0, utils_1.appendToDescription)(schema13.description, ...commentsToAppend);
     }
   });
-  rules.set("Optionally remove maxItems and minItems", (schema12, _fileName, options8) => {
-    if (!isArrayType(schema12)) {
+  rules.set("Optionally remove maxItems and minItems", (schema13, _fileName, options8) => {
+    if (!isArrayType(schema13)) {
       return;
     }
-    if ("minItems" in schema12 && options8.ignoreMinAndMaxItems) {
-      delete schema12.minItems;
+    if ("minItems" in schema13 && options8.ignoreMinAndMaxItems) {
+      delete schema13.minItems;
     }
-    if ("maxItems" in schema12 && (options8.ignoreMinAndMaxItems || options8.maxItems === -1)) {
-      delete schema12.maxItems;
+    if ("maxItems" in schema13 && (options8.ignoreMinAndMaxItems || options8.maxItems === -1)) {
+      delete schema13.maxItems;
     }
   });
-  rules.set("Normalize schema.minItems", (schema12, _fileName, options8) => {
+  rules.set("Normalize schema.minItems", (schema13, _fileName, options8) => {
     if (options8.ignoreMinAndMaxItems) {
       return;
     }
-    if (!isArrayType(schema12)) {
+    if (!isArrayType(schema13)) {
       return;
     }
-    const { minItems } = schema12;
-    schema12.minItems = typeof minItems === "number" ? minItems : 0;
+    const { minItems } = schema13;
+    schema13.minItems = typeof minItems === "number" ? minItems : 0;
   });
-  rules.set("Remove maxItems if it is big enough to likely cause OOMs", (schema12, _fileName, options8) => {
+  rules.set("Remove maxItems if it is big enough to likely cause OOMs", (schema13, _fileName, options8) => {
     if (options8.ignoreMinAndMaxItems || options8.maxItems === -1) {
       return;
     }
-    if (!isArrayType(schema12)) {
+    if (!isArrayType(schema13)) {
       return;
     }
-    const { maxItems, minItems } = schema12;
+    const { maxItems, minItems } = schema13;
     if (maxItems !== undefined && maxItems - minItems > options8.maxItems) {
-      delete schema12.maxItems;
+      delete schema13.maxItems;
     }
   });
-  rules.set("Normalize schema.items", (schema12, _fileName, options8) => {
+  rules.set("Normalize schema.items", (schema13, _fileName, options8) => {
     if (options8.ignoreMinAndMaxItems) {
       return;
     }
-    const { maxItems, minItems } = schema12;
+    const { maxItems, minItems } = schema13;
     const hasMaxItems = typeof maxItems === "number" && maxItems >= 0;
     const hasMinItems = typeof minItems === "number" && minItems > 0;
-    if (schema12.items && !Array.isArray(schema12.items) && (hasMaxItems || hasMinItems)) {
-      const items = schema12.items;
+    if (schema13.items && !Array.isArray(schema13.items) && (hasMaxItems || hasMinItems)) {
+      const items = schema13.items;
       const newItems = Array(maxItems || minItems || 0).fill(items);
       if (!hasMaxItems) {
-        schema12.additionalItems = items;
+        schema13.additionalItems = items;
       }
-      schema12.items = newItems;
+      schema13.items = newItems;
     }
-    if (Array.isArray(schema12.items) && hasMaxItems && maxItems < schema12.items.length) {
-      schema12.items = schema12.items.slice(0, maxItems);
+    if (Array.isArray(schema13.items) && hasMaxItems && maxItems < schema13.items.length) {
+      schema13.items = schema13.items.slice(0, maxItems);
     }
-    return schema12;
+    return schema13;
   });
-  rules.set("Remove extends, if it is empty", (schema12) => {
-    if (!schema12.hasOwnProperty("extends")) {
+  rules.set("Remove extends, if it is empty", (schema13) => {
+    if (!schema13.hasOwnProperty("extends")) {
       return;
     }
-    if (schema12.extends == null || Array.isArray(schema12.extends) && schema12.extends.length === 0) {
-      delete schema12.extends;
+    if (schema13.extends == null || Array.isArray(schema13.extends) && schema13.extends.length === 0) {
+      delete schema13.extends;
     }
   });
-  rules.set("Make extends always an array, if it is defined", (schema12) => {
-    if (schema12.extends == null) {
+  rules.set("Make extends always an array, if it is defined", (schema13) => {
+    if (schema13.extends == null) {
       return;
     }
-    if (!Array.isArray(schema12.extends)) {
-      schema12.extends = [schema12.extends];
+    if (!Array.isArray(schema13.extends)) {
+      schema13.extends = [schema13.extends];
     }
   });
-  rules.set("Transform definitions to $defs", (schema12, fileName) => {
-    if (schema12.definitions && schema12.$defs && !(0, util_1.isDeepStrictEqual)(schema12.definitions, schema12.$defs)) {
-      throw ReferenceError(`Schema must define either definitions or $defs, not both. Given id=${schema12.id} in ${fileName}`);
+  rules.set("Transform definitions to $defs", (schema13, fileName) => {
+    if (schema13.definitions && schema13.$defs && !(0, util_1.isDeepStrictEqual)(schema13.definitions, schema13.$defs)) {
+      throw ReferenceError(`Schema must define either definitions or $defs, not both. Given id=${schema13.id} in ${fileName}`);
     }
-    if (schema12.definitions) {
-      schema12.$defs = schema12.definitions;
-      delete schema12.definitions;
+    if (schema13.definitions) {
+      schema13.$defs = schema13.definitions;
+      delete schema13.definitions;
     }
   });
-  rules.set("Transform const to singleton enum", (schema12) => {
-    if (schema12.const !== undefined) {
-      schema12.enum = [schema12.const];
-      delete schema12.const;
+  rules.set("Transform const to singleton enum", (schema13) => {
+    if (schema13.const !== undefined) {
+      schema13.enum = [schema13.const];
+      delete schema13.const;
     }
   });
-  rules.set("Add tsEnumNames to enum types", (schema12, _10, options8) => {
+  rules.set("Add tsEnumNames to enum types", (schema13, _10, options8) => {
     var _a7;
-    if (isEnumTypeWithoutTsEnumNames(schema12) && options8.inferStringEnumKeysFromValues) {
-      schema12.tsEnumNames = (_a7 = schema12.enum) === null || _a7 === undefined ? undefined : _a7.map(String);
+    if (isEnumTypeWithoutTsEnumNames(schema13) && options8.inferStringEnumKeysFromValues) {
+      schema13.tsEnumNames = (_a7 = schema13.enum) === null || _a7 === undefined ? undefined : _a7.map(String);
     }
   });
-  rules.set("Pre-calculate schema types and intersections", (schema12) => {
-    if (schema12 !== null && typeof schema12 === "object") {
-      (0, applySchemaTyping_1.applySchemaTyping)(schema12);
+  rules.set("Pre-calculate schema types and intersections", (schema13) => {
+    if (schema13 !== null && typeof schema13 === "object") {
+      (0, applySchemaTyping_1.applySchemaTyping)(schema13);
     }
   });
   function normalize2(rootSchema, dereferencedPaths, filename, options8) {
-    rules.forEach((rule) => (0, utils_1.traverse)(rootSchema, (schema12, key2) => rule(schema12, filename, options8, key2, dereferencedPaths)));
+    rules.forEach((rule) => (0, utils_1.traverse)(rootSchema, (schema13, key2) => rule(schema13, filename, options8, key2, dereferencedPaths)));
     return rootSchema;
   }
   exports.normalize = normalize2;
@@ -142190,37 +142190,37 @@ var require_parser2 = __commonJS((exports) => {
   var AST_1 = require_AST();
   var JSONSchema_1 = require_JSONSchema();
   var utils_1 = require_utils7();
-  function parse11(schema12, options8, keyName, processed = new Map, usedNames = new Set) {
-    if ((0, JSONSchema_1.isPrimitive)(schema12)) {
-      if ((0, JSONSchema_1.isBoolean)(schema12)) {
-        return parseBooleanSchema(schema12, keyName, options8);
+  function parse11(schema13, options8, keyName, processed = new Map, usedNames = new Set) {
+    if ((0, JSONSchema_1.isPrimitive)(schema13)) {
+      if ((0, JSONSchema_1.isBoolean)(schema13)) {
+        return parseBooleanSchema(schema13, keyName, options8);
       }
-      return parseLiteral(schema12, keyName);
+      return parseLiteral(schema13, keyName);
     }
-    const intersection2 = schema12[JSONSchema_1.Intersection];
-    const types = schema12[JSONSchema_1.Types];
+    const intersection2 = schema13[JSONSchema_1.Intersection];
+    const types = schema13[JSONSchema_1.Types];
     if (intersection2) {
       const ast = parseAsTypeWithCache(intersection2, "ALL_OF", options8, keyName, processed, usedNames);
       types.forEach((type) => {
-        ast.params.push(parseAsTypeWithCache(schema12, type, options8, keyName, processed, usedNames));
+        ast.params.push(parseAsTypeWithCache(schema13, type, options8, keyName, processed, usedNames));
       });
-      (0, utils_1.log)("blue", "parser", "Types:", [...types], "Input:", schema12, "Output:", ast);
+      (0, utils_1.log)("blue", "parser", "Types:", [...types], "Input:", schema13, "Output:", ast);
       return ast;
     }
     if (types.size === 1) {
       const type = [...types][0];
-      const ast = parseAsTypeWithCache(schema12, type, options8, keyName, processed, usedNames);
-      (0, utils_1.log)("blue", "parser", "Type:", type, "Input:", schema12, "Output:", ast);
+      const ast = parseAsTypeWithCache(schema13, type, options8, keyName, processed, usedNames);
+      (0, utils_1.log)("blue", "parser", "Type:", type, "Input:", schema13, "Output:", ast);
       return ast;
     }
     throw new ReferenceError("Expected intersection schema. Please file an issue on GitHub.");
   }
   exports.parse = parse11;
-  function parseAsTypeWithCache(schema12, type, options8, keyName, processed = new Map, usedNames = new Set) {
-    let cachedTypeMap = processed.get(schema12);
+  function parseAsTypeWithCache(schema13, type, options8, keyName, processed = new Map, usedNames = new Set) {
+    let cachedTypeMap = processed.get(schema13);
     if (!cachedTypeMap) {
       cachedTypeMap = new Map;
-      processed.set(schema12, cachedTypeMap);
+      processed.set(schema13, cachedTypeMap);
     }
     const cachedAST = cachedTypeMap.get(type);
     if (cachedAST) {
@@ -142228,10 +142228,10 @@ var require_parser2 = __commonJS((exports) => {
     }
     const ast = {};
     cachedTypeMap.set(type, ast);
-    return Object.assign(ast, parseNonLiteral(schema12, type, options8, keyName, processed, usedNames));
+    return Object.assign(ast, parseNonLiteral(schema13, type, options8, keyName, processed, usedNames));
   }
-  function parseBooleanSchema(schema12, keyName, options8) {
-    if (schema12) {
+  function parseBooleanSchema(schema13, keyName, options8) {
+    if (schema13) {
       return {
         keyName,
         type: options8.unknownAny ? "UNKNOWN" : "ANY"
@@ -142242,157 +142242,157 @@ var require_parser2 = __commonJS((exports) => {
       type: "NEVER"
     };
   }
-  function parseLiteral(schema12, keyName) {
+  function parseLiteral(schema13, keyName) {
     return {
       keyName,
-      params: schema12,
+      params: schema13,
       type: "LITERAL"
     };
   }
-  function parseNonLiteral(schema12, type, options8, keyName, processed, usedNames) {
-    const definitions = getDefinitionsMemoized((0, JSONSchema_1.getRootSchema)(schema12));
-    const keyNameFromDefinition = (0, lodash_1.findKey)(definitions, (_10) => _10 === schema12);
+  function parseNonLiteral(schema13, type, options8, keyName, processed, usedNames) {
+    const definitions = getDefinitionsMemoized((0, JSONSchema_1.getRootSchema)(schema13));
+    const keyNameFromDefinition = (0, lodash_1.findKey)(definitions, (_10) => _10 === schema13);
     switch (type) {
       case "ALL_OF":
         return {
-          comment: schema12.description,
-          deprecated: schema12.deprecated,
+          comment: schema13.description,
+          deprecated: schema13.deprecated,
           keyName,
-          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
-          params: schema12.allOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
+          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
+          params: schema13.allOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
           type: "INTERSECTION"
         };
       case "ANY":
-        return Object.assign(Object.assign({}, options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY), { comment: schema12.description, deprecated: schema12.deprecated, keyName, standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8) });
+        return Object.assign(Object.assign({}, options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY), { comment: schema13.description, deprecated: schema13.deprecated, keyName, standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8) });
       case "ANY_OF":
         return {
-          comment: schema12.description,
-          deprecated: schema12.deprecated,
+          comment: schema13.description,
+          deprecated: schema13.deprecated,
           keyName,
-          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
-          params: schema12.anyOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
+          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
+          params: schema13.anyOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
           type: "UNION"
         };
       case "BOOLEAN":
         return {
-          comment: schema12.description,
-          deprecated: schema12.deprecated,
+          comment: schema13.description,
+          deprecated: schema13.deprecated,
           keyName,
-          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
           type: "BOOLEAN"
         };
       case "CUSTOM_TYPE":
         return {
-          comment: schema12.description,
-          deprecated: schema12.deprecated,
+          comment: schema13.description,
+          deprecated: schema13.deprecated,
           keyName,
-          params: schema12.tsType,
-          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
+          params: schema13.tsType,
+          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
           type: "CUSTOM_TYPE"
         };
       case "NAMED_ENUM":
         return {
-          comment: schema12.description,
-          deprecated: schema12.deprecated,
+          comment: schema13.description,
+          deprecated: schema13.deprecated,
           keyName,
-          standaloneName: standaloneName(schema12, keyNameFromDefinition !== null && keyNameFromDefinition !== undefined ? keyNameFromDefinition : keyName, usedNames, options8),
-          params: schema12.enum.map((_10, n5) => ({
+          standaloneName: standaloneName(schema13, keyNameFromDefinition !== null && keyNameFromDefinition !== undefined ? keyNameFromDefinition : keyName, usedNames, options8),
+          params: schema13.enum.map((_10, n5) => ({
             ast: parseLiteral(_10, undefined),
-            keyName: schema12.tsEnumNames[n5]
+            keyName: schema13.tsEnumNames[n5]
           })),
           type: "ENUM"
         };
       case "NAMED_SCHEMA":
-        return newInterface(schema12, options8, processed, usedNames, keyName);
+        return newInterface(schema13, options8, processed, usedNames, keyName);
       case "NEVER":
         return {
-          comment: schema12.description,
-          deprecated: schema12.deprecated,
+          comment: schema13.description,
+          deprecated: schema13.deprecated,
           keyName,
-          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
           type: "NEVER"
         };
       case "NULL":
         return {
-          comment: schema12.description,
-          deprecated: schema12.deprecated,
+          comment: schema13.description,
+          deprecated: schema13.deprecated,
           keyName,
-          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
           type: "NULL"
         };
       case "NUMBER":
         return {
-          comment: schema12.description,
-          deprecated: schema12.deprecated,
+          comment: schema13.description,
+          deprecated: schema13.deprecated,
           keyName,
-          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
           type: "NUMBER"
         };
       case "OBJECT":
         return {
-          comment: schema12.description,
+          comment: schema13.description,
           keyName,
-          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
           type: "OBJECT",
-          deprecated: schema12.deprecated
+          deprecated: schema13.deprecated
         };
       case "ONE_OF":
         return {
-          comment: schema12.description,
-          deprecated: schema12.deprecated,
+          comment: schema13.description,
+          deprecated: schema13.deprecated,
           keyName,
-          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
-          params: schema12.oneOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
+          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
+          params: schema13.oneOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
           type: "UNION"
         };
       case "REFERENCE":
-        throw Error((0, util_1.format)("Refs should have been resolved by the resolver!", schema12));
+        throw Error((0, util_1.format)("Refs should have been resolved by the resolver!", schema13));
       case "STRING":
         return {
-          comment: schema12.description,
-          deprecated: schema12.deprecated,
+          comment: schema13.description,
+          deprecated: schema13.deprecated,
           keyName,
-          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
           type: "STRING"
         };
       case "TYPED_ARRAY":
-        if (Array.isArray(schema12.items)) {
-          const minItems2 = schema12.minItems;
-          const maxItems2 = schema12.maxItems;
+        if (Array.isArray(schema13.items)) {
+          const minItems2 = schema13.minItems;
+          const maxItems2 = schema13.maxItems;
           const arrayType = {
-            comment: schema12.description,
-            deprecated: schema12.deprecated,
+            comment: schema13.description,
+            deprecated: schema13.deprecated,
             keyName,
             maxItems: maxItems2,
             minItems: minItems2,
-            standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
-            params: schema12.items.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
+            standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
+            params: schema13.items.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
             type: "TUPLE"
           };
-          if (schema12.additionalItems === true) {
+          if (schema13.additionalItems === true) {
             arrayType.spreadParam = options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY;
-          } else if (schema12.additionalItems) {
-            arrayType.spreadParam = parse11(schema12.additionalItems, options8, undefined, processed, usedNames);
+          } else if (schema13.additionalItems) {
+            arrayType.spreadParam = parse11(schema13.additionalItems, options8, undefined, processed, usedNames);
           }
           return arrayType;
         } else {
           return {
-            comment: schema12.description,
-            deprecated: schema12.deprecated,
+            comment: schema13.description,
+            deprecated: schema13.deprecated,
             keyName,
-            standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
-            params: parse11(schema12.items, options8, `{keyNameFromDefinition}Items`, processed, usedNames),
+            standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
+            params: parse11(schema13.items, options8, `{keyNameFromDefinition}Items`, processed, usedNames),
             type: "ARRAY"
           };
         }
       case "UNION":
         return {
-          comment: schema12.description,
-          deprecated: schema12.deprecated,
+          comment: schema13.description,
+          deprecated: schema13.deprecated,
           keyName,
-          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
-          params: schema12.type.map((type2) => {
-            const member = Object.assign(Object.assign({}, (0, lodash_1.omit)(schema12, "$id", "description", "title")), { type: type2 });
+          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
+          params: schema13.type.map((type2) => {
+            const member = Object.assign(Object.assign({}, (0, lodash_1.omit)(schema13, "$id", "description", "title")), { type: type2 });
             (0, utils_1.maybeStripDefault)(member);
             (0, applySchemaTyping_1.applySchemaTyping)(member);
             return parse11(member, options8, undefined, processed, usedNames);
@@ -142401,80 +142401,80 @@ var require_parser2 = __commonJS((exports) => {
         };
       case "UNNAMED_ENUM":
         return {
-          comment: schema12.description,
-          deprecated: schema12.deprecated,
+          comment: schema13.description,
+          deprecated: schema13.deprecated,
           keyName,
-          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
-          params: schema12.enum.map((_10) => parseLiteral(_10, undefined)),
+          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
+          params: schema13.enum.map((_10) => parseLiteral(_10, undefined)),
           type: "UNION"
         };
       case "UNNAMED_SCHEMA":
-        return newInterface(schema12, options8, processed, usedNames, keyName, keyNameFromDefinition);
+        return newInterface(schema13, options8, processed, usedNames, keyName, keyNameFromDefinition);
       case "UNTYPED_ARRAY":
-        const minItems = schema12.minItems;
-        const maxItems = typeof schema12.maxItems === "number" ? schema12.maxItems : -1;
+        const minItems = schema13.minItems;
+        const maxItems = typeof schema13.maxItems === "number" ? schema13.maxItems : -1;
         const params = options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY;
         if (minItems > 0 || maxItems >= 0) {
           return {
-            comment: schema12.description,
-            deprecated: schema12.deprecated,
+            comment: schema13.description,
+            deprecated: schema13.deprecated,
             keyName,
-            maxItems: schema12.maxItems,
+            maxItems: schema13.maxItems,
             minItems,
             params: Array(Math.max(maxItems, minItems) || 0).fill(params),
             spreadParam: maxItems >= 0 ? undefined : params,
-            standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
+            standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
             type: "TUPLE"
           };
         }
         return {
-          comment: schema12.description,
-          deprecated: schema12.deprecated,
+          comment: schema13.description,
+          deprecated: schema13.deprecated,
           keyName,
           params,
-          standaloneName: standaloneName(schema12, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
           type: "ARRAY"
         };
     }
   }
-  function standaloneName(schema12, keyNameFromDefinition, usedNames, options8) {
+  function standaloneName(schema13, keyNameFromDefinition, usedNames, options8) {
     var _a7;
-    const name2 = ((_a7 = options8.customName) === null || _a7 === undefined ? undefined : _a7.call(options8, schema12, keyNameFromDefinition)) || schema12.title || schema12.$id || keyNameFromDefinition;
+    const name2 = ((_a7 = options8.customName) === null || _a7 === undefined ? undefined : _a7.call(options8, schema13, keyNameFromDefinition)) || schema13.title || schema13.$id || keyNameFromDefinition;
     if (name2) {
       return (0, utils_1.generateName)(name2, usedNames);
     }
   }
-  function newInterface(schema12, options8, processed, usedNames, keyName, keyNameFromDefinition) {
-    const name2 = standaloneName(schema12, keyNameFromDefinition, usedNames, options8);
+  function newInterface(schema13, options8, processed, usedNames, keyName, keyNameFromDefinition) {
+    const name2 = standaloneName(schema13, keyNameFromDefinition, usedNames, options8);
     return {
-      comment: schema12.description,
-      deprecated: schema12.deprecated,
+      comment: schema13.description,
+      deprecated: schema13.deprecated,
       keyName,
-      params: parseSchema(schema12, options8, processed, usedNames, name2),
+      params: parseSchema(schema13, options8, processed, usedNames, name2),
       standaloneName: name2,
-      superTypes: parseSuperTypes(schema12, options8, processed, usedNames),
+      superTypes: parseSuperTypes(schema13, options8, processed, usedNames),
       type: "INTERFACE"
     };
   }
-  function parseSuperTypes(schema12, options8, processed, usedNames) {
-    const superTypes = schema12.extends;
+  function parseSuperTypes(schema13, options8, processed, usedNames) {
+    const superTypes = schema13.extends;
     if (!superTypes) {
       return [];
     }
     return superTypes.map((_10) => parse11(_10, options8, undefined, processed, usedNames));
   }
-  function parseSchema(schema12, options8, processed, usedNames, parentSchemaName) {
-    let asts = (0, lodash_1.map)(schema12.properties, (value, key2) => ({
+  function parseSchema(schema13, options8, processed, usedNames, parentSchemaName) {
+    let asts = (0, lodash_1.map)(schema13.properties, (value, key2) => ({
       ast: parse11(value, options8, key2, processed, usedNames),
       isPatternProperty: false,
-      isRequired: (0, lodash_1.includes)(schema12.required || [], key2),
+      isRequired: (0, lodash_1.includes)(schema13.required || [], key2),
       isUnreachableDefinition: false,
       keyName: key2
     }));
     let singlePatternProperty = false;
-    if (schema12.patternProperties) {
-      singlePatternProperty = !schema12.additionalProperties && Object.keys(schema12.patternProperties).length === 1;
-      asts = asts.concat((0, lodash_1.map)(schema12.patternProperties, (value, key2) => {
+    if (schema13.patternProperties) {
+      singlePatternProperty = !schema13.additionalProperties && Object.keys(schema13.patternProperties).length === 1;
+      asts = asts.concat((0, lodash_1.map)(schema13.patternProperties, (value, key2) => {
         const ast = parse11(value, options8, key2, processed, usedNames);
         const comment = `This interface was referenced by \`${parentSchemaName}\`'s JSON-Schema definition
 via the \`patternProperty\` "${key2.replace("*/", "*\\/")}".`;
@@ -142484,14 +142484,14 @@ ${comment}` : comment;
         return {
           ast,
           isPatternProperty: !singlePatternProperty,
-          isRequired: singlePatternProperty || (0, lodash_1.includes)(schema12.required || [], key2),
+          isRequired: singlePatternProperty || (0, lodash_1.includes)(schema13.required || [], key2),
           isUnreachableDefinition: false,
           keyName: singlePatternProperty ? "[k: string]" : key2
         };
       }));
     }
     if (options8.unreachableDefinitions) {
-      asts = asts.concat((0, lodash_1.map)(schema12.$defs, (value, key2) => {
+      asts = asts.concat((0, lodash_1.map)(schema13.$defs, (value, key2) => {
         const ast = parse11(value, options8, key2, processed, usedNames);
         const comment = `This interface was referenced by \`${parentSchemaName}\`'s JSON-Schema
 via the \`definition\` "${key2}".`;
@@ -142501,13 +142501,13 @@ ${comment}` : comment;
         return {
           ast,
           isPatternProperty: false,
-          isRequired: (0, lodash_1.includes)(schema12.required || [], key2),
+          isRequired: (0, lodash_1.includes)(schema13.required || [], key2),
           isUnreachableDefinition: true,
           keyName: key2
         };
       }));
     }
-    switch (schema12.additionalProperties) {
+    switch (schema13.additionalProperties) {
       case undefined:
       case true:
         if (singlePatternProperty) {
@@ -142524,7 +142524,7 @@ ${comment}` : comment;
         return asts;
       default:
         return asts.concat({
-          ast: parse11(schema12.additionalProperties, options8, "[k: string]", processed, usedNames),
+          ast: parse11(schema13.additionalProperties, options8, "[k: string]", processed, usedNames),
           isPatternProperty: false,
           isRequired: true,
           isUnreachableDefinition: false,
@@ -142532,22 +142532,22 @@ ${comment}` : comment;
         });
     }
   }
-  function getDefinitions(schema12, isSchema = true, processed = new Set) {
-    if (processed.has(schema12)) {
+  function getDefinitions(schema13, isSchema = true, processed = new Set) {
+    if (processed.has(schema13)) {
       return {};
     }
-    processed.add(schema12);
-    if (Array.isArray(schema12)) {
-      return schema12.reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(cur, false, processed)), {});
+    processed.add(schema13);
+    if (Array.isArray(schema13)) {
+      return schema13.reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(cur, false, processed)), {});
     }
-    if ((0, lodash_1.isPlainObject)(schema12)) {
-      return Object.assign(Object.assign({}, isSchema && hasDefinitions(schema12) ? schema12.$defs : {}), Object.keys(schema12).reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(schema12[cur], false, processed)), {}));
+    if ((0, lodash_1.isPlainObject)(schema13)) {
+      return Object.assign(Object.assign({}, isSchema && hasDefinitions(schema13) ? schema13.$defs : {}), Object.keys(schema13).reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(schema13[cur], false, processed)), {}));
     }
     return {};
   }
   var getDefinitionsMemoized = (0, lodash_1.memoize)(getDefinitions);
-  function hasDefinitions(schema12) {
-    return "$defs" in schema12;
+  function hasDefinitions(schema13) {
+    return "$defs" in schema13;
   }
 });
 
@@ -142972,7 +142972,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;
@@ -143122,7 +143122,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 resolve13(from, to5);
     }
@@ -144371,7 +144371,7 @@ var require_normalize_args = __commonJS((exports) => {
   var options_js_1 = require_options();
   function normalizeArgs(_args) {
     let path18;
-    let schema12;
+    let schema13;
     let options8;
     let callback;
     const args = Array.prototype.slice.call(_args);
@@ -144381,15 +144381,15 @@ var require_normalize_args = __commonJS((exports) => {
     if (typeof args[0] === "string") {
       path18 = args[0];
       if (typeof args[2] === "object") {
-        schema12 = args[1];
+        schema13 = args[1];
         options8 = args[2];
       } else {
-        schema12 = undefined;
+        schema13 = undefined;
         options8 = args[1];
       }
     } else {
       path18 = "";
-      schema12 = args[0];
+      schema13 = args[0];
       options8 = args[1];
     }
     try {
@@ -144397,12 +144397,12 @@ var require_normalize_args = __commonJS((exports) => {
     } catch (e8) {
       console.error(`JSON Schema Ref Parser: Error normalizing options: ${e8}`);
     }
-    if (!options8.mutateInputSchema && typeof schema12 === "object") {
-      schema12 = JSON.parse(JSON.stringify(schema12));
+    if (!options8.mutateInputSchema && typeof schema13 === "object") {
+      schema13 = JSON.parse(JSON.stringify(schema13));
     }
     return {
       path: path18,
-      schema: schema12,
+      schema: schema13,
       options: options8,
       callback
     };
@@ -145191,12 +145191,12 @@ var require_resolver = __commonJS((exports) => {
   var json_schema_ref_parser_1 = require_lib3();
   var utils_1 = require_utils7();
   function dereference(schema_1, _a7) {
-    return __awaiter(this, arguments, undefined, function* (schema12, { cwd, $refOptions }) {
-      (0, utils_1.log)("green", "dereferencer", "Dereferencing input schema:", cwd, schema12);
+    return __awaiter(this, arguments, undefined, function* (schema13, { cwd, $refOptions }) {
+      (0, utils_1.log)("green", "dereferencer", "Dereferencing input schema:", cwd, schema13);
       const parser2 = new json_schema_ref_parser_1.$RefParser;
       const dereferencedPaths = new WeakMap;
-      const dereferencedSchema = yield parser2.dereference(cwd, schema12, Object.assign(Object.assign({}, $refOptions), { dereference: Object.assign(Object.assign({}, $refOptions.dereference), { onDereference($ref, schema13) {
-        dereferencedPaths.set(schema13, $ref);
+      const dereferencedSchema = yield parser2.dereference(cwd, schema13, Object.assign(Object.assign({}, $refOptions), { dereference: Object.assign(Object.assign({}, $refOptions.dereference), { onDereference($ref, schema14) {
+        dereferencedPaths.set(schema14, $ref);
       } }) }));
       return { dereferencedPaths, dereferencedSchema };
     });
@@ -145210,46 +145210,46 @@ var require_validator = __commonJS((exports) => {
   exports.validate = undefined;
   var utils_1 = require_utils7();
   var rules = new Map;
-  rules.set("Enum members and tsEnumNames must be of the same length", (schema12) => {
-    if (schema12.enum && schema12.tsEnumNames && schema12.enum.length !== schema12.tsEnumNames.length) {
+  rules.set("Enum members and tsEnumNames must be of the same length", (schema13) => {
+    if (schema13.enum && schema13.tsEnumNames && schema13.enum.length !== schema13.tsEnumNames.length) {
       return false;
     }
   });
-  rules.set("tsEnumNames must be an array of strings", (schema12) => {
-    if (schema12.tsEnumNames && schema12.tsEnumNames.some((_10) => typeof _10 !== "string")) {
+  rules.set("tsEnumNames must be an array of strings", (schema13) => {
+    if (schema13.tsEnumNames && schema13.tsEnumNames.some((_10) => typeof _10 !== "string")) {
       return false;
     }
   });
-  rules.set("When both maxItems and minItems are present, maxItems >= minItems", (schema12) => {
-    const { maxItems, minItems } = schema12;
+  rules.set("When both maxItems and minItems are present, maxItems >= minItems", (schema13) => {
+    const { maxItems, minItems } = schema13;
     if (typeof maxItems === "number" && typeof minItems === "number") {
       return maxItems >= minItems;
     }
   });
-  rules.set("When maxItems exists, maxItems >= 0", (schema12) => {
-    const { maxItems } = schema12;
+  rules.set("When maxItems exists, maxItems >= 0", (schema13) => {
+    const { maxItems } = schema13;
     if (typeof maxItems === "number") {
       return maxItems >= 0;
     }
   });
-  rules.set("When minItems exists, minItems >= 0", (schema12) => {
-    const { minItems } = schema12;
+  rules.set("When minItems exists, minItems >= 0", (schema13) => {
+    const { minItems } = schema13;
     if (typeof minItems === "number") {
       return minItems >= 0;
     }
   });
-  rules.set("deprecated must be a boolean", (schema12) => {
-    const typeOfDeprecated = typeof schema12.deprecated;
+  rules.set("deprecated must be a boolean", (schema13) => {
+    const typeOfDeprecated = typeof schema13.deprecated;
     return typeOfDeprecated === "boolean" || typeOfDeprecated === "undefined";
   });
-  function validate2(schema12, filename) {
+  function validate2(schema13, filename) {
     const errors5 = [];
     rules.forEach((rule, ruleName) => {
-      (0, utils_1.traverse)(schema12, (schema13, key2) => {
-        if (rule(schema13) === false) {
+      (0, utils_1.traverse)(schema13, (schema14, key2) => {
+        if (rule(schema14) === false) {
           errors5.push(`Error at key "${key2}" in file "${filename}": ${ruleName}`);
         }
-        return schema13;
+        return schema14;
       });
     });
     return errors5;
@@ -145263,25 +145263,25 @@ var require_linker = __commonJS((exports) => {
   exports.link = undefined;
   var JSONSchema_1 = require_JSONSchema();
   var lodash_1 = require_lodash8();
-  function link2(schema12, parent = null) {
-    if (!Array.isArray(schema12) && !(0, lodash_1.isPlainObject)(schema12)) {
-      return schema12;
+  function link2(schema13, parent = null) {
+    if (!Array.isArray(schema13) && !(0, lodash_1.isPlainObject)(schema13)) {
+      return schema13;
     }
-    if (schema12.hasOwnProperty(JSONSchema_1.Parent)) {
-      return schema12;
+    if (schema13.hasOwnProperty(JSONSchema_1.Parent)) {
+      return schema13;
     }
-    Object.defineProperty(schema12, JSONSchema_1.Parent, {
+    Object.defineProperty(schema13, JSONSchema_1.Parent, {
       enumerable: false,
       value: parent,
       writable: false
     });
-    if (Array.isArray(schema12)) {
-      schema12.forEach((child) => link2(child, schema12));
+    if (Array.isArray(schema13)) {
+      schema13.forEach((child) => link2(child, schema13));
     }
-    for (const key2 in schema12) {
-      link2(schema12[key2], schema12);
+    for (const key2 in schema13) {
+      link2(schema13[key2], schema13);
     }
-    return schema12;
+    return schema13;
   }
   exports.link = link2;
 });
@@ -145373,8 +145373,8 @@ var require_src3 = __commonJS((exports) => {
     unknownAny: true
   };
   function compileFromFile(filename, options8 = exports.DEFAULT_OPTIONS) {
-    const schema12 = parseAsJSONSchema(filename);
-    return compile(schema12, (0, utils_1.stripExtension)(filename), Object.assign({ cwd: (0, path_1.dirname)(filename) }, options8));
+    const schema13 = parseAsJSONSchema(filename);
+    return compile(schema13, (0, utils_1.stripExtension)(filename), Object.assign({ cwd: (0, path_1.dirname)(filename) }, options8));
   }
   exports.compileFromFile = compileFromFile;
   function parseAsJSONSchema(filename) {
@@ -145384,7 +145384,7 @@ var require_src3 = __commonJS((exports) => {
     return (0, utils_1.parseFileAsJSONSchema)(filename, contents.toString());
   }
   function compile(schema_1, name_1) {
-    return __awaiter(this, arguments, undefined, function* (schema12, name2, options8 = {}) {
+    return __awaiter(this, arguments, undefined, function* (schema13, name2, options8 = {}) {
       (0, optionValidator_1.validateOptions)(options8);
       const _options = (0, lodash_1.merge)({}, exports.DEFAULT_OPTIONS, options8);
       const start = Date.now();
@@ -145394,7 +145394,7 @@ var require_src3 = __commonJS((exports) => {
       if (!(0, lodash_1.endsWith)(_options.cwd, "/")) {
         _options.cwd += "/";
       }
-      const _schema = (0, lodash_1.cloneDeep)(schema12);
+      const _schema = (0, lodash_1.cloneDeep)(schema13);
       const { dereferencedPaths, dereferencedSchema } = yield (0, resolver_1.dereference)(_schema, _options);
       if (process.env.VERBOSE) {
         if ((0, util_1.isDeepStrictEqual)(_schema, dereferencedSchema)) {
@@ -146451,7 +146451,7 @@ var require_depd = __commonJS((exports, module) => {
    * Copyright(c) 2014-2018 Douglas Christopher Wilson
    * MIT Licensed
    */
-  var relative4 = __require("path").relative;
+  var relative6 = __require("path").relative;
   module.exports = depd;
   var basePath = process.cwd();
   function containsNamespace(str, namespace) {
@@ -146647,7 +146647,7 @@ var require_depd = __commonJS((exports, module) => {
     return formatted;
   }
   function formatLocation(callSite) {
-    return relative4(basePath, callSite[0]) + ":" + callSite[1] + ":" + callSite[2];
+    return relative6(basePath, callSite[0]) + ":" + callSite[1] + ":" + callSite[2];
   }
   function getStack() {
     var limit = Error.stackTraceLimit;
@@ -164109,8 +164109,8 @@ var require_view = __commonJS((exports, module) => {
   var debug = require_src4()("express:view");
   var path18 = __require("node:path");
   var fs28 = __require("node:fs");
-  var dirname20 = path18.dirname;
-  var basename7 = path18.basename;
+  var dirname22 = path18.dirname;
+  var basename8 = path18.basename;
   var extname2 = path18.extname;
   var join29 = path18.join;
   var resolve13 = path18.resolve;
@@ -164148,8 +164148,8 @@ var require_view = __commonJS((exports, module) => {
     for (var i5 = 0;i5 < roots.length && !path19; i5++) {
       var root2 = roots[i5];
       var loc = resolve13(root2, name2);
-      var dir = dirname20(loc);
-      var file2 = basename7(loc);
+      var dir = dirname22(loc);
+      var file2 = basename8(loc);
       path19 = this.resolve(dir, file2);
     }
     return path19;
@@ -164179,7 +164179,7 @@ var require_view = __commonJS((exports, module) => {
     if (stat3 && stat3.isFile()) {
       return path19;
     }
-    path19 = join29(dir, basename7(file2, ext), "index" + ext);
+    path19 = join29(dir, basename8(file2, ext), "index" + ext);
     stat3 = tryStat(path19);
     if (stat3 && stat3.isFile()) {
       return path19;
@@ -167500,7 +167500,7 @@ var require_content_disposition = __commonJS((exports, module) => {
    */
   module.exports = contentDisposition;
   module.exports.parse = parse11;
-  var basename7 = __require("path").basename;
+  var basename8 = __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;
@@ -167535,9 +167535,9 @@ var require_content_disposition = __commonJS((exports, module) => {
     if (typeof fallback === "string" && NON_LATIN1_REGEXP.test(fallback)) {
       throw new TypeError("fallback must be ISO-8859-1 string");
     }
-    var name2 = basename7(filename);
+    var name2 = basename8(filename);
     var isQuotedString = TEXT_REGEXP.test(name2);
-    var fallbackName = typeof fallback !== "string" ? fallback && getlatin1(name2) : basename7(fallback);
+    var fallbackName = typeof fallback !== "string" ? fallback && getlatin1(name2) : basename8(fallback);
     var hasFallback = typeof fallbackName === "string" && fallbackName !== name2;
     if (hasFallback || !isQuotedString || HEX_ESCAPE_REGEXP.test(name2)) {
       params["filename*"] = name2;
@@ -169284,18 +169284,18 @@ var require_common7 = __commonJS((exports) => {
     retSegs.push.apply(retSegs, lastSegs);
     return retSegs.join("?");
   };
-  common2.rewriteCookieProperty = function rewriteCookieProperty(header2, config13, property) {
+  common2.rewriteCookieProperty = function rewriteCookieProperty(header2, config14, property) {
     if (Array.isArray(header2)) {
       return header2.map(function(headerElement) {
-        return rewriteCookieProperty(headerElement, config13, property);
+        return rewriteCookieProperty(headerElement, config14, property);
       });
     }
     return header2.replace(new RegExp("(;\\s*" + property + "=)([^;]+)", "i"), function(match, prefix, previousValue) {
       var newValue;
-      if (previousValue in config13) {
-        newValue = config13[previousValue];
-      } else if ("*" in config13) {
-        newValue = config13["*"];
+      if (previousValue in config14) {
+        newValue = config14[previousValue];
+      } else if ("*" in config14) {
+        newValue = config14["*"];
       } else {
         return match;
       }
@@ -169795,8 +169795,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)) {
@@ -170660,9 +170660,9 @@ var require_router2 = __commonJS((exports) => {
   var is_plain_object_1 = require_is_plain_object();
   var debug_1 = require_debug4();
   var debug = debug_1.Debug.extend("router");
-  async function getTarget(req, config13) {
+  async function getTarget(req, config14) {
     let newTarget;
-    const router = config13.router;
+    const router = config14.router;
     if ((0, is_plain_object_1.isPlainObject)(router)) {
       newTarget = getTargetFromProxyTable(req, router);
     } else if (typeof router === "function") {
@@ -171434,8 +171434,8 @@ var require_tmp = __commonJS((exports, module) => {
       const name2 = options8.name;
       if (path18.isAbsolute(name2))
         throw new Error(`name option must not contain an absolute path, found "${name2}".`);
-      const basename7 = path18.basename(name2);
-      if (basename7 === ".." || basename7 === "." || basename7 !== name2)
+      const basename8 = path18.basename(name2);
+      if (basename8 === ".." || basename8 === "." || basename8 !== name2)
         throw new Error(`name option must not contain a path, found "${name2}".`);
     }
     if (!_isUndefined(options8.template) && !options8.template.match(TEMPLATE_PATTERN)) {
@@ -213566,7 +213566,7 @@ var require_utils12 = __commonJS((exports, module) => {
     if (decode4)
       return decode4(data, hint);
   }
-  function basename7(path18) {
+  function basename8(path18) {
     if (typeof path18 !== "string")
       return "";
     for (let i5 = path18.length - 1;i5 >= 0; --i5) {
@@ -214870,7 +214870,7 @@ var require_utils12 = __commonJS((exports, module) => {
     -1
   ];
   module.exports = {
-    basename: basename7,
+    basename: basename8,
     convertToUTF8,
     getDecoder,
     parseContentType,
@@ -215278,7 +215278,7 @@ var require_multipart = __commonJS((exports, module) => {
   var { Readable: Readable6, Writable: Writable4 } = __require("stream");
   var StreamSearch = require_sbmh();
   var {
-    basename: basename7,
+    basename: basename8,
     convertToUTF8,
     getDecoder,
     parseContentType,
@@ -215540,7 +215540,7 @@ var require_multipart = __commonJS((exports, module) => {
           else if (disp.params.filename)
             filename = disp.params.filename;
           if (filename !== undefined && !preservePath)
-            filename = basename7(filename);
+            filename = basename8(filename);
         }
         if (header2["content-type"]) {
           const conType = parseContentType(header2["content-type"][0]);
@@ -237657,6 +237657,21 @@ class ApiError extends SystemError {
   }
 }
 
+class ResourceDeployError extends SystemError {
+  code = "RESOURCE_DEPLOY_FAILED";
+  failures;
+  constructor(resource, failures) {
+    const label = failures.length === 1 ? resource : `${resource}s`;
+    const hints = failures.flatMap((failure) => failure.cause instanceof CLIError ? failure.cause.hints : []);
+    super(`Failed to deploy ${failures.length} ${label}`, {
+      details: failures.map((failure) => `${failure.name}: ${failure.message}`),
+      hints: hints.filter((hint, index, all) => all.findIndex((candidate) => candidate.message === hint.message && candidate.command === hint.command) === index),
+      cause: failures.find((failure) => failure.cause)?.cause
+    });
+    this.failures = failures;
+  }
+}
+
 class FileNotFoundError extends SystemError {
   code = "FILE_NOT_FOUND";
   constructor(message, options) {
@@ -237840,7 +237855,7 @@ function normalizeBase44Env() {
 loadProjectEnvFiles();
 
 // src/cli/index.ts
-import { dirname as dirname25, join as join36 } from "node:path";
+import { dirname as dirname27, join as join36 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 
 // ../../node_modules/@clack/core/dist/index.mjs
@@ -239046,9 +239061,6 @@ var {
   Option,
   Help
 } = import__.default;
-
-// src/cli/commands/agent-skills/pull.ts
-import { dirname as dirname10, join as join17 } from "node:path";
 // ../../node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
 var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
@@ -239862,6 +239874,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"),
   agentSkillsDir: exports_external.string().optional().default("agent-skills"),
   connectorsDir: exports_external.string().optional().default("connectors"),
@@ -245801,7 +245814,7 @@ async function getSiteUrl() {
   return result.data.url;
 }
 // src/core/project/config.ts
-import { dirname as dirname8, join as join11 } from "node:path";
+import { dirname as dirname10, join as join11 } from "node:path";
 
 // src/core/project/plugins.ts
 import { createRequire as createRequire2 } from "node:module";
@@ -245839,6 +245852,198 @@ 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")
+  })
+]);
+function throwIfDeployFailed(results, resource) {
+  const failures = results.filter((result) => result.status === "error").map((result) => ({
+    name: result.name,
+    message: result.error ?? "Unknown deployment error",
+    cause: result.cause
+  }));
+  if (failures.length > 0) {
+    throw new ResourceDeployError(resource, failures);
+  }
+}
+
+// src/core/resources/actor/schema.ts
+var ActorSchema = exports_external.object({
+  name: exports_external.string().min(1),
+  entry: exports_external.string().min(1),
+  entryPath: exports_external.string().min(1),
+  filePaths: exports_external.array(exports_external.string()).min(1),
+  source: ResourceSourceSchema
+});
+var DeployActorResponseSchema = exports_external.object({
+  status: exports_external.enum(["deployed", "unchanged"])
+});
+
+// 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;
+}
+async function deleteSingleActor(name2) {
+  const appClient = getAppClient();
+  try {
+    await appClient.delete(`actors/${encodeURIComponent(name2)}`, {
+      timeout: 60000
+    });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, `deleting actor "${name2}"`);
+  }
+}
+// src/core/resources/actor/config.ts
+import { basename as basename3, dirname as dirname6, relative } from "node:path";
+var VALID_ACTOR_NAME = /^[A-Za-z_][A-Za-z0-9_]{0,127}$/;
+var JS_RESERVED_ACTOR_NAMES = new Set(("await break case catch class const continue debugger default delete do else " + "enum export extends false finally for function if import in instanceof let " + "new null return static super switch this throw true try typeof var void " + "while with yield implements interface package private protected public " + "eval arguments").split(" "));
+function assertValidActorName(name2) {
+  if (name2.includes("/")) {
+    throw new ConfigInvalidError(`Invalid actor name "${name2}" — actors cannot be nested in subfolders`, null, {
+      hints: [
+        {
+          message: `Use a single folder level (e.g. actors/${name2.split("/").pop()}/entry.ts)`
+        },
+        {
+          message: "A nested name can also mean a helper file was named entry.ts — every entry file under the actors directory is treated as an actor, so rename the helper"
+        }
+      ]
+    });
+  }
+  if (!VALID_ACTOR_NAME.test(name2)) {
+    throw new ConfigInvalidError(`Invalid actor name "${name2}" — actor names become a JavaScript class binding, so they must match [A-Za-z_][A-Za-z0-9_]* (max 128 characters, no "-", "." or ":")`, null, {
+      hints: [
+        { message: "Rename the folder in PascalCase (e.g. actors/ChatRoom)" }
+      ]
+    });
+  }
+  if (JS_RESERVED_ACTOR_NAMES.has(name2)) {
+    throw new ConfigInvalidError(`Invalid actor name "${name2}" — it is a reserved word in JavaScript, and actor names become a class binding`, null, {
+      hints: [
+        { message: "Rename the folder in PascalCase (e.g. actors/ChatRoom)" }
+      ]
+    });
+  }
+}
+async function readActor(entryFile, actorsDir) {
+  const actorDir = dirname6(entryFile);
+  const name2 = relative(actorsDir, actorDir).split(/[/\\]/).join("/");
+  if (!name2) {
+    const entryName = basename3(entryFile);
+    throw new InvalidInputError(`${entryName} 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)`
+        }
+      ]
+    });
+  }
+  assertValidActorName(name2);
+  const filePaths = await globby(BACKEND_FILE_GLOB, {
+    cwd: actorDir,
+    absolute: true
+  });
+  return {
+    name: name2,
+    entry: basename3(entryFile),
+    entryPath: entryFile,
+    filePaths,
+    source: { type: "project" }
+  };
+}
+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 ConfigInvalidError(`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),
+      cause: error48 instanceof Error ? error48 : undefined
+    };
+  }
+}
+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: async (actors) => {
+    const results = await deployActorsSequentially(actors);
+    throwIfDeployFailed(results, "actor");
+    return results;
+  }
+};
 // src/core/resources/agent/schema.ts
 var EntityOperationSchema = exports_external.enum(["create", "update", "delete", "read"]);
 var EntityToolConfigSchema = exports_external.object({
@@ -246231,8 +246436,8 @@ var AppAuthConfigResponseSchema = exports_external.object({
 }).transform((data) => ({
   authConfig: data.auth_config
 }));
-function hasAnyLoginMethod(config5) {
-  return config5.enableUsernamePassword || config5.enableGoogleLogin || config5.enableMicrosoftLogin || config5.enableFacebookLogin || config5.enableAppleLogin || config5.enableSSOLogin;
+function hasAnyLoginMethod(config6) {
+  return config6.enableUsernamePassword || config6.enableGoogleLogin || config6.enableMicrosoftLogin || config6.enableFacebookLogin || config6.enableAppleLogin || config6.enableSSOLogin;
 }
 var SOCIAL_PROVIDERS = {
   google: {
@@ -246247,18 +246452,18 @@ var SOCIAL_PROVIDERS = {
   facebook: { field: "enableFacebookLogin" },
   apple: { field: "enableAppleLogin" }
 };
-function toAuthConfigPayload(config5) {
+function toAuthConfigPayload(config6) {
   return {
-    enable_username_password: config5.enableUsernamePassword,
-    enable_google_login: config5.enableGoogleLogin,
-    enable_microsoft_login: config5.enableMicrosoftLogin,
-    enable_facebook_login: config5.enableFacebookLogin,
-    enable_apple_login: config5.enableAppleLogin,
-    sso_provider_name: config5.ssoProviderName,
-    enable_sso_login: config5.enableSSOLogin,
-    google_oauth_mode: config5.googleOAuthMode,
-    google_oauth_client_id: config5.googleOAuthClientId,
-    use_workspace_sso: config5.useWorkspaceSSO
+    enable_username_password: config6.enableUsernamePassword,
+    enable_google_login: config6.enableGoogleLogin,
+    enable_microsoft_login: config6.enableMicrosoftLogin,
+    enable_facebook_login: config6.enableFacebookLogin,
+    enable_apple_login: config6.enableAppleLogin,
+    sso_provider_name: config6.ssoProviderName,
+    enable_sso_login: config6.enableSSOLogin,
+    google_oauth_mode: config6.googleOAuthMode,
+    google_oauth_client_id: config6.googleOAuthClientId,
+    use_workspace_sso: config6.useWorkspaceSSO
   };
 }
 
@@ -246277,9 +246482,9 @@ async function getAuthConfig() {
   }
   return result.data.authConfig;
 }
-async function pushAuthConfigToApi(config5) {
+async function pushAuthConfigToApi(config6) {
   const { id } = getAppContext();
-  const payload = toAuthConfigPayload(config5);
+  const payload = toAuthConfigPayload(config6);
   if (hasWorkspaceApiKeyAuth()) {
     try {
       await base44Client.put(`api/apps/${id}/deployment/auth-configuration`, {
@@ -246288,7 +246493,7 @@ async function pushAuthConfigToApi(config5) {
     } catch (error48) {
       throw await ApiError.fromHttpError(error48, "updating auth config");
     }
-    return config5;
+    return config6;
   }
   let response;
   try {
@@ -246335,16 +246540,16 @@ async function readAuthConfig(authDir) {
   }
   return result.data;
 }
-async function writeAuthConfig(authDir, config5) {
+async function writeAuthConfig(authDir, config6) {
   const filePath = getAuthConfigPath(authDir);
   if (await pathExists(filePath)) {
     const existing = await readJsonFile(filePath);
     const existingResult = AuthConfigFileSchema.safeParse(existing);
-    if (existingResult.success && isDeepStrictEqual2(existingResult.data, config5)) {
+    if (existingResult.success && isDeepStrictEqual2(existingResult.data, config6)) {
       return { written: false };
     }
   }
-  await writeJsonFile(filePath, config5);
+  await writeJsonFile(filePath, config6);
   return { written: true };
 }
 // src/core/resources/auth-config/pull.ts
@@ -246352,17 +246557,17 @@ async function pullAuthConfig() {
   return await getAuthConfig();
 }
 // src/core/resources/auth-config/push.ts
-async function pushAuthConfig(config5) {
-  if (!config5) {
+async function pushAuthConfig(config6) {
+  if (!config6) {
     return;
   }
-  await pushAuthConfigToApi(config5);
+  await pushAuthConfigToApi(config6);
 }
 // src/core/resources/auth-config/resource.ts
 var authConfigResource = {
   readAll: async (dir) => {
-    const config5 = await readAuthConfig(dir);
-    return config5 ? [config5] : [];
+    const config6 = await readAuthConfig(dir);
+    return config6 ? [config6] : [];
   },
   push: async (items) => {
     await pushAuthConfig(items[0] ?? null);
@@ -246602,7 +246807,7 @@ class MissingSSOFieldsError extends InvalidInputError {
   }
 }
 function buildSSOSecrets(provider, options) {
-  const schema4 = SSO_PROVIDER_SCHEMAS[provider];
+  const schema5 = SSO_PROVIDER_SCHEMAS[provider];
   const secrets = {};
   secrets["sso_name" /* Name */] = options.ssoName ?? provider;
   secrets["sso_client_id" /* ClientId */] = options.clientId;
@@ -246613,21 +246818,21 @@ function buildSSOSecrets(provider, options) {
       secrets[secretKey] = value;
     }
   }
-  if (schema4.deriveDefaults) {
-    const derived = schema4.deriveDefaults(secrets);
+  if (schema5.deriveDefaults) {
+    const derived = schema5.deriveDefaults(secrets);
     for (const [key, val] of Object.entries(derived)) {
       if (!secrets[key]) {
         secrets[key] = val;
       }
     }
   }
-  for (const [key, val] of Object.entries(schema4.defaults)) {
+  for (const [key, val] of Object.entries(schema5.defaults)) {
     if (!secrets[key]) {
       secrets[key] = val;
     }
   }
   const missing = [];
-  for (const key of schema4.requiredKeys) {
+  for (const key of schema5.requiredKeys) {
     if (!secrets[key]) {
       missing.push(key);
     }
@@ -247189,36 +247394,34 @@ 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(),
-  exports_external.number(),
-  exports_external.boolean(),
-  exports_external.null(),
-  exports_external.looseObject({
-    $in: exports_external.unknown().optional(),
-    $nin: exports_external.unknown().optional(),
-    $ne: exports_external.unknown().optional(),
-    $all: exports_external.unknown().optional()
-  })
+var fieldConditionOperators = new Set([
+  "$eq",
+  "$ne",
+  "$in",
+  "$nin",
+  "$gt",
+  "$gte",
+  "$lt",
+  "$lte",
+  "$exists",
+  "$all",
+  "$size",
+  "$elemMatch"
 ]);
-var userConditionAllowedKeys = new Set(["role", "email", "id"]);
-var UserConditionSchema = exports_external.looseObject({
-  role: exports_external.string().optional(),
-  email: exports_external.string().optional(),
-  id: exports_external.string().optional()
-}).refine((val) => Object.keys(val).every((key) => userConditionAllowedKeys.has(key) || key.startsWith("data.")), "Keys must be role, email, id, or match data.* pattern");
+var isScalar = (value) => value === null || ["string", "number", "boolean"].includes(typeof value);
+var isValidFieldCondition = (value) => {
+  if (isScalar(value)) {
+    return true;
+  }
+  if (typeof value === "object" && !Array.isArray(value)) {
+    return Object.keys(value).every((k2) => fieldConditionOperators.has(k2));
+  }
+  return false;
+};
+var supportedOperators = [...fieldConditionOperators].sort().join(", ");
+var FieldConditionSchema = exports_external.union([exports_external.string(), exports_external.number(), exports_external.boolean(), exports_external.null(), exports_external.looseObject({})]).refine(isValidFieldCondition, `Field condition values must be a primitive or an operator object (${supportedOperators})`);
+var UserConditionSchema = exports_external.looseObject({}).refine((val) => Object.keys(val).length > 0 && Object.entries(val).every(([key, value]) => !key.startsWith("$") && isScalar(value)), "user_condition compares user attributes by exact equality: a non-empty object of attribute: scalar pairs, no operators");
 var rlsConditionAllowedKeys = new Set([
   "user_condition",
   "created_by",
@@ -247250,18 +247453,13 @@ var RLSConditionSchema = exports_external.looseObject({
     return exports_external.array(RefineRLSConditionSchema).optional();
   }
 });
-var fieldConditionOperators = new Set(["$in", "$nin", "$ne", "$all"]);
-var isValidFieldCondition = (value) => {
-  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return true;
-  }
-  if (typeof value === "object") {
-    return Object.keys(value).every((k2) => fieldConditionOperators.has(k2));
-  }
-  return false;
-};
-var RefineRLSConditionSchema = RLSConditionSchema.refine((val) => Object.entries(val).every(([key, value]) => rlsConditionAllowedKeys.has(key) || isValidFieldCondition(value)), "Field condition values must be a primitive or an operator object ($in, $nin, $ne, $all)");
-var RLSRuleSchema = exports_external.union([exports_external.boolean(), RefineRLSConditionSchema]);
+var RefineRLSConditionSchema = RLSConditionSchema.refine((val) => Object.entries(val).every(([key, value]) => rlsConditionAllowedKeys.has(key) || isValidFieldCondition(value)), `Field condition values must be a primitive or an operator object (${supportedOperators})`);
+var RLSRuleSchema = exports_external.union([
+  exports_external.boolean(),
+  exports_external.null(),
+  exports_external.literal(""),
+  RefineRLSConditionSchema
+]);
 var EntityRLSSchema = exports_external.looseObject({
   create: RLSRuleSchema.optional(),
   read: RLSRuleSchema.optional(),
@@ -247277,7 +247475,7 @@ var FieldRLSSchema = exports_external.looseObject({
   delete: RLSRuleSchema.optional()
 });
 var PropertyDefinitionSchema = exports_external.looseObject({
-  type: exports_external.string(),
+  type: exports_external.union([exports_external.string(), exports_external.array(exports_external.string())]),
   title: exports_external.string().optional(),
   description: exports_external.string().optional(),
   minLength: exports_external.number().int().min(0).optional(),
@@ -247301,7 +247499,7 @@ var PropertyDefinitionSchema = exports_external.looseObject({
 });
 var EntitySchema = exports_external.looseObject({
   type: exports_external.literal("object").default("object"),
-  name: exports_external.string().min(1).regex(/^[a-zA-Z0-9]+$/, "Entity name must be alphanumeric only"),
+  name: exports_external.string().min(1).regex(/^\w+$/, "Entity name must contain only letters, numbers, and underscores"),
   title: exports_external.string().optional(),
   description: exports_external.string().optional(),
   properties: exports_external.record(exports_external.string(), PropertyDefinitionSchema).default({}),
@@ -247636,7 +247834,7 @@ async function fetchFunctionLogs(functionName, filters = {}) {
   return result.data;
 }
 // src/core/resources/function/config.ts
-import { basename as basename3, dirname as dirname6, join as join9, relative, resolve as resolve2 } from "node:path";
+import { basename as basename4, dirname as dirname8, join as join9, relative as relative3, resolve as resolve2 } from "node:path";
 async function readSharedFiles(functionsDir) {
   const sharedDir = resolve2(functionsDir, "..", "shared");
   if (!await pathExists(sharedDir)) {
@@ -247653,9 +247851,9 @@ async function readFunctionConfig(configPath) {
   return result.data;
 }
 async function readFunction(configPath, sharedFiles) {
-  const config8 = await readFunctionConfig(configPath);
-  const functionDir = dirname6(configPath);
-  const entryPath = join9(functionDir, config8.entry);
+  const config9 = await readFunctionConfig(configPath);
+  const functionDir = dirname8(configPath);
+  const entryPath = join9(functionDir, config9.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" }]
@@ -247667,7 +247865,7 @@ async function readFunction(configPath, sharedFiles) {
   });
   const allFilePaths = [...new Set([...filePaths, ...sharedFiles])];
   const functionData = {
-    ...config8,
+    ...config9,
     entryPath,
     filePaths: allFilePaths,
     source: { type: "project" }
@@ -247687,18 +247885,18 @@ 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 sharedFiles = await readSharedFiles(functionsDir);
   const functionsFromConfig = await Promise.all(configFiles.map((configPath) => readFunction(configPath, sharedFiles)));
   const functionsWithoutConfig = await Promise.all(entryFilesWithoutConfig.map(async (entryFile) => {
-    const functionDir = dirname6(entryFile);
+    const functionDir = dirname8(entryFile);
     const filePaths = await globby(BACKEND_FILE_GLOB, {
       cwd: functionDir,
       absolute: true
     });
     const allFilePaths = [...new Set([...filePaths, ...sharedFiles])];
-    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: [
@@ -247708,7 +247906,7 @@ async function readAllFunctions(functionsDir) {
         ]
       });
     }
-    const entry = basename3(entryFile);
+    const entry = basename4(entryFile);
     const functionData = {
       name: name2,
       entry,
@@ -247735,17 +247933,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);
@@ -247763,7 +247961,8 @@ async function deployOne(fn) {
     return {
       name: fn.name,
       status: "error",
-      error: error48 instanceof Error ? error48.message : String(error48)
+      error: error48 instanceof Error ? error48.message : String(error48),
+      cause: error48 instanceof Error ? error48 : undefined
     };
   }
 }
@@ -247773,7 +247972,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);
   }
@@ -247816,14 +248015,14 @@ async function writeFunctions(functionsDir, functions) {
       skipped.push(fn.name);
       continue;
     }
-    const config8 = {
+    const config9 = {
       name: fn.name,
       entry: fn.entry
     };
     if (fn.automations.length > 0) {
-      config8.automations = fn.automations;
+      config9.automations = fn.automations;
     }
-    await writeJsonFile(configPath, config8);
+    await writeJsonFile(configPath, config9);
     for (const file2 of fn.files) {
       await writeFile(join10(functionDir, file2.path), file2.content);
     }
@@ -247866,15 +248065,24 @@ async function isFunctionUnchanged(functionDir, fn) {
 // src/core/resources/function/resource.ts
 var functionResource = {
   readAll: readAllFunctions,
-  push: (functions) => deployFunctionsSequentially(functions)
+  push: async (functions) => {
+    const results = await deployFunctionsSequentially(functions);
+    throwIfDeployFailed(results, "function");
+    return results;
+  }
 };
 // src/core/project/config.ts
 class ProjectConfigReader {
   pluginSourceByNamespace = new Map;
-  async readProjectConfig(projectRoot) {
+  async readProjectSettings(projectRoot) {
     const { root, configPath } = await this.findConfigOrThrow(projectRoot);
     const project = await this.readConfigFile(configPath);
     this.assertPluginProjectDoesNotLoadPlugins(project, configPath);
+    return { ...project, root, configPath };
+  }
+  async readProjectConfig(projectRoot) {
+    const project = await this.readProjectSettings(projectRoot);
+    const { configPath } = project;
     const localResources = await this.readProjectResources(configPath, project);
     const pluginResources = await this.readPlugins(project.plugins, configPath);
     const entities = mergeProjectAndPluginEntities(localResources.entities, pluginResources.entities, configPath);
@@ -247883,10 +248091,12 @@ class ProjectConfigReader {
       ...pluginResources.functions
     ];
     this.validateFunctionNames(functions, configPath);
+    this.validateActorNames(localResources.actors, functions, configPath);
     return {
-      project: { ...project, root, configPath },
+      project,
       entities,
       functions,
+      actors: localResources.actors,
       agents: localResources.agents,
       agentSkills: localResources.agentSkills,
       connectors: localResources.connectors,
@@ -247915,16 +248125,33 @@ class ProjectConfigReader {
     return result.data;
   }
   async readProjectResources(configPath, project) {
-    const configDir = dirname8(configPath);
-    const [entities, functions, agents, agentSkills, connectors, authConfig] = await Promise.all([
+    const configDir = dirname10(configPath);
+    const [
+      entities,
+      functions,
+      actors,
+      agents,
+      agentSkills,
+      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)),
       agentSkillResource.readAll(join11(configDir, project.agentSkillsDir)),
       connectorResource.readAll(join11(configDir, project.connectorsDir)),
       authConfigResource.readAll(join11(configDir, project.authDir))
     ]);
-    return { entities, functions, agents, agentSkills, connectors, authConfig };
+    return {
+      entities,
+      functions,
+      actors,
+      agents,
+      agentSkills,
+      connectors,
+      authConfig
+    };
   }
   assertPluginProjectDoesNotLoadPlugins(project, configPath) {
     if (project.plugin && project.plugins.length > 0) {
@@ -247945,7 +248172,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);
@@ -247957,6 +248184,7 @@ class ProjectConfigReader {
     return {
       entities: markPluginEntities(resources.entities, namespace),
       functions: namespacePluginFunctions(resources.functions, namespace),
+      actors: [],
       agents: [],
       agentSkills: [],
       connectors: [],
@@ -247995,6 +248223,7 @@ class ProjectConfigReader {
     return {
       entities,
       functions,
+      actors: [],
       agents: [],
       agentSkills: [],
       connectors: [],
@@ -248017,15 +248246,33 @@ class ProjectConfigReader {
       functionsByName.set(fn.name, fn);
     }
   }
+  validateActorNames(actors, functions, configPath) {
+    const functionNames = new Set(functions.map((fn) => fn.name));
+    for (const actor of actors) {
+      if (functionNames.has(actor.name)) {
+        throw new ConfigInvalidError(`"${actor.name}" exists as both a backend function and an actor.`, configPath, {
+          hints: [
+            {
+              message: "Actors and functions share one deploy namespace — rename one of them."
+            }
+          ]
+        });
+      }
+    }
+  }
 }
 async function readProjectConfig(projectRoot) {
   const reader = new ProjectConfigReader;
   return await reader.readProjectConfig(projectRoot);
 }
+async function readProjectSettings(projectRoot) {
+  const reader = new ProjectConfigReader;
+  return await reader.readProjectSettings(projectRoot);
+}
 // src/core/project/template.ts
 var import_ejs = __toESM(require_ejs(), 1);
 var import_front_matter2 = __toESM(require_front_matter(), 1);
-import { dirname as dirname9, join as join13 } from "node:path";
+import { dirname as dirname11, join as join13 } from "node:path";
 
 // src/core/assets.ts
 import { cpSync, existsSync } from "node:fs";
@@ -248034,7 +248281,7 @@ import { join as join12 } from "node:path";
 // package.json
 var package_default = {
   name: "base44",
-  version: "0.1.8",
+  version: "0.1.9",
   description: "Base44 CLI - Unified interface for managing Base44 applications",
   type: "module",
   bin: {
@@ -248186,7 +248433,7 @@ async function renderTemplate(template, destPath, data, options = {}) {
       if (file2.endsWith(".ejs")) {
         const rendered = await import_ejs.default.renderFile(srcPath, data);
         const { attributes, body } = import_front_matter2.default(rendered);
-        const destFile = attributes.outputFileName ? join13(dirname9(file2), attributes.outputFileName) : file2.replace(/\.ejs$/, "");
+        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);
@@ -248335,7 +248582,9 @@ async function deploySite(siteOutputDir) {
   if (!await pathExists(siteOutputDir)) {
     throw new InvalidInputError(`Output directory does not exist: ${siteOutputDir}. Make sure to build your project first.`, {
       hints: [
-        { message: "Run your build command (e.g., 'npm run build') first" }
+        {
+          message: "Run 'base44 build' first (it injects your app id; a bare 'npm run build' does not)"
+        }
       ]
     });
   }
@@ -248343,7 +248592,9 @@ async function deploySite(siteOutputDir) {
   if (filePaths.length === 0) {
     throw new ConfigInvalidError(`No files found in output directory: ${siteOutputDir}. Make sure to build your project first.`, siteOutputDir, {
       hints: [
-        { message: "Run your build command (e.g., 'npm run build') first" }
+        {
+          message: "Run 'base44 build' first (it injects your app id; a bare 'npm run build' does not)"
+        }
       ]
     });
   }
@@ -248365,7 +248616,7 @@ async function createArchive(pathToArchive, targetArchivePath) {
 // src/core/site/manifest.ts
 import { createHash } from "node:crypto";
 import { readFile as readFile2, stat } from "node:fs/promises";
-import { basename as basename4, join as join15 } from "node:path";
+import { basename as basename5, join as join15 } from "node:path";
 var MAX_ASSET_SIZE_BYTES = 25 * 1024 * 1024;
 var MAX_ASSET_COUNT = 1e5;
 var ASSETS_IGNORE_FILE = ".assetsignore";
@@ -248387,7 +248638,7 @@ async function buildAssetManifest(assetsDir, appId) {
     followSymbolicLinks: false,
     ignoreFiles: [ASSETS_IGNORE_FILE]
   });
-  const relativeFilePaths = found.filter((path11) => !ALWAYS_IGNORED.has(basename4(path11)));
+  const relativeFilePaths = found.filter((path11) => !ALWAYS_IGNORED.has(basename5(path11)));
   if (relativeFilePaths.length > MAX_ASSET_COUNT) {
     throw new InvalidInputError(`Too many static assets: found ${relativeFilePaths.length}, the limit is ${MAX_ASSET_COUNT} files.`);
   }
@@ -248604,6 +248855,7 @@ function hasResourcesToDeploy(projectData) {
     project,
     entities,
     functions,
+    actors,
     agents,
     agentSkills,
     connectors,
@@ -248612,18 +248864,20 @@ function hasResourcesToDeploy(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 hasAgentSkills = agentSkills.length > 0;
   const hasConnectors = connectors.length > 0;
   const hasAuthConfig = authConfig.length > 0;
   const hasVisibility = Boolean(project.visibility);
-  return hasEntities || hasFunctions || hasAgents || hasAgentSkills || hasConnectors || hasAuthConfig || hasVisibility || hasSite;
+  return hasEntities || hasFunctions || hasActors || hasAgents || hasAgentSkills || hasConnectors || hasAuthConfig || hasVisibility || hasSite;
 }
 async function deployAll(projectData, options) {
   const {
     project,
     entities,
     functions,
+    actors,
     agents,
     agentSkills,
     connectors,
@@ -248634,10 +248888,16 @@ async function deployAll(projectData, options) {
     options?.onVisibilitySet?.(project.visibility);
   }
   await entityResource.push(entities);
-  await deployFunctionsSequentially(functions, {
+  const functionResults = await deployFunctionsSequentially(functions, {
     onStart: options?.onFunctionStart,
     onResult: options?.onFunctionResult
   });
+  throwIfDeployFailed(functionResults, "function");
+  const actorResults = await deployActorsSequentially(actors, {
+    onStart: options?.onActorStart,
+    onResult: options?.onActorResult
+  });
+  throwIfDeployFailed(actorResults, "actor");
   await agentSkillResource.push(agentSkills);
   await agentResource.push(agents);
   await authConfigResource.push(authConfig);
@@ -255586,6 +255846,34 @@ function writeJsonError(error48) {
       envelope.hints = error48.hints;
     }
   }
+  if (error48 instanceof ApiError) {
+    if (error48.statusCode !== undefined) {
+      envelope.statusCode = error48.statusCode;
+    }
+    if (error48.requestId !== undefined) {
+      envelope.requestId = error48.requestId;
+    }
+  }
+  if (error48 instanceof ResourceDeployError) {
+    envelope.failures = error48.failures.map((failure) => {
+      const item = {
+        name: failure.name,
+        error: failure.message
+      };
+      if (isCLIError(failure.cause)) {
+        item.code = failure.cause.code;
+      }
+      if (failure.cause instanceof ApiError) {
+        if (failure.cause.statusCode !== undefined) {
+          item.statusCode = failure.cause.statusCode;
+        }
+        if (failure.cause.requestId !== undefined) {
+          item.requestId = failure.cause.requestId;
+        }
+      }
+      return item;
+    });
+  }
   process.stdout.write(`${JSON.stringify(envelope)}
 `);
 }
@@ -255682,11 +255970,55 @@ async function confirmPush({
   });
   return !Ct(proceed) && proceed;
 }
+// src/cli/utils/datetime.ts
+var import_ms2 = __toESM(require_ms(), 1);
+var HAS_TIMEZONE_SUFFIX = /Z$|[+-]\d{2}:\d{2}$/;
+function normalizeDatetime(value) {
+  const duration3 = import_ms2.default(value);
+  if (duration3 !== undefined) {
+    return new Date(Date.now() - duration3).toISOString();
+  }
+  if (HAS_TIMEZONE_SUFFIX.test(value))
+    return value;
+  return `${value}Z`;
+}
+// src/cli/utils/deploy-reporting.ts
+function formatDuration(ms2) {
+  return `${(ms2 / 1000).toFixed(1)}s`;
+}
+function formatDeployResult(result, log) {
+  const label = result.name.padEnd(25);
+  if (result.status === "deployed") {
+    const timing = result.durationMs ? theme.styles.dim(` (${formatDuration(result.durationMs)})`) : "";
+    log.success(`${label} deployed${timing}`);
+  } else if (result.status === "unchanged") {
+    log.success(`${label} unchanged`);
+  } else {
+    log.error(`${label} error: ${result.error}`);
+  }
+}
+function buildDeploySummary(results, noun) {
+  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 ${noun} deployed`;
+}
 // src/cli/utils/json.ts
 function toJsonStdout(result) {
   return `${JSON.stringify(result, null, 2)}
 `;
 }
+// src/cli/utils/parse-names.ts
+function parseNames(args) {
+  return args.flatMap((arg) => arg.split(",")).map((n2) => n2.trim()).filter(Boolean);
+}
 // src/cli/errors.ts
 class CLIExitError extends Error {
   code;
@@ -255806,6 +256138,55 @@ function formatYaml(data, options = {}) {
   const replacer = stripEmpty ? stripEmptyReplacer : undefined;
   return $stringify(data, replacer, { indent: YAML_INDENT }).trimEnd();
 }
+// src/cli/commands/actors/delete.ts
+async function deleteActorsAction({ runTask: runTask2 }, names) {
+  let deleted = 0;
+  let notFound = 0;
+  let errors4 = 0;
+  for (const name2 of names) {
+    try {
+      await runTask2(`Deleting ${name2}...`, () => deleteSingleActor(name2), {
+        successMessage: `${name2} deleted`,
+        errorMessage: `Failed to delete ${name2}`
+      });
+      deleted++;
+    } catch (error48) {
+      if (error48 instanceof ApiError && error48.statusCode === 404) {
+        notFound++;
+      } else {
+        errors4++;
+      }
+    }
+  }
+  if (names.length === 1) {
+    if (deleted)
+      return { outroMessage: `Actor "${names[0]}" deleted` };
+    if (notFound)
+      return { outroMessage: `Actor "${names[0]}" not found` };
+    return { outroMessage: `Failed to delete "${names[0]}"` };
+  }
+  const total = names.length;
+  const parts = [];
+  if (deleted > 0)
+    parts.push(`${deleted}/${total} deleted`);
+  if (notFound > 0)
+    parts.push(`${notFound} not found`);
+  if (errors4 > 0)
+    parts.push(`${errors4} error${errors4 !== 1 ? "s" : ""}`);
+  return { outroMessage: parts.join(", ") };
+}
+function validateNames(command2) {
+  const names = parseNames(command2.args);
+  if (names.length === 0) {
+    command2.error("At least one actor name is required");
+  }
+}
+function getDeleteCommand() {
+  return new Base44Command("delete").description("Delete deployed actors").argument("<names...>", "Actor names to delete").hook("preAction", validateNames).action(async (ctx, rawNames) => {
+    const names = parseNames(rawNames);
+    return deleteActorsAction(ctx, names);
+  });
+}
 // src/core/utils/dependencies.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
 function verifyDenoInstalled(context) {
@@ -255893,13 +256274,64 @@ async function moveAppToWorkspace(appId, targetWorkspaceId, options = {}) {
   }
   return result.data;
 }
+// src/cli/commands/actors/deploy.ts
+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));
+}
+async function deployActorsAction({ log }, names) {
+  const { actors, project: project2 } = await readProjectConfig();
+  const toDeploy = resolveActorsToDeploy(names, actors);
+  if (toDeploy.length === 0) {
+    return {
+      outroMessage: `No actors found. Create actors in the '${project2.actorsDir}' 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, "actors"));
+    throwIfDeployFailed(results, "actor");
+  }
+  return { outroMessage: buildDeploySummary(results, "actors") };
+}
+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 deployActorsAction(ctx, names);
+  });
+}
+
+// src/cli/commands/actors/index.ts
+function getActorsCommand() {
+  return new Command("actors").description("Manage actors").addCommand(getDeployCommand()).addCommand(getDeleteCommand());
+}
+
 // src/cli/commands/agent-skills/pull.ts
+import { dirname as dirname12, join as join17 } from "node:path";
 async function pullAction({
   log,
   runTask: runTask2
 }) {
   const { project: project2 } = await readProjectConfig();
-  const dir = join17(dirname10(project2.configPath), project2.agentSkillsDir);
+  const dir = join17(dirname12(project2.configPath), project2.agentSkillsDir);
   const remote = await runTask2("Fetching agent skills from Base44", () => fetchAgentSkills(), {
     successMessage: "Agent skills fetched successfully",
     errorMessage: "Failed to fetch agent skills"
@@ -255955,13 +256387,13 @@ function getAgentSkillsCommand() {
 }
 
 // src/cli/commands/agents/pull.ts
-import { dirname as dirname11, join as join18 } from "node:path";
+import { dirname as dirname13, join as join18 } from "node:path";
 async function pullAgentsAction({
   log,
   runTask: runTask2
 }) {
   const { project: project2 } = await readProjectConfig();
-  const configDir = dirname11(project2.configPath);
+  const configDir = dirname13(project2.configPath);
   const agentsDir = join18(configDir, project2.agentsDir);
   const remoteAgents = await runTask2("Fetching agents from Base44", async () => {
     return await fetchAgents();
@@ -256032,11 +256464,11 @@ function getAgentsCommand() {
 }
 
 // src/cli/commands/auth/password-login.ts
-import { dirname as dirname12, join as join19 } from "node:path";
+import { dirname as dirname14, join as join19 } from "node:path";
 async function passwordLoginAction({ log, runTask: runTask2 }, action) {
   const shouldEnable = action === "enable";
   const { project: project2 } = await readProjectConfig();
-  const configDir = dirname12(project2.configPath);
+  const configDir = dirname14(project2.configPath);
   const authDir = join19(configDir, project2.authDir);
   const updated = await runTask2("Updating local auth config", async () => {
     const current = await readAuthConfig(authDir) ?? DEFAULT_AUTH_CONFIG;
@@ -256057,13 +256489,13 @@ function getPasswordLoginCommand() {
 }
 
 // src/cli/commands/auth/pull.ts
-import { dirname as dirname13, join as join20 } from "node:path";
+import { dirname as dirname15, join as join20 } from "node:path";
 async function pullAuthAction({
   log,
   runTask: runTask2
 }) {
   const { project: project2 } = await readProjectConfig();
-  const configDir = dirname13(project2.configPath);
+  const configDir = dirname15(project2.configPath);
   const authDir = join20(configDir, project2.authDir);
   const remoteConfig = await runTask2("Fetching auth config from Base44", async () => {
     return await pullAuthConfig();
@@ -256128,7 +256560,7 @@ function getAuthPushCommand() {
 }
 
 // src/cli/commands/auth/social-login.ts
-import { dirname as dirname14, join as join21, resolve as resolve4 } from "node:path";
+import { dirname as dirname16, join as join21, resolve as resolve4 } from "node:path";
 var PROVIDER_LABELS = {
   google: "Google",
   microsoft: "Microsoft",
@@ -256198,7 +256630,7 @@ async function socialLoginAction({ log, isNonInteractive, runTask: runTask2 }, p
     }
   }
   const { project: project2 } = await readProjectConfig();
-  const configDir = dirname14(project2.configPath);
+  const configDir = dirname16(project2.configPath);
   const authDir = join21(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) {
@@ -256224,7 +256656,7 @@ function getSocialLoginCommand() {
 }
 
 // src/cli/commands/auth/sso.ts
-import { dirname as dirname15, join as join22, resolve as resolve5 } from "node:path";
+import { dirname as dirname17, join as join22, resolve as resolve5 } from "node:path";
 var SSOConfigFileSchema = exports_external.object({
   provider: exports_external.enum(Object.values(KNOWN_SSO_PROVIDERS)),
   clientId: exports_external.string(),
@@ -256387,7 +256819,7 @@ async function ssoEnableAction({ isNonInteractive, runTask: runTask2 }, options)
     throw error48;
   }
   const { project: project2 } = await readProjectConfig();
-  const configDir = dirname15(project2.configPath);
+  const configDir = dirname17(project2.configPath);
   const authDir = join22(configDir, project2.authDir);
   await runTask2("Updating local auth config", async () => updateSSOConfig(authDir, provider, true));
   await runTask2("Saving SSO credentials", async () => pushSSOSecrets(secrets));
@@ -256403,7 +256835,7 @@ async function ssoDisableAction({ log, runTask: runTask2 }, options) {
     throw new InvalidInputError("Configuration options cannot be used with disable. To disable SSO: base44 auth sso disable");
   }
   const { project: project2 } = await readProjectConfig();
-  const configDir = dirname15(project2.configPath);
+  const configDir = dirname17(project2.configPath);
   const authDir = join22(configDir, project2.authDir);
   const updated = await runTask2("Updating local auth config", async () => updateSSOConfig(authDir, null, false));
   await runTask2("Removing SSO credentials", async () => deleteSSOSecrets());
@@ -257261,13 +257693,13 @@ function getConnectorsListAvailableCommand() {
 }
 
 // src/cli/commands/connectors/pull.ts
-import { dirname as dirname16, join as join23, resolve as resolve6 } from "node:path";
+import { dirname as dirname18, join as join23, resolve as resolve6 } from "node:path";
 async function resolveConnectorsDir(options) {
   if (!getAppContext().projectRoot) {
     return resolve6(options.dir ?? "connectors");
   }
   const { project: project2 } = await readProjectConfig();
-  return join23(dirname16(project2.configPath), project2.connectorsDir);
+  return join23(dirname18(project2.configPath), project2.connectorsDir);
 }
 async function pullConnectorsAction({ log, runTask: runTask2, jsonMode }, options) {
   const connectorsDir = await resolveConnectorsDir(options);
@@ -257522,43 +257954,19 @@ async function deleteFunctionsAction({ runTask: runTask2 }, names) {
     parts.push(`${errors5} error${errors5 !== 1 ? "s" : ""}`);
   return { outroMessage: parts.join(", ") };
 }
-function parseNames(args) {
-  return args.flatMap((arg) => arg.split(",")).map((n2) => n2.trim()).filter(Boolean);
-}
-function validateNames(command2) {
+function validateNames2(command2) {
   const names = parseNames(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) => {
+function getDeleteCommand2() {
+  return new Base44Command("delete").description("Delete deployed functions").argument("<names...>", "Function names to delete").hook("preAction", validateNames2).action(async (ctx, rawNames) => {
     const names = parseNames(rawNames);
     return deleteFunctionsAction(ctx, names);
   });
 }
 
-// src/cli/commands/functions/formatDeployResult.ts
-function formatDuration(ms) {
-  return `${(ms / 1000).toFixed(1)}s`;
-}
-function formatDeployResult(result, log) {
-  const label = result.name.padEnd(25);
-  if (result.status === "deployed") {
-    const timing = result.durationMs ? theme.styles.dim(` (${formatDuration(result.durationMs)})`) : "";
-    log.success(`${label} deployed${timing}`);
-  } else if (result.status === "unchanged") {
-    log.success(`${label} unchanged`);
-  } else {
-    log.error(`${label} error: ${result.error}`);
-  }
-}
-
-// src/cli/commands/functions/parseNames.ts
-function parseNames2(args) {
-  return args.flatMap((arg) => arg.split(",")).map((n2) => n2.trim()).filter(Boolean);
-}
-
 // src/cli/commands/functions/deploy.ts
 function resolveFunctionsToDeploy(names, allFunctions) {
   if (names.length === 0)
@@ -257582,19 +257990,6 @@ function formatPruneSummary(pruneResults, log) {
     log.info(`${pruned} deleted`);
   }
 }
-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 functions deployed";
-}
 async function deployFunctionsAction({ log }, names, options) {
   if (options.force && names.length > 0) {
     throw new InvalidInputError("--force cannot be used when specifying function names");
@@ -257621,8 +258016,8 @@ async function deployFunctionsAction({ log }, names, options) {
   });
   const hasFailures = results.some((r) => r.status === "error");
   if (hasFailures) {
-    log.message(buildDeploySummary(results));
-    throw new CLIExitError(1);
+    log.message(buildDeploySummary(results, "functions"));
+    throwIfDeployFailed(results, "function");
   }
   if (options.force) {
     const allLocalNames = functions.map((f) => f.name);
@@ -257643,11 +258038,11 @@ async function deployFunctionsAction({ log }, names, options) {
     });
     formatPruneSummary(pruneResults, log);
   }
-  return { outroMessage: buildDeploySummary(results) };
+  return { outroMessage: buildDeploySummary(results, "functions") };
 }
-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 = parseNames(rawNames);
     return deployFunctionsAction(ctx, names, options);
   });
 }
@@ -257675,10 +258070,10 @@ function getListCommand() {
 }
 
 // src/cli/commands/functions/pull.ts
-import { dirname as dirname17, join as join24 } from "node:path";
+import { dirname as dirname19, join as join24 } from "node:path";
 async function pullFunctionsAction({ log, runTask: runTask2 }, name2) {
   const { project: project2, functions } = await readProjectConfig();
-  const configDir = dirname17(project2.configPath);
+  const configDir = dirname19(project2.configPath);
   const functionsDir = join24(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 () => {
@@ -257734,7 +258129,7 @@ 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(getDeleteCommand2()).addCommand(getListCommand()).addCommand(getPullCommand());
 }
 
 // src/cli/commands/project/site-build.ts
@@ -257812,7 +258207,7 @@ function getBuildCommand() {
 }
 
 // src/cli/commands/project/create.ts
-import { basename as basename5, resolve as resolve8 } from "node:path";
+import { basename as basename6, resolve as resolve8 } from "node:path";
 var import_kebabCase = __toESM(require_kebabCase(), 1);
 
 // src/cli/commands/project/scaffold-shared.ts
@@ -257833,7 +258228,7 @@ async function completeProjectSetup({
   projectId,
   name: name2,
   resolvedPath,
-  deploy: deploy5,
+  deploy: deploy6,
   skills,
   isInteractive
 }, { runTask: runTask2 }) {
@@ -257847,7 +258242,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 () => {
@@ -257867,13 +258262,17 @@ 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) => {
         await execa({ cwd: resolvedPath, shell: true })`${installCommand}`;
         updateMessage("Building project...");
-        await execa({ cwd: resolvedPath, shell: true })`${buildCommand}`;
+        await execa({
+          cwd: resolvedPath,
+          shell: true,
+          env: { VITE_BASE44_APP_ID: projectId }
+        })`${buildCommand}`;
         updateMessage("Deploying site...");
         return await deploySite(join25(resolvedPath, outputDirectory));
       }, {
@@ -257973,8 +258372,8 @@ async function createInteractive(options, ctx) {
     name: () => {
       return options.name ? Promise.resolve(options.name) : Ze({
         message: "What is the name of your project?",
-        placeholder: basename5(process.cwd()),
-        initialValue: basename5(process.cwd()),
+        placeholder: basename6(process.cwd()),
+        initialValue: basename6(process.cwd()),
         validate: (value) => {
           if (!value || value.trim().length === 0) {
             return "Every project deserves a name";
@@ -258021,7 +258420,7 @@ async function executeCreate({
   name: rawName,
   description,
   projectPath,
-  deploy: deploy5,
+  deploy: deploy6,
   skills,
   workspaceId: flagWorkspaceId,
   isInteractive
@@ -258043,7 +258442,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" };
 }
@@ -258090,7 +258489,15 @@ async function deployAction(ctx, 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"}`);
@@ -258098,6 +258505,9 @@ async function deployAction(ctx, 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"}`);
   }
@@ -258131,6 +258541,8 @@ ${summaryLines.join(`
   await maybeBuildBeforeDeploy(ctx, project2, options.build);
   let functionCompleted = 0;
   const functionTotal = functions.length;
+  let actorCompleted = 0;
+  const actorTotal = actors.length;
   const result = await deployAll(projectData, {
     onVisibilitySet: (level) => {
       log.success(`App visibility set to ${level}`);
@@ -258142,6 +258554,14 @@ ${summaryLines.join(`
     onFunctionResult: (r) => {
       functionCompleted++;
       formatDeployResult(r, log);
+    },
+    onActorStart: (names) => {
+      const label = names.length === 1 ? names[0] : `${names.length} actors`;
+      log.step(theme.styles.dim(`[${actorCompleted + 1}/${actorTotal}] Deploying ${label}...`));
+    },
+    onActorResult: (r) => {
+      actorCompleted++;
+      formatDeployResult(r, log);
     }
   });
   const connectorResults = result.connectorResults ?? [];
@@ -258156,8 +258576,8 @@ ${summaryLines.join(`
   }
   return { outroMessage: "App deployed successfully" };
 }
-function getDeployCommand2() {
-  return new Base44Command("deploy").description("Deploy all project resources (entities, functions, agents, connectors, and site)").option("-y, --yes", "Skip confirmation prompt").option("--build", "Build the site before deploying (skips the prompt)").option("--no-build", "Deploy without building (skips the prompt)").action(deployAction);
+function getDeployCommand3() {
+  return new Base44Command("deploy").description("Deploy entities, functions, actors, agent skills, agents, auth, connectors, and site").option("-y, --yes", "Skip confirmation prompt").option("--build", "Build the site before deploying (skips the prompt)").option("--no-build", "Deploy without building (skips the prompt)").action(deployAction);
 }
 async function handleOAuthConnectors(connectorResults, isNonInteractive, options, log) {
   const needsOAuth = filterPendingOAuth(connectorResults);
@@ -258353,7 +258773,6 @@ function getLinkCommand() {
 }
 
 // src/cli/commands/project/logs.ts
-var import_ms2 = __toESM(require_ms(), 1);
 function parseFunctionFilters(options) {
   const filters = {};
   if (options.since) {
@@ -258381,15 +258800,6 @@ function parseFunctionNames(option) {
     return [];
   return option.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
 }
-function normalizeDatetime(value) {
-  const duration3 = import_ms2.default(value);
-  if (duration3 !== undefined) {
-    return new Date(Date.now() - duration3).toISOString();
-  }
-  if (/Z$|[+-]\d{2}:\d{2}$/.test(value))
-    return value;
-  return `${value}Z`;
-}
 function formatEntry(entry) {
   const time3 = entry.time.substring(0, 19).replace("T", " ");
   const level = entry.level.toUpperCase().padEnd(5);
@@ -258551,7 +258961,7 @@ function getLogsCommand() {
 }
 
 // src/cli/commands/project/scaffold.ts
-import { basename as basename6, resolve as resolve9 } from "node:path";
+import { basename as basename7, resolve as resolve9 } from "node:path";
 function resolveAppId(options) {
   const appId = options.appId;
   if (!appId) {
@@ -258568,7 +258978,7 @@ async function scaffoldAction(ctx, name2, options, command2) {
   const { log, runTask: runTask2 } = ctx;
   const appId = resolveAppId(command2.optsWithGlobals());
   const resolvedPath = resolve9("./");
-  const projectName = (name2 ?? basename6(resolvedPath)).trim();
+  const projectName = (name2 ?? basename7(resolvedPath)).trim();
   const template2 = await getTemplateById("backend-only");
   log.info(`Scaffolding project at ${resolvedPath}`);
   const { projectId } = await runTask2("Setting up your project...", async () => {
@@ -258733,7 +259143,7 @@ function withSandboxAuthHint(error48) {
     cause: error48
   });
 }
-async function callTool(appId, tool, payload, schema12, context, timeout2 = 60000) {
+async function callTool(appId, tool, payload, schema13, context, timeout2 = 60000) {
   const client = getSandboxClient(appId);
   let response;
   try {
@@ -258741,7 +259151,7 @@ async function callTool(appId, tool, payload, schema12, context, timeout2 = 6000
   } catch (error48) {
     throw withSandboxAuthHint(await ApiError.fromHttpError(error48, context));
   }
-  const result = schema12.safeParse(await response.json());
+  const result = schema13.safeParse(await response.json());
   if (!result.success) {
     throw new SchemaValidationError("Invalid response from server", result.error);
   }
@@ -259030,7 +259440,7 @@ async function deployAction2(ctx, options) {
   if (isNonInteractive && !options.yes) {
     throw new InvalidInputError("--yes is required in non-interactive mode");
   }
-  const { project: project2 } = await readProjectConfig();
+  const project2 = await readProjectSettings();
   const outputDirectory = project2.site?.outputDirectory;
   if (!outputDirectory) {
     throw new ConfigNotFoundError("No site configuration found.", {
@@ -259142,8 +259552,8 @@ 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' {
@@ -259155,8 +259565,8 @@ async function generateTypesFile(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;
+  if (!entities.length && !functions.length && !agents.length && !connectors.length && !actors.length) {
     return EMPTY_TEMPLATE;
   }
   const entityInterfaces = await Promise.all(entities.map((e8) => compileEntity(e8)));
@@ -259167,7 +259577,8 @@ 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;`)]
   ];
   const registries2 = registryEntries.filter(([, entries]) => entries.length > 0).map(([name2, entries]) => registry2(name2, entries));
   return [
@@ -259187,9 +259598,9 @@ async function generateContent(input) {
 `);
 }
 async function compileEntity(entity2) {
-  const { name: name2, source: _source, ...schema12 } = entity2;
+  const { name: name2, source: _source, ...schema13 } = entity2;
   const jsonSchema = {
-    ...schema12,
+    ...schema13,
     title: name2,
     additionalProperties: false
   };
@@ -259243,14 +259654,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);
@@ -259267,6 +259679,235 @@ function getTypesCommand() {
   return new Command("types").description("Manage TypeScript type generation").addCommand(getTypesGenerateCommand());
 }
 
+// src/core/resources/workflow/schema.ts
+var WorkflowRunStatusSchema = exports_external.enum([
+  "running",
+  "completed",
+  "failed",
+  "cancelled"
+]);
+var WorkflowListItemSchema = exports_external.object({
+  id: exports_external.string(),
+  name: exports_external.string(),
+  description: exports_external.string().nullable().optional(),
+  status: exports_external.string(),
+  status_reason: exports_external.string().nullable().optional(),
+  total_runs: exports_external.number().default(0),
+  consecutive_failures: exports_external.number().default(0),
+  last_run_at: exports_external.string().nullable().optional(),
+  last_run_status: exports_external.string().nullable().optional()
+}).transform((data) => ({
+  id: data.id,
+  name: data.name,
+  description: data.description ?? null,
+  status: data.status,
+  statusReason: data.status_reason ?? null,
+  totalRuns: data.total_runs,
+  consecutiveFailures: data.consecutive_failures,
+  lastRunAt: data.last_run_at ?? null,
+  lastRunStatus: data.last_run_status ?? null
+}));
+var ListWorkflowsResponseSchema = exports_external.array(WorkflowListItemSchema);
+var WorkflowRunSchema = exports_external.object({
+  run_id: exports_external.string(),
+  workflow_id: exports_external.string(),
+  workflow_name: exports_external.string().default(""),
+  trigger_type: exports_external.string().default(""),
+  status: exports_external.string(),
+  started_at: exports_external.string().nullable().optional(),
+  completed_at: exports_external.string().nullable().optional(),
+  duration_ms: exports_external.number().default(0),
+  steps_count: exports_external.number().default(0),
+  error_message: exports_external.string().nullable().optional(),
+  is_test_run: exports_external.boolean().default(false),
+  status_reason: exports_external.string().default("")
+}).transform((data) => ({
+  runId: data.run_id,
+  workflowId: data.workflow_id,
+  workflowName: data.workflow_name,
+  triggerType: data.trigger_type,
+  status: data.status,
+  startedAt: data.started_at ?? null,
+  completedAt: data.completed_at ?? null,
+  durationMs: data.duration_ms,
+  stepsCount: data.steps_count,
+  errorMessage: data.error_message ?? null,
+  isTestRun: data.is_test_run,
+  statusReason: data.status_reason
+}));
+var ListWorkflowRunsResponseSchema = exports_external.array(WorkflowRunSchema);
+
+// src/core/resources/workflow/api.ts
+async function listWorkflows(limit) {
+  const appClient = getAppClient();
+  const searchParams = new URLSearchParams;
+  if (limit !== undefined) {
+    searchParams.set("limit", String(limit));
+  }
+  let response;
+  try {
+    response = await appClient.get("workflows", { searchParams });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "listing workflows");
+  }
+  const result = ListWorkflowsResponseSchema.safeParse(await response.json());
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid workflows response from server", result.error);
+  }
+  return result.data;
+}
+function buildRunsQueryString(filters) {
+  const params = new URLSearchParams;
+  if (filters.status) {
+    params.set("status", filters.status);
+  }
+  if (filters.since) {
+    params.set("since", filters.since);
+  }
+  if (filters.limit !== undefined) {
+    params.set("limit", String(filters.limit));
+  }
+  return params;
+}
+async function listWorkflowRuns(filters = {}) {
+  const appClient = getAppClient();
+  let response;
+  try {
+    response = await appClient.get("workflows/runs", {
+      searchParams: buildRunsQueryString(filters)
+    });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "listing workflow runs");
+  }
+  const result = ListWorkflowRunsResponseSchema.safeParse(await response.json());
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid workflow runs response from server", result.error);
+  }
+  return result.data;
+}
+// src/cli/commands/workflows/legacy-app.ts
+var isWorkflowsNotEnabled = (error48) => error48 instanceof ApiError && error48.statusCode === 403;
+function rethrowLegacyAppAsExplanation(error48) {
+  if (isWorkflowsNotEnabled(error48)) {
+    throw new InvalidInputError("Workflows are not enabled for this app — it predates the Workflows system, so its automation runs are not readable via this command.");
+  }
+  throw error48;
+}
+
+// src/cli/commands/workflows/limit.ts
+var MAX_LIMIT = 200;
+function parseLimit(limit) {
+  if (limit === undefined)
+    return;
+  const parsed = Number.parseInt(limit, 10);
+  if (Number.isNaN(parsed) || parsed < 1 || parsed > MAX_LIMIT) {
+    throw new InvalidInputError(`Invalid limit: "${limit}". Must be a number between 1 and ${MAX_LIMIT}.`);
+  }
+  return parsed;
+}
+
+// src/cli/commands/workflows/list.ts
+function formatWorkflowLine(workflow) {
+  const lastRun = workflow.lastRunAt ? `last run ${workflow.lastRunStatus ?? "unknown"} at ${workflow.lastRunAt}` : "never ran";
+  const failures = workflow.consecutiveFailures > 0 ? ` (${workflow.consecutiveFailures} consecutive failures)` : "";
+  return `${workflow.name}  [${workflow.status}]  runs: ${workflow.totalRuns}, ${lastRun}${failures}`;
+}
+async function listAction({ log, runTask: runTask2, jsonMode }, options8) {
+  const limit = parseLimit(options8.limit);
+  const workflows = await runTask2("Fetching workflows from Base44", async () => listWorkflows(limit).catch(rethrowLegacyAppAsExplanation), {
+    successMessage: "Workflows fetched successfully",
+    errorMessage: "Failed to fetch workflows"
+  });
+  if (jsonMode) {
+    return {
+      outroMessage: `Found ${workflows.length} workflows.`,
+      stdout: `${JSON.stringify({ workflows }, null, 2)}
+`
+    };
+  }
+  if (workflows.length === 0) {
+    return { outroMessage: "This app has no workflows." };
+  }
+  for (const workflow of workflows) {
+    log.info(formatWorkflowLine(workflow));
+  }
+  return { outroMessage: `Found ${workflows.length} workflows.` };
+}
+function getWorkflowsListCommand() {
+  return new Base44Command("list").description("List this app's workflows").option("-n, --limit <n>", `Number of workflows to return (1-${MAX_LIMIT}, default: 30)`).action(listAction);
+}
+
+// src/cli/commands/workflows/runs.ts
+function formatDuration2(durationMs) {
+  if (durationMs === 0)
+    return "";
+  return `  ${(durationMs / 1000).toFixed(1)}s`;
+}
+function formatRunTags(run) {
+  const tags = [run.triggerType, run.isTestRun ? "test" : null].filter(Boolean);
+  return tags.length > 0 ? `  (${tags.join(", ")})` : "";
+}
+function formatFailureDetail(run) {
+  const reason = run.statusReason ? ` [${run.statusReason}]` : "";
+  const message = run.errorMessage ? `
+    ${run.errorMessage}` : "";
+  return `${reason}${message}`;
+}
+function formatRunLine(run) {
+  const time3 = (run.startedAt ?? "").substring(0, 19).replace("T", " ");
+  const status = run.status.toUpperCase().padEnd(9);
+  const base = `${time3} ${status} ${run.workflowName}${formatRunTags(run)}${formatDuration2(run.durationMs)}`;
+  const failureDetail = run.status === "failed" || run.status === "cancelled" ? formatFailureDetail(run) : "";
+  return `${base}${failureDetail}`;
+}
+async function describeEmptyResult(hasFilters) {
+  const workflows = await listWorkflows().catch(() => null);
+  if (workflows === null) {
+    return "No runs found.";
+  }
+  if (workflows.length === 0) {
+    return "This app has no workflows, so there are no runs.";
+  }
+  const names = workflows.map((workflow) => workflow.name).join(", ");
+  return hasFilters ? `No runs match your filters. Workflows in this app: ${names}.` : `No runs yet. Workflows in this app: ${names}.`;
+}
+async function runsAction(ctx, options8) {
+  const limit = parseLimit(options8.limit);
+  const runs = await ctx.runTask("Fetching workflow runs from Base44", async () => listWorkflowRuns({
+    status: options8.status,
+    since: options8.since,
+    limit
+  }).catch(rethrowLegacyAppAsExplanation), {
+    successMessage: "Workflow runs fetched successfully",
+    errorMessage: "Failed to fetch workflow runs"
+  });
+  if (ctx.jsonMode) {
+    return {
+      outroMessage: `Found ${runs.length} runs.`,
+      stdout: `${JSON.stringify({ runs }, null, 2)}
+`
+    };
+  }
+  if (runs.length === 0) {
+    const hasFilters = Boolean(options8.status || options8.since);
+    return { outroMessage: await describeEmptyResult(hasFilters) };
+  }
+  for (const run of runs) {
+    ctx.log.info(formatRunLine(run));
+  }
+  return { outroMessage: `Found ${runs.length} runs.` };
+}
+function getWorkflowsRunsCommand() {
+  return new Base44Command("runs").description("List workflow runs for this app, newest first (includes scheduled, manual, and test runs)").addOption(new Option("--status <status>", "Filter by run status").choices([
+    ...WorkflowRunStatusSchema.options
+  ])).option("--since <datetime>", "Show runs started after this time. ISO datetime or relative shorthand (e.g. 1h, 30m, 2d)", normalizeDatetime).option("-n, --limit <n>", `Number of runs to return (1-${MAX_LIMIT}, default: 30)`).action(runsAction);
+}
+
+// src/cli/commands/workflows/index.ts
+function getWorkflowsCommand() {
+  return new Command("workflows").description("Inspect this app's workflows and their runs").addCommand(getWorkflowsListCommand()).addCommand(getWorkflowsRunsCommand());
+}
+
 // src/cli/commands/workspace/shared.ts
 function workspaceTag(workspace2) {
   const role = workspace2.userRole ?? "member";
@@ -259454,7 +260095,7 @@ function createDevLogger(label2, labelColor = theme.styles.dim) {
 // src/cli/dev/dev-server/main.ts
 var import_cors = __toESM(require_lib4(), 1);
 var import_express6 = __toESM(require_express(), 1);
-import { dirname as dirname23, join as join35 } from "node:path";
+import { dirname as dirname25, join as join35 } from "node:path";
 
 // ../../node_modules/get-port/index.js
 import net from "node:net";
@@ -259475,8 +260116,8 @@ var getLocalHosts = () => {
   const interfaces = os11.networkInterfaces();
   const results = new Set([undefined, "0.0.0.0"]);
   for (const _interface of Object.values(interfaces)) {
-    for (const config13 of _interface) {
-      results.add(config13.address);
+    for (const config14 of _interface) {
+      results.add(config14.address);
     }
   }
   return results;
@@ -259589,7 +260230,7 @@ var $setGracefulCleanup = tmp.setGracefulCleanup;
 
 // src/cli/dev/dev-server/function-manager.ts
 import { spawn as spawn2 } from "node:child_process";
-import { dirname as dirname20, join as join29 } from "node:path";
+import { dirname as dirname22, join as join29 } from "node:path";
 import { pathToFileURL } from "node:url";
 
 // src/cli/dev/dev-server/base-function-manager.ts
@@ -259694,7 +260335,7 @@ class FunctionManager extends BaseFunctionManager {
   }
   spawnFunction(func, port) {
     this.logger.log(`Spawning function "${func.name}" on port ${port}`);
-    const importMapPath = join29(dirname20(this.wrapperPath), "import-map.json");
+    const importMapPath = join29(dirname22(this.wrapperPath), "import-map.json");
     const process23 = spawn2("deno", ["run", "--allow-all", "--import-map", importMapPath, this.wrapperPath], {
       env: {
         ...globalThis.process.env,
@@ -260261,7 +260902,8 @@ var fieldTypes = [
   "number",
   "boolean",
   "array",
-  "object"
+  "object",
+  "null"
 ];
 
 class Validator {
@@ -260321,6 +260963,14 @@ class Validator {
     if (!property) {
       return { hasError: false };
     }
+    if (Array.isArray(property.type)) {
+      const types = property.type;
+      const matched = types.some((type) => !this.validateValue(value, { ...property, type }, fieldPath).hasError);
+      return matched ? { hasError: false } : {
+        hasError: true,
+        error: this.createValidationError(`Error in field ${fieldPath}: Input should be a valid ${types.join(" or ")}`)
+      };
+    }
     const propertyType = property.type;
     if (!fieldTypes.includes(propertyType)) {
       return {
@@ -260361,6 +261011,14 @@ class Validator {
           }
         }
         break;
+      case "null":
+        if (value !== null) {
+          return {
+            hasError: true,
+            error: this.createValidationError(`Error in field ${fieldPath}: Input should be null`)
+          };
+        }
+        break;
       case "integer":
         if (!Number.isInteger(value)) {
           return {
@@ -260479,22 +261137,22 @@ class Database {
     this.schemas.clear();
   }
   validate(entityName, record2, partial2 = false) {
-    const schema12 = this.schemas.get(this.normalizeName(entityName));
-    if (!schema12) {
+    const schema13 = this.schemas.get(this.normalizeName(entityName));
+    if (!schema13) {
       throw new Error(`Entity "${entityName}" not found`);
     }
-    return this.validator.validate(record2, schema12, partial2);
+    return this.validator.validate(record2, schema13, partial2);
   }
   prepareRecord(entityName, record2, partial2 = false) {
-    const schema12 = this.schemas.get(this.normalizeName(entityName));
-    if (!schema12) {
+    const schema13 = this.schemas.get(this.normalizeName(entityName));
+    if (!schema13) {
       throw new Error(`Entity "${entityName}" not found`);
     }
-    const filteredRecord = this.validator.filterFields(record2, schema12);
+    const filteredRecord = this.validator.filterFields(record2, schema13);
     if (partial2) {
       return filteredRecord;
     }
-    return this.validator.applyDefaults(filteredRecord, schema12);
+    return this.validator.applyDefaults(filteredRecord, schema13);
   }
   normalizeName(entityName) {
     return entityName.toLowerCase();
@@ -260780,7 +261438,9 @@ function evaluateCondition(condition, record2, user) {
 function checkRLS(rule, record2, user) {
   if (user?.is_service === true)
     return true;
-  if (rule === undefined)
+  if (rule === undefined || rule === null || rule === "")
+    return true;
+  if (typeof rule === "object" && Object.keys(rule).length === 0)
     return true;
   if (typeof rule === "boolean")
     return rule;
@@ -260788,13 +261448,13 @@ function checkRLS(rule, record2, user) {
     return false;
   return evaluateCondition(rule, record2, user);
 }
-function applyFLS(record2, schema12, user, operation) {
+function applyFLS(record2, schema13, user, operation) {
   if (Array.isArray(record2)) {
-    return record2.map((r5) => applyFLS(r5, schema12, user, operation));
+    return record2.map((r5) => applyFLS(r5, schema13, user, operation));
   }
   const result = {};
   for (const [key2, value] of Object.entries(record2)) {
-    const rule = schema12.properties[key2]?.rls?.[operation];
+    const rule = schema13.properties[key2]?.rls?.[operation];
     if (rule === undefined || checkRLS(rule, record2, user)) {
       result[key2] = value;
     }
@@ -261022,14 +261682,14 @@ async function createEntityRoutes(db2, logger2, broadcast) {
         res.status(404).json({ error: `Entity "${entityName}" not found` });
         return;
       }
-      const schema12 = db2.getSchema(entityName);
-      if (!schema12) {
+      const schema13 = db2.getSchema(entityName);
+      if (!schema13) {
         res.status(404).json({ error: `Schema for "${entityName}" not found` });
         return;
       }
       const currentUserResult = await resolveCurrentUser(db2, req);
       const currentUser = currentUserResult.ok ? currentUserResult.user : undefined;
-      await handler(req, res, collection, schema12, currentUser);
+      await handler(req, res, collection, schema13, currentUser);
     };
   }
   function emit(appId, entityName, type, data) {
@@ -261047,19 +261707,19 @@ async function createEntityRoutes(db2, logger2, broadcast) {
     }
     broadcast(appId, entityName, createData(data));
   }
-  function prepareCreateRecord(entityName, body, schema12, currentUser, now) {
+  function prepareCreateRecord(entityName, body, schema13, currentUser, now) {
     const { _id, ...recordBody } = body;
     const ownerFields = {
       created_by: currentUser?.email,
       created_by_id: currentUser?.id
     };
-    if (!checkRLS(schema12.rls?.create, {
+    if (!checkRLS(schema13.rls?.create, {
       ...recordBody,
       ...ownerFields
     }, currentUser)) {
       return;
     }
-    const filteredBody = applyFLS(db2.prepareRecord(entityName, recordBody), schema12, currentUser, "write");
+    const filteredBody = applyFLS(db2.prepareRecord(entityName, recordBody), schema13, currentUser, "write");
     db2.validate(entityName, filteredBody);
     return {
       ...filteredBody,
@@ -261071,7 +261731,7 @@ async function createEntityRoutes(db2, logger2, broadcast) {
   }
   const userRouter = createUserRouter(db2, logger2);
   router.use("/User", userRouter);
-  router.get("/:entityName/:id", withCollection(async (req, res, collection, schema12, currentUser) => {
+  router.get("/:entityName/:id", withCollection(async (req, res, collection, schema13, currentUser) => {
     const { entityName, id: id2 } = req.params;
     try {
       const doc2 = await collection.findOneAsync({ id: id2 });
@@ -261079,27 +261739,27 @@ async function createEntityRoutes(db2, logger2, broadcast) {
         res.status(404).json({ error: `Record with id "${id2}" not found` });
         return;
       }
-      if (!checkRLS(schema12.rls?.read, doc2, currentUser)) {
+      if (!checkRLS(schema13.rls?.read, doc2, currentUser)) {
         res.status(404).json({
           message: `Entity ${entityName} with ID ${id2} not found`
         });
         return;
       }
-      const result = applyFLS(stripInternalFields(doc2), schema12, currentUser, "read");
+      const result = applyFLS(stripInternalFields(doc2), schema13, currentUser, "read");
       res.json(result);
     } catch (error48) {
       logger2.error(`Error in GET /${entityName}/${id2}:`, error48);
       res.status(500).json({ error: "Internal server error" });
     }
   }));
-  router.get("/:entityName", withCollection(async (req, res, collection, schema12, currentUser) => {
+  router.get("/:entityName", withCollection(async (req, res, collection, schema13, currentUser) => {
     const { entityName } = req.params;
     try {
       let results = stripInternalFields(await queryEntity(collection, req.query));
-      if (schema12.rls?.read !== undefined && schema12.rls.read !== true) {
-        results = results.filter((doc2) => checkRLS(schema12.rls.read, doc2, currentUser));
+      if (schema13.rls?.read !== undefined && schema13.rls.read !== true) {
+        results = results.filter((doc2) => checkRLS(schema13.rls.read, doc2, currentUser));
       }
-      results = results.map((doc2) => applyFLS(doc2, schema12, currentUser, "read"));
+      results = results.map((doc2) => applyFLS(doc2, schema13, currentUser, "read"));
       res.json(results);
     } catch (error48) {
       if (error48 instanceof InvalidInputError) {
@@ -261110,16 +261770,16 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       }
     }
   }));
-  router.post("/:entityName", parseBody, withCollection(async (req, res, collection, schema12, currentUser) => {
+  router.post("/:entityName", parseBody, withCollection(async (req, res, collection, schema13, currentUser) => {
     const { appId, entityName } = req.params;
     try {
       const now = new Date().toISOString();
-      const record2 = prepareCreateRecord(entityName, req.body, schema12, currentUser, now);
+      const record2 = prepareCreateRecord(entityName, req.body, schema13, currentUser, now);
       if (!record2) {
         res.status(403).json({ error: "Permission denied" });
         return;
       }
-      const inserted = applyFLS(stripInternalFields(await collection.insertAsync(record2)), schema12, currentUser, "read");
+      const inserted = applyFLS(stripInternalFields(await collection.insertAsync(record2)), schema13, currentUser, "read");
       emit(appId, entityName, "create", inserted);
       res.status(201).json(inserted);
     } catch (error48) {
@@ -261131,7 +261791,7 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       res.status(500).json({ error: "Internal server error" });
     }
   }));
-  router.post("/:entityName/bulk", parseBody, withCollection(async (req, res, collection, schema12, currentUser) => {
+  router.post("/:entityName/bulk", parseBody, withCollection(async (req, res, collection, schema13, currentUser) => {
     const { appId, entityName } = req.params;
     if (!Array.isArray(req.body)) {
       res.status(400).json({ error: "Request body must be an array" });
@@ -261141,14 +261801,14 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       const now = new Date().toISOString();
       const records = [];
       for (const body of req.body) {
-        const record2 = prepareCreateRecord(entityName, body, schema12, currentUser, now);
+        const record2 = prepareCreateRecord(entityName, body, schema13, currentUser, now);
         if (!record2) {
           res.status(403).json({ error: "Permission denied" });
           return;
         }
         records.push(record2);
       }
-      const inserted = applyFLS(stripInternalFields(await collection.insertAsync(records)), schema12, currentUser, "read");
+      const inserted = applyFLS(stripInternalFields(await collection.insertAsync(records)), schema13, currentUser, "read");
       emit(appId, entityName, "create", inserted);
       res.status(201).json(inserted);
     } catch (error48) {
@@ -261160,24 +261820,24 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       res.status(500).json({ error: "Internal server error" });
     }
   }));
-  router.put("/:entityName/:id", parseBody, withCollection(async (req, res, collection, schema12, currentUser) => {
+  router.put("/:entityName/:id", parseBody, withCollection(async (req, res, collection, schema13, currentUser) => {
     const { appId, entityName, id: id2 } = req.params;
     const { id: _id, created_date: _created_date, ...body } = req.body;
     try {
-      if (schema12.rls?.update !== undefined) {
+      if (schema13.rls?.update !== undefined) {
         const existing = await collection.findOneAsync({ id: id2 });
         if (!existing) {
           res.status(404).json({ error: `Record with id "${id2}" not found` });
           return;
         }
-        if (!checkRLS(schema12.rls.update, existing, currentUser)) {
+        if (!checkRLS(schema13.rls.update, existing, currentUser)) {
           res.status(404).json({
             message: `Entity ${entityName} with ID ${id2} not found`
           });
           return;
         }
       }
-      const filteredBody = applyFLS(db2.prepareRecord(entityName, body, true), schema12, currentUser, "write");
+      const filteredBody = applyFLS(db2.prepareRecord(entityName, body, true), schema13, currentUser, "write");
       db2.validate(entityName, filteredBody, true);
       const updateData = {
         ...filteredBody,
@@ -261188,7 +261848,7 @@ async function createEntityRoutes(db2, logger2, broadcast) {
         res.status(404).json({ error: `Record with id "${id2}" not found` });
         return;
       }
-      const updated = applyFLS(stripInternalFields(result.affectedDocuments), schema12, currentUser, "read");
+      const updated = applyFLS(stripInternalFields(result.affectedDocuments), schema13, currentUser, "read");
       emit(appId, entityName, "update", updated);
       res.json(updated);
     } catch (error48) {
@@ -261200,7 +261860,7 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       res.status(500).json({ error: "Internal server error" });
     }
   }));
-  router.delete("/:entityName/:id", withCollection(async (req, res, collection, schema12, currentUser) => {
+  router.delete("/:entityName/:id", withCollection(async (req, res, collection, schema13, currentUser) => {
     const { appId, entityName, id: id2 } = req.params;
     try {
       const doc2 = await collection.findOneAsync({ id: id2 });
@@ -261208,7 +261868,7 @@ async function createEntityRoutes(db2, logger2, broadcast) {
         res.status(404).json({ error: `Record with id "${id2}" not found` });
         return;
       }
-      if (!checkRLS(schema12.rls?.delete, doc2, currentUser)) {
+      if (!checkRLS(schema13.rls?.delete, doc2, currentUser)) {
         res.status(404).json({
           message: `Entity ${entityName} with ID ${id2} not found`
         });
@@ -261222,11 +261882,11 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       res.status(500).json({ error: "Internal server error" });
     }
   }));
-  router.delete("/:entityName", parseBody, withCollection(async (req, res, collection, schema12, currentUser) => {
+  router.delete("/:entityName", parseBody, withCollection(async (req, res, collection, schema13, currentUser) => {
     const { entityName } = req.params;
     try {
       const query = req.body || {};
-      const rlsDelete = schema12?.rls?.delete;
+      const rlsDelete = schema13?.rls?.delete;
       if (rlsDelete !== undefined && rlsDelete !== true) {
         if (rlsDelete === false && currentUser?.is_service !== true) {
           res.status(403).json({ error: "Permission denied" });
@@ -261342,7 +262002,7 @@ function createCustomIntegrationRoutes(remoteProxy, logger2) {
 
 // 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";
@@ -261512,10 +262172,10 @@ class ReaddirpStream extends Readable6 {
   }
   async _formatEntry(dirent, path19) {
     let entry;
-    const basename7 = this._isDirent ? dirent.name : dirent;
+    const basename8 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path19, basename7));
-      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename7 };
+      const fullPath = presolve(pjoin(path19, basename8));
+      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename8 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
       this._onError(err);
@@ -262042,9 +262702,9 @@ class NodeFsHandler {
   _watchWithNodeFs(path19, listener) {
     const opts = this.fsw.options;
     const directory = sp2.dirname(path19);
-    const basename8 = sp2.basename(path19);
+    const basename9 = sp2.basename(path19);
     const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename8);
+    parent.add(basename9);
     const absolutePath = sp2.resolve(path19);
     const options8 = {
       persistent: opts.persistent
@@ -262054,7 +262714,7 @@ class NodeFsHandler {
     let closer;
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
-      options8.interval = enableBin && isBinaryPath(basename8) ? opts.binaryInterval : opts.interval;
+      options8.interval = enableBin && isBinaryPath(basename9) ? opts.binaryInterval : opts.interval;
       closer = setFsWatchFileListener(path19, absolutePath, options8, {
         listener,
         rawEmitter: this.fsw._emitRaw
@@ -262072,11 +262732,11 @@ class NodeFsHandler {
     if (this.fsw.closed) {
       return;
     }
-    const dirname22 = sp2.dirname(file2);
-    const basename8 = sp2.basename(file2);
-    const parent = this.fsw._getWatchedDir(dirname22);
+    const dirname24 = sp2.dirname(file2);
+    const basename9 = sp2.basename(file2);
+    const parent = this.fsw._getWatchedDir(dirname24);
     let prevStats = stats;
-    if (parent.has(basename8))
+    if (parent.has(basename9))
       return;
     const listener = async (path19, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
@@ -262101,9 +262761,9 @@ class NodeFsHandler {
             prevStats = newStats2;
           }
         } catch (error48) {
-          this.fsw._remove(dirname22, basename8);
+          this.fsw._remove(dirname24, basename9);
         }
-      } else if (parent.has(basename8)) {
+      } else if (parent.has(basename9)) {
         const at13 = newStats.atimeMs;
         const mt12 = newStats.mtimeMs;
         if (!at13 || at13 <= mt12 || mt12 !== prevStats.mtimeMs) {
@@ -262324,11 +262984,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;
     };
@@ -263027,7 +263687,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);
@@ -263134,8 +263794,8 @@ async function createDevServer(options8) {
     broadcastEntityEvent(io6, appId, entityName, event);
   };
   const base44ConfigWatcher = new WatchBase44({
-    functions: join35(dirname23(project2.configPath), project2.functionsDir),
-    entities: join35(dirname23(project2.configPath), project2.entitiesDir)
+    functions: join35(dirname25(project2.configPath), project2.functionsDir),
+    entities: join35(dirname25(project2.configPath), project2.entitiesDir)
   }, devLogger);
   base44ConfigWatcher.on("change", async (name2) => {
     try {
@@ -263331,6 +263991,10 @@ function validateDevOptions(command2) {
   if (appId !== undefined) {
     command2.error(`base44 dev cannot be used with --app-id or ${BASE44_APP_ID_ENV_VAR}.`);
   }
+  const { port, remote } = command2.opts();
+  if (remote && port !== undefined) {
+    command2.error("--port applies to the local backend, which --remote does not start.");
+  }
 }
 function requireLinkedProject({ app }) {
   if (!app?.projectRoot) {
@@ -263338,31 +264002,44 @@ function requireLinkedProject({ app }) {
   }
   return { id: app.id, projectRoot: app.projectRoot };
 }
-async function createConfiguredServeRunner(app, backendUrl) {
+async function resolveConfiguredSite(app) {
   const { project: project2 } = await readProjectConfig(app.projectRoot);
   const serveCommand = project2.site?.serveCommand;
-  if (!serveCommand) {
-    return;
-  }
-  return createServeCommandRunner({
-    serveCommand,
-    projectRoot: project2.root,
-    appId: app.id,
-    appBaseUrl: backendUrl
-  });
+  return serveCommand ? { serveCommand, projectRoot: project2.root } : undefined;
 }
-function startServeCommand(runner, backend) {
+function stopRunnerOnProcessSignals(runner) {
   const stop2 = () => void runner.stop();
   process.on("SIGINT", stop2);
   process.on("SIGTERM", stop2);
+}
+function startServeCommand(runner, backend) {
+  stopRunnerOnProcessSignals(runner);
   runner.onExit(() => {
     backend.shutdown().finally(() => process.exit(1));
   });
   createDevLogger("backend", theme.styles.info).log(`Backend running on ${backend.url}`);
   runner.start();
 }
-async function devAction(ctx, options8) {
-  const app = requireLinkedProject(ctx);
+async function remoteDevAction(app) {
+  const site2 = await resolveConfiguredSite(app);
+  if (!site2) {
+    throw new ConfigInvalidError("base44 dev --remote serves the frontend against the production backend, but this project has no site.serveCommand in base44/config.jsonc.");
+  }
+  const appBaseUrl = await getSiteUrl();
+  const runner = createServeCommandRunner({
+    ...site2,
+    appId: app.id,
+    appBaseUrl
+  });
+  stopRunnerOnProcessSignals(runner);
+  runner.onExit((code2) => process.exit(code2 ?? 1));
+  runner.start();
+  return {
+    outroMessage: `Frontend dev server targets ${theme.styles.bold(appBaseUrl)} — every write hits your live app`
+  };
+}
+async function localDevAction(ctx, app, options8) {
+  const site2 = await resolveConfiguredSite(app);
   const siteUrlPromise = getSiteUrl().catch(() => {
     return;
   });
@@ -263377,15 +264054,23 @@ async function devAction(ctx, options8) {
     }
   });
   const backendUrl = localServerUrl(backend.port);
-  const runner = await createConfiguredServeRunner(app, backendUrl);
-  if (runner) {
+  if (site2) {
+    const runner = createServeCommandRunner({
+      ...site2,
+      appId: app.id,
+      appBaseUrl: backendUrl
+    });
     startServeCommand(runner, { url: backendUrl, shutdown: backend.shutdown });
   }
-  const outroMessage = runner ? "Open your app using the frontend dev server URL" : `Dev server is available at ${theme.colors.links(backendUrl)}`;
+  const outroMessage = site2 ? "Open your app using the frontend dev server URL" : `Dev server is available at ${theme.colors.links(backendUrl)}`;
   return { outroMessage };
 }
+async function devAction(ctx, options8) {
+  const app = requireLinkedProject(ctx);
+  return options8.remote ? remoteDevAction(app) : localDevAction(ctx, app, options8);
+}
 function getDevCommand() {
-  return new Base44Command("dev").description("Start the development server").option("-p, --port <number>", "Port for the development server").hook("preAction", validateDevOptions).action(devAction);
+  return new Base44Command("dev").description("Start the development server").option("-p, --port <number>", "Port for the development server").option("--remote", "Serve the frontend against the production backend instead of a local one").hook("preAction", validateDevOptions).action(devAction);
 }
 
 // src/core/exec/run-script.ts
@@ -263638,7 +264323,7 @@ function createProgram(context) {
   program2.addCommand(getScaffoldCommand());
   program2.addCommand(getDashboardCommand());
   program2.addCommand(getBuildCommand());
-  program2.addCommand(getDeployCommand2());
+  program2.addCommand(getDeployCommand3());
   program2.addCommand(getVisibilityCommand());
   program2.addCommand(getLinkCommand());
   program2.addCommand(getEjectCommand());
@@ -263648,6 +264333,8 @@ function createProgram(context) {
   program2.addCommand(getAgentSkillsCommand());
   program2.addCommand(getConnectorsCommand());
   program2.addCommand(getFunctionsCommand());
+  program2.addCommand(getActorsCommand());
+  program2.addCommand(getWorkflowsCommand());
   program2.addCommand(getSecretsCommand());
   program2.addCommand(getSandboxCommand());
   program2.addCommand(getAuthCommand());
@@ -263664,7 +264351,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 dirname24, posix, sep } from "path";
+import { dirname as dirname26, posix, sep } from "path";
 function createModulerModifier() {
   const getModuleFromFileName = createGetModuleFromFilename();
   return async (frames) => {
@@ -263673,7 +264360,7 @@ function createModulerModifier() {
     return frames;
   };
 }
-function createGetModuleFromFilename(basePath = process.argv[1] ? dirname24(process.argv[1]) : process.cwd(), isWindows5 = sep === "\\") {
+function createGetModuleFromFilename(basePath = process.argv[1] ? dirname26(process.argv[1]) : process.cwd(), isWindows5 = sep === "\\") {
   const normalizedBase = isWindows5 ? normalizeWindowsPath2(basePath) : basePath;
   return (filename) => {
     if (!filename)
@@ -267862,7 +268549,7 @@ function addCommandInfoToErrorReporter(program2, errorReporter) {
   });
 }
 // src/cli/index.ts
-var __dirname4 = dirname25(fileURLToPath6(import.meta.url));
+var __dirname4 = dirname27(fileURLToPath6(import.meta.url));
 async function runCLI(options8) {
   ensureNpmAssets(join36(__dirname4, "../assets"));
   const errorReporter = new ErrorReporter;
@@ -267903,4 +268590,4 @@ export {
   CLIExitError
 };
 
-//# debugId=D124AF9A61B7AEE264756E2164756E21
+//# debugId=FD1D5482C30AB9D864756E2164756E21