@base44-preview/cli 0.1.3-pr.565.21ee30e → 0.1.4-pr.567.1086443

package/dist/cli/index.js

@@ -12982,8 +12982,8 @@ var require_ejs = __commonJS((exports) => {
   exports.resolveInclude = function(name2, filename, isDir) {
     var dirname9 = path11.dirname;
     var extname = path11.extname;
-    var resolve2 = path11.resolve;
-    var includePath = resolve2(isDir ? filename : dirname9(filename), name2);
+    var resolve3 = path11.resolve;
+    var includePath = resolve3(isDir ? filename : dirname9(filename), name2);
     var ext = extname(name2);
     if (!ext) {
       includePath += ".ejs";
@@ -13058,10 +13058,10 @@ var require_ejs = __commonJS((exports) => {
     var result;
     if (!cb) {
       if (typeof exports.promiseImpl == "function") {
-        return new exports.promiseImpl(function(resolve2, reject) {
+        return new exports.promiseImpl(function(resolve3, reject) {
           try {
             result = handleCache(options)(data);
-            resolve2(result);
+            resolve3(result);
           } catch (err) {
             reject(err);
           }
@@ -16499,12 +16499,12 @@ var require_isexe = __commonJS((exports, module) => {
       if (typeof Promise !== "function") {
         throw new TypeError("callback not provided");
       }
-      return new Promise(function(resolve3, reject) {
+      return new Promise(function(resolve4, reject) {
         isexe(path11, options || {}, function(er, is) {
           if (er) {
             reject(er);
           } else {
-            resolve3(is);
+            resolve4(is);
           }
         });
       });
@@ -16566,27 +16566,27 @@ var require_which = __commonJS((exports, module) => {
       opt = {};
     const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
     const found = [];
-    const step = (i) => new Promise((resolve3, reject) => {
+    const step = (i) => new Promise((resolve4, reject) => {
       if (i === pathEnv.length)
-        return opt.all && found.length ? resolve3(found) : reject(getNotFoundError(cmd));
+        return opt.all && found.length ? resolve4(found) : reject(getNotFoundError(cmd));
       const ppRaw = pathEnv[i];
       const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
       const pCmd = path11.join(pathPart, cmd);
       const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-      resolve3(subStep(p, i, 0));
+      resolve4(subStep(p, i, 0));
     });
-    const subStep = (p, i, ii) => new Promise((resolve3, reject) => {
+    const subStep = (p, i, ii) => new Promise((resolve4, reject) => {
       if (ii === pathExt.length)
-        return resolve3(step(i + 1));
+        return resolve4(step(i + 1));
       const ext = pathExt[ii];
       isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
         if (!er && is) {
           if (opt.all)
             found.push(p + ext);
           else
-            return resolve3(p + ext);
+            return resolve4(p + ext);
         }
-        return resolve3(subStep(p, i, ii + 1));
+        return resolve4(subStep(p, i, ii + 1));
       });
     });
     return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
@@ -119560,11 +119560,11 @@ function chooseDescription(descriptions, printWidth) {
   return firstWidth > printWidth && firstWidth > secondWidth ? secondDescription : firstDescription;
 }
 function createSchema(SchemaConstructor, parameters) {
-  const schema10 = new SchemaConstructor(parameters);
-  const subSchema = Object.create(schema10);
+  const schema11 = new SchemaConstructor(parameters);
+  const subSchema = Object.create(schema11);
   for (const handlerKey of HANDLER_KEYS) {
     if (handlerKey in parameters) {
-      subSchema[handlerKey] = normalizeHandler(parameters[handlerKey], schema10, Schema2.prototype[handlerKey].length);
+      subSchema[handlerKey] = normalizeHandler(parameters[handlerKey], schema11, Schema2.prototype[handlerKey].length);
     }
   }
   return subSchema;
@@ -122904,9 +122904,9 @@ function optionInfoToSchema(optionInfo, {
       throw new Error(`Unexpected type ${optionInfo.type}`);
   }
   if (optionInfo.exception) {
-    parameters.validate = (value, schema10, utils3) => optionInfo.exception(value) || schema10.validate(value, utils3);
+    parameters.validate = (value, schema11, utils3) => optionInfo.exception(value) || schema11.validate(value, utils3);
   } else {
-    parameters.validate = (value, schema10, utils3) => value === undefined || schema10.validate(value, utils3);
+    parameters.validate = (value, schema11, utils3) => value === undefined || schema11.validate(value, utils3);
   }
   if (optionInfo.redirect) {
     handlers.redirect = (value) => !value ? undefined : {
@@ -122921,7 +122921,7 @@ function optionInfoToSchema(optionInfo, {
   }
   if (isCLI && !optionInfo.array) {
     const originalPreprocess = parameters.preprocess || ((x10) => x10);
-    parameters.preprocess = (value, schema10, utils3) => schema10.preprocess(originalPreprocess(Array.isArray(value) ? method_at_default2(0, value, -1) : value), utils3);
+    parameters.preprocess = (value, schema11, utils3) => schema11.preprocess(originalPreprocess(Array.isArray(value) ? method_at_default2(0, value, -1) : value), utils3);
   }
   return optionInfo.array ? ArraySchema.create({
     ...isCLI ? {
@@ -124498,9 +124498,9 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc,
     };
     applyNormalization();
     for (const key2 of Object.keys(this._utils.schemas)) {
-      const schema10 = this._utils.schemas[key2];
+      const schema11 = this._utils.schemas[key2];
       if (!(key2 in newOptions)) {
-        const defaultResult = normalizeDefaultResult(schema10.default(this._utils));
+        const defaultResult = normalizeDefaultResult(schema11.default(this._utils));
         if ("value" in defaultResult) {
           restOptionsArray.push({ [key2]: defaultResult.value });
         }
@@ -124511,13 +124511,13 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc,
       if (!(key2 in newOptions)) {
         continue;
       }
-      const schema10 = this._utils.schemas[key2];
+      const schema11 = this._utils.schemas[key2];
       const value = newOptions[key2];
-      const newValue = schema10.postprocess(value, this._utils);
+      const newValue = schema11.postprocess(value, this._utils);
       if (newValue === VALUE_UNCHANGED) {
         continue;
       }
-      this._applyValidation(newValue, key2, schema10);
+      this._applyValidation(newValue, key2, schema11);
       newOptions[key2] = newValue;
     }
     this._applyPostprocess(newOptions);
@@ -124528,14 +124528,14 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc,
     const transferredOptionsArray = [];
     const { knownKeys, unknownKeys } = this._partitionOptionKeys(options8);
     for (const key2 of knownKeys) {
-      const schema10 = this._utils.schemas[key2];
-      const value = schema10.preprocess(options8[key2], this._utils);
-      this._applyValidation(value, key2, schema10);
+      const schema11 = this._utils.schemas[key2];
+      const value = schema11.preprocess(options8[key2], this._utils);
+      this._applyValidation(value, key2, schema11);
       const appendTransferredOptions = ({ from, to: to5 }) => {
         transferredOptionsArray.push(typeof to5 === "string" ? { [to5]: from } : { [to5.key]: to5.value });
       };
       const warnDeprecated = ({ value: currentValue, redirectTo }) => {
-        const deprecatedResult = normalizeDeprecatedResult(schema10.deprecated(currentValue, this._utils), value, true);
+        const deprecatedResult = normalizeDeprecatedResult(schema11.deprecated(currentValue, this._utils), value, true);
         if (deprecatedResult === false) {
           return;
         }
@@ -124553,13 +124553,13 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc,
           }
         }
       };
-      const forwardResult = normalizeForwardResult(schema10.forward(value, this._utils), value);
+      const forwardResult = normalizeForwardResult(schema11.forward(value, this._utils), value);
       forwardResult.forEach(appendTransferredOptions);
-      const redirectResult = normalizeRedirectResult(schema10.redirect(value, this._utils), value);
+      const redirectResult = normalizeRedirectResult(schema11.redirect(value, this._utils), value);
       redirectResult.redirect.forEach(appendTransferredOptions);
       if ("remain" in redirectResult) {
         const remainingValue = redirectResult.remain;
-        newOptions[key2] = key2 in newOptions ? schema10.overlap(newOptions[key2], remainingValue, this._utils) : remainingValue;
+        newOptions[key2] = key2 in newOptions ? schema11.overlap(newOptions[key2], remainingValue, this._utils) : remainingValue;
         warnDeprecated({ value: remainingValue });
       }
       for (const { from, to: to5 } of redirectResult.redirect) {
@@ -124587,8 +124587,8 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc,
     const [knownKeys, unknownKeys] = partition(Object.keys(options8).filter((key2) => !this._identifyMissing(key2, options8)), (key2) => (key2 in this._utils.schemas));
     return { knownKeys, unknownKeys };
   }
-  _applyValidation(value, key2, schema10) {
-    const validateResult = normalizeValidateResult(schema10.validate(value, this._utils), value);
+  _applyValidation(value, key2, schema11) {
+    const validateResult = normalizeValidateResult(schema11.validate(value, this._utils), value);
     if (validateResult !== true) {
       throw this._invalidHandler(key2, validateResult.value, this._utils);
     }
@@ -124630,8 +124630,8 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc,
       for (const key2 of unknownKeys) {
         const value = postprocessed.override[key2];
         this._applyUnknownHandler(key2, value, options8, (knownResultKey, knownResultValue) => {
-          const schema10 = this._utils.schemas[knownResultKey];
-          this._applyValidation(knownResultValue, knownResultKey, schema10);
+          const schema11 = this._utils.schemas[knownResultKey];
+          this._applyValidation(knownResultValue, knownResultKey, schema11);
           options8[knownResultKey] = knownResultValue;
         });
       }
@@ -138269,11 +138269,11 @@ var require_prettier = __commonJS((exports, module) => {
 var require_formatter = __commonJS((exports) => {
   var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P9, generator) {
     function adopt(value) {
-      return value instanceof P9 ? value : new P9(function(resolve12) {
-        resolve12(value);
+      return value instanceof P9 ? value : new P9(function(resolve13) {
+        resolve13(value);
       });
     }
-    return new (P9 || (P9 = Promise))(function(resolve12, reject) {
+    return new (P9 || (P9 = Promise))(function(resolve13, reject) {
       function fulfilled(value) {
         try {
           step(generator.next(value));
@@ -138289,7 +138289,7 @@ var require_formatter = __commonJS((exports) => {
         }
       }
       function step(result) {
-        result.done ? resolve12(result.value) : adopt(result.value).then(fulfilled, rejected);
+        result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
       }
       step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
@@ -138344,23 +138344,23 @@ var require_JSONSchema = __commonJS((exports) => {
   exports.Parent = Symbol("Parent");
   exports.Types = Symbol("Types");
   exports.Intersection = Symbol("Intersection");
-  exports.getRootSchema = (0, lodash_1.memoize)((schema10) => {
-    const parent = schema10[exports.Parent];
+  exports.getRootSchema = (0, lodash_1.memoize)((schema11) => {
+    const parent = schema11[exports.Parent];
     if (!parent) {
-      return schema10;
+      return schema11;
     }
     return (0, exports.getRootSchema)(parent);
   });
-  function isBoolean(schema10) {
-    return schema10 === true || schema10 === false;
+  function isBoolean(schema11) {
+    return schema11 === true || schema11 === false;
   }
   exports.isBoolean = isBoolean;
-  function isPrimitive(schema10) {
-    return !(0, lodash_1.isPlainObject)(schema10);
+  function isPrimitive(schema11) {
+    return !(0, lodash_1.isPlainObject)(schema11);
   }
   exports.isPrimitive = isPrimitive;
-  function isCompound(schema10) {
-    return Array.isArray(schema10.type) || "anyOf" in schema10 || "oneOf" in schema10;
+  function isCompound(schema11) {
+    return Array.isArray(schema11.type) || "anyOf" in schema11 || "oneOf" in schema11;
   }
   exports.isCompound = isCompound;
 });
@@ -138587,9 +138587,9 @@ var require_type2 = __commonJS((exports, module) => {
 var require_schema5 = __commonJS((exports, module) => {
   var YAMLException = require_exception2();
   var Type = require_type2();
-  function compileList(schema10, name2) {
+  function compileList(schema11, name2) {
     var result = [];
-    schema10[name2].forEach(function(currentType) {
+    schema11[name2].forEach(function(currentType) {
       var newIndex = result.length;
       result.forEach(function(previousType, previousIndex) {
         if (previousType.tag === currentType.tag && previousType.kind === currentType.kind && previousType.multi === currentType.multi) {
@@ -140534,7 +140534,7 @@ var require_dumper2 = __commonJS((exports, module) => {
     "OFF"
   ];
   var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;
-  function compileStyleMap(schema10, map2) {
+  function compileStyleMap(schema11, map2) {
     var result, keys, index, length, tag, style, type;
     if (map2 === null)
       return {};
@@ -140546,7 +140546,7 @@ var require_dumper2 = __commonJS((exports, module) => {
       if (tag.slice(0, 2) === "!!") {
         tag = "tag:yaml.org,2002:" + tag.slice(2);
       }
-      type = schema10.compiledTypeMap["fallback"][tag];
+      type = schema11.compiledTypeMap["fallback"][tag];
       if (type && _hasOwnProperty.call(type.styleAliases, style)) {
         style = type.styleAliases[style];
       }
@@ -141205,11 +141205,11 @@ var require_utils7 = __commonJS((exports) => {
   function traverseArray(arr, callback, processed) {
     arr.forEach((s5, k9) => traverse(s5, callback, processed, k9.toString()));
   }
-  function traverseIntersection(schema10, callback, processed) {
-    if (typeof schema10 !== "object" || !schema10) {
+  function traverseIntersection(schema11, callback, processed) {
+    if (typeof schema11 !== "object" || !schema11) {
       return;
     }
-    const r5 = schema10;
+    const r5 = schema11;
     const intersection2 = r5[JSONSchema_1.Intersection];
     if (!intersection2) {
       return;
@@ -141218,60 +141218,60 @@ var require_utils7 = __commonJS((exports) => {
       traverseArray(intersection2.allOf, callback, processed);
     }
   }
-  function traverse(schema10, callback, processed = new Set, key2) {
-    if (processed.has(schema10)) {
+  function traverse(schema11, callback, processed = new Set, key2) {
+    if (processed.has(schema11)) {
       return;
     }
-    processed.add(schema10);
-    callback(schema10, key2 !== null && key2 !== undefined ? key2 : null);
-    if (schema10.anyOf) {
-      traverseArray(schema10.anyOf, callback, processed);
+    processed.add(schema11);
+    callback(schema11, key2 !== null && key2 !== undefined ? key2 : null);
+    if (schema11.anyOf) {
+      traverseArray(schema11.anyOf, callback, processed);
     }
-    if (schema10.allOf) {
-      traverseArray(schema10.allOf, callback, processed);
+    if (schema11.allOf) {
+      traverseArray(schema11.allOf, callback, processed);
     }
-    if (schema10.oneOf) {
-      traverseArray(schema10.oneOf, callback, processed);
+    if (schema11.oneOf) {
+      traverseArray(schema11.oneOf, callback, processed);
     }
-    if (schema10.properties) {
-      traverseObjectKeys(schema10.properties, callback, processed);
+    if (schema11.properties) {
+      traverseObjectKeys(schema11.properties, callback, processed);
     }
-    if (schema10.patternProperties) {
-      traverseObjectKeys(schema10.patternProperties, callback, processed);
+    if (schema11.patternProperties) {
+      traverseObjectKeys(schema11.patternProperties, callback, processed);
     }
-    if (schema10.additionalProperties && typeof schema10.additionalProperties === "object") {
-      traverse(schema10.additionalProperties, callback, processed);
+    if (schema11.additionalProperties && typeof schema11.additionalProperties === "object") {
+      traverse(schema11.additionalProperties, callback, processed);
     }
-    if (schema10.items) {
-      const { items } = schema10;
+    if (schema11.items) {
+      const { items } = schema11;
       if (Array.isArray(items)) {
         traverseArray(items, callback, processed);
       } else {
         traverse(items, callback, processed);
       }
     }
-    if (schema10.additionalItems && typeof schema10.additionalItems === "object") {
-      traverse(schema10.additionalItems, callback, processed);
+    if (schema11.additionalItems && typeof schema11.additionalItems === "object") {
+      traverse(schema11.additionalItems, callback, processed);
     }
-    if (schema10.dependencies) {
-      if (Array.isArray(schema10.dependencies)) {
-        traverseArray(schema10.dependencies, callback, processed);
+    if (schema11.dependencies) {
+      if (Array.isArray(schema11.dependencies)) {
+        traverseArray(schema11.dependencies, callback, processed);
       } else {
-        traverseObjectKeys(schema10.dependencies, callback, processed);
+        traverseObjectKeys(schema11.dependencies, callback, processed);
       }
     }
-    if (schema10.definitions) {
-      traverseObjectKeys(schema10.definitions, callback, processed);
+    if (schema11.definitions) {
+      traverseObjectKeys(schema11.definitions, callback, processed);
     }
-    if (schema10.$defs) {
-      traverseObjectKeys(schema10.$defs, callback, processed);
+    if (schema11.$defs) {
+      traverseObjectKeys(schema11.$defs, callback, processed);
     }
-    if (schema10.not) {
-      traverse(schema10.not, callback, processed);
+    if (schema11.not) {
+      traverse(schema11.not, callback, processed);
     }
-    traverseIntersection(schema10, callback, processed);
-    Object.keys(schema10).filter((key3) => !BLACKLISTED_KEYS.has(key3)).forEach((key3) => {
-      const child = schema10[key3];
+    traverseIntersection(schema11, callback, processed);
+    Object.keys(schema11).filter((key3) => !BLACKLISTED_KEYS.has(key3)).forEach((key3) => {
+      const child = schema11[key3];
       if (child && typeof child === "object") {
         traverseObjectKeys(child, callback, processed);
       }
@@ -141353,14 +141353,14 @@ var require_utils7 = __commonJS((exports) => {
         return (_g2 = color()) === null || _g2 === undefined ? undefined : _g2.whiteBright.bgYellow;
     }
   }
-  function escapeBlockComment(schema10) {
+  function escapeBlockComment(schema11) {
     const replacer = "* /";
-    if (schema10 === null || typeof schema10 !== "object") {
+    if (schema11 === null || typeof schema11 !== "object") {
       return;
     }
-    for (const key2 of Object.keys(schema10)) {
-      if (key2 === "description" && typeof schema10[key2] === "string") {
-        schema10[key2] = schema10[key2].replace(/\*\//g, replacer);
+    for (const key2 of Object.keys(schema11)) {
+      if (key2 === "description" && typeof schema11[key2] === "string") {
+        schema11[key2] = schema11[key2].replace(/\*\//g, replacer);
       }
     }
   }
@@ -141372,45 +141372,45 @@ var require_utils7 = __commonJS((exports) => {
     return path_1.posix.join(path_1.posix.normalize(outputPath), ...filePathRel);
   }
   exports.pathTransform = pathTransform;
-  function maybeStripDefault(schema10) {
-    if (!("default" in schema10)) {
-      return schema10;
+  function maybeStripDefault(schema11) {
+    if (!("default" in schema11)) {
+      return schema11;
     }
-    switch (schema10.type) {
+    switch (schema11.type) {
       case "array":
-        if (Array.isArray(schema10.default)) {
-          return schema10;
+        if (Array.isArray(schema11.default)) {
+          return schema11;
         }
         break;
       case "boolean":
-        if (typeof schema10.default === "boolean") {
-          return schema10;
+        if (typeof schema11.default === "boolean") {
+          return schema11;
         }
         break;
       case "integer":
       case "number":
-        if (typeof schema10.default === "number") {
-          return schema10;
+        if (typeof schema11.default === "number") {
+          return schema11;
         }
         break;
       case "string":
-        if (typeof schema10.default === "string") {
-          return schema10;
+        if (typeof schema11.default === "string") {
+          return schema11;
         }
         break;
       case "null":
-        if (schema10.default === null) {
-          return schema10;
+        if (schema11.default === null) {
+          return schema11;
         }
         break;
       case "object":
-        if ((0, lodash_1.isPlainObject)(schema10.default)) {
-          return schema10;
+        if ((0, lodash_1.isPlainObject)(schema11.default)) {
+          return schema11;
         }
         break;
     }
-    delete schema10.default;
-    return schema10;
+    delete schema11.default;
+    return schema11;
   }
   exports.maybeStripDefault = maybeStripDefault;
   function appendToDescription(existingDescription, ...values) {
@@ -141424,11 +141424,11 @@ ${values.join(`
 `);
   }
   exports.appendToDescription = appendToDescription;
-  function isSchemaLike(schema10) {
-    if (!(0, lodash_1.isPlainObject)(schema10)) {
+  function isSchemaLike(schema11) {
+    if (!(0, lodash_1.isPlainObject)(schema11)) {
       return false;
     }
-    const parent = schema10[JSONSchema_1.Parent];
+    const parent = schema11[JSONSchema_1.Parent];
     if (parent === null) {
       return true;
     }
@@ -141445,7 +141445,7 @@ ${values.join(`
       "properties",
       "required"
     ];
-    if (JSON_SCHEMA_KEYWORDS.some((_10) => parent[_10] === schema10)) {
+    if (JSON_SCHEMA_KEYWORDS.some((_10) => parent[_10] === schema11)) {
       return false;
     }
     return true;
@@ -141743,13 +141743,13 @@ var require_typesOfSchema = __commonJS((exports) => {
   exports.typesOfSchema = undefined;
   var lodash_1 = require_lodash8();
   var JSONSchema_1 = require_JSONSchema();
-  function typesOfSchema(schema10) {
-    if (schema10.tsType) {
+  function typesOfSchema(schema11) {
+    if (schema11.tsType) {
       return new Set(["CUSTOM_TYPE"]);
     }
     const matchedTypes = new Set;
     for (const [schemaType, f7] of Object.entries(matchers)) {
-      if (f7(schema10)) {
+      if (f7(schema11)) {
         matchedTypes.add(schemaType);
       }
     }
@@ -141760,26 +141760,26 @@ var require_typesOfSchema = __commonJS((exports) => {
   }
   exports.typesOfSchema = typesOfSchema;
   var matchers = {
-    ALL_OF(schema10) {
-      return "allOf" in schema10;
+    ALL_OF(schema11) {
+      return "allOf" in schema11;
     },
-    ANY(schema10) {
-      if (Object.keys(schema10).length === 0) {
+    ANY(schema11) {
+      if (Object.keys(schema11).length === 0) {
         return true;
       }
-      return schema10.type === "any";
+      return schema11.type === "any";
     },
-    ANY_OF(schema10) {
-      return "anyOf" in schema10;
+    ANY_OF(schema11) {
+      return "anyOf" in schema11;
     },
-    BOOLEAN(schema10) {
-      if ("enum" in schema10) {
+    BOOLEAN(schema11) {
+      if ("enum" in schema11) {
         return false;
       }
-      if (schema10.type === "boolean") {
+      if (schema11.type === "boolean") {
         return true;
       }
-      if (!(0, JSONSchema_1.isCompound)(schema10) && typeof schema10.default === "boolean") {
+      if (!(0, JSONSchema_1.isCompound)(schema11) && typeof schema11.default === "boolean") {
         return true;
       }
       return false;
@@ -141787,74 +141787,74 @@ var require_typesOfSchema = __commonJS((exports) => {
     CUSTOM_TYPE() {
       return false;
     },
-    NAMED_ENUM(schema10) {
-      return "enum" in schema10 && "tsEnumNames" in schema10;
+    NAMED_ENUM(schema11) {
+      return "enum" in schema11 && "tsEnumNames" in schema11;
     },
-    NAMED_SCHEMA(schema10) {
-      return "$id" in schema10 && (("patternProperties" in schema10) || ("properties" in schema10));
+    NAMED_SCHEMA(schema11) {
+      return "$id" in schema11 && (("patternProperties" in schema11) || ("properties" in schema11));
     },
-    NEVER(schema10) {
-      return schema10 === false;
+    NEVER(schema11) {
+      return schema11 === false;
     },
-    NULL(schema10) {
-      return schema10.type === "null";
+    NULL(schema11) {
+      return schema11.type === "null";
     },
-    NUMBER(schema10) {
-      if ("enum" in schema10) {
+    NUMBER(schema11) {
+      if ("enum" in schema11) {
         return false;
       }
-      if (schema10.type === "integer" || schema10.type === "number") {
+      if (schema11.type === "integer" || schema11.type === "number") {
         return true;
       }
-      if (!(0, JSONSchema_1.isCompound)(schema10) && typeof schema10.default === "number") {
+      if (!(0, JSONSchema_1.isCompound)(schema11) && typeof schema11.default === "number") {
         return true;
       }
       return false;
     },
-    OBJECT(schema10) {
-      return schema10.type === "object" && !(0, lodash_1.isPlainObject)(schema10.additionalProperties) && !schema10.allOf && !schema10.anyOf && !schema10.oneOf && !schema10.patternProperties && !schema10.properties && !schema10.required;
+    OBJECT(schema11) {
+      return schema11.type === "object" && !(0, lodash_1.isPlainObject)(schema11.additionalProperties) && !schema11.allOf && !schema11.anyOf && !schema11.oneOf && !schema11.patternProperties && !schema11.properties && !schema11.required;
     },
-    ONE_OF(schema10) {
-      return "oneOf" in schema10;
+    ONE_OF(schema11) {
+      return "oneOf" in schema11;
     },
-    REFERENCE(schema10) {
-      return "$ref" in schema10;
+    REFERENCE(schema11) {
+      return "$ref" in schema11;
     },
-    STRING(schema10) {
-      if ("enum" in schema10) {
+    STRING(schema11) {
+      if ("enum" in schema11) {
         return false;
       }
-      if (schema10.type === "string") {
+      if (schema11.type === "string") {
         return true;
       }
-      if (!(0, JSONSchema_1.isCompound)(schema10) && typeof schema10.default === "string") {
+      if (!(0, JSONSchema_1.isCompound)(schema11) && typeof schema11.default === "string") {
         return true;
       }
       return false;
     },
-    TYPED_ARRAY(schema10) {
-      if (schema10.type && schema10.type !== "array") {
+    TYPED_ARRAY(schema11) {
+      if (schema11.type && schema11.type !== "array") {
         return false;
       }
-      return "items" in schema10;
+      return "items" in schema11;
     },
-    UNION(schema10) {
-      return Array.isArray(schema10.type);
+    UNION(schema11) {
+      return Array.isArray(schema11.type);
     },
-    UNNAMED_ENUM(schema10) {
-      if ("tsEnumNames" in schema10) {
+    UNNAMED_ENUM(schema11) {
+      if ("tsEnumNames" in schema11) {
         return false;
       }
-      if (schema10.type && schema10.type !== "boolean" && schema10.type !== "integer" && schema10.type !== "number" && schema10.type !== "string") {
+      if (schema11.type && schema11.type !== "boolean" && schema11.type !== "integer" && schema11.type !== "number" && schema11.type !== "string") {
         return false;
       }
-      return "enum" in schema10;
+      return "enum" in schema11;
     },
     UNNAMED_SCHEMA() {
       return false;
     },
-    UNTYPED_ARRAY(schema10) {
-      return schema10.type === "array" && !("items" in schema10);
+    UNTYPED_ARRAY(schema11) {
+      return schema11.type === "array" && !("items" in schema11);
     }
   };
 });
@@ -141865,10 +141865,10 @@ var require_applySchemaTyping = __commonJS((exports) => {
   exports.applySchemaTyping = undefined;
   var JSONSchema_1 = require_JSONSchema();
   var typesOfSchema_1 = require_typesOfSchema();
-  function applySchemaTyping(schema10) {
+  function applySchemaTyping(schema11) {
     var _a7;
-    const types = (0, typesOfSchema_1.typesOfSchema)(schema10);
-    Object.defineProperty(schema10, JSONSchema_1.Types, {
+    const types = (0, typesOfSchema_1.typesOfSchema)(schema11);
+    Object.defineProperty(schema11, JSONSchema_1.Types, {
       enumerable: false,
       value: types,
       writable: false
@@ -141877,23 +141877,23 @@ var require_applySchemaTyping = __commonJS((exports) => {
       return;
     }
     const intersection2 = {
-      [JSONSchema_1.Parent]: schema10,
+      [JSONSchema_1.Parent]: schema11,
       [JSONSchema_1.Types]: new Set(["ALL_OF"]),
-      $id: schema10.$id,
-      description: schema10.description,
-      name: schema10.name,
-      title: schema10.title,
-      allOf: (_a7 = schema10.allOf) !== null && _a7 !== undefined ? _a7 : [],
+      $id: schema11.$id,
+      description: schema11.description,
+      name: schema11.name,
+      title: schema11.title,
+      allOf: (_a7 = schema11.allOf) !== null && _a7 !== undefined ? _a7 : [],
       required: [],
       additionalProperties: false
     };
     types.delete("ALL_OF");
-    delete schema10.allOf;
-    delete schema10.$id;
-    delete schema10.description;
-    delete schema10.name;
-    delete schema10.title;
-    Object.defineProperty(schema10, JSONSchema_1.Intersection, {
+    delete schema11.allOf;
+    delete schema11.$id;
+    delete schema11.description;
+    delete schema11.name;
+    delete schema11.title;
+    Object.defineProperty(schema11, JSONSchema_1.Intersection, {
       enumerable: false,
       value: intersection2,
       writable: false
@@ -141911,186 +141911,186 @@ var require_normalizer = __commonJS((exports) => {
   var applySchemaTyping_1 = require_applySchemaTyping();
   var util_1 = __require("util");
   var rules = new Map;
-  function hasType(schema10, type) {
-    return schema10.type === type || Array.isArray(schema10.type) && schema10.type.includes(type);
+  function hasType(schema11, type) {
+    return schema11.type === type || Array.isArray(schema11.type) && schema11.type.includes(type);
   }
-  function isObjectType(schema10) {
-    return schema10.properties !== undefined || hasType(schema10, "object") || hasType(schema10, "any");
+  function isObjectType(schema11) {
+    return schema11.properties !== undefined || hasType(schema11, "object") || hasType(schema11, "any");
   }
-  function isArrayType(schema10) {
-    return schema10.items !== undefined || hasType(schema10, "array") || hasType(schema10, "any");
+  function isArrayType(schema11) {
+    return schema11.items !== undefined || hasType(schema11, "array") || hasType(schema11, "any");
   }
-  function isEnumTypeWithoutTsEnumNames(schema10) {
-    return schema10.type === "string" && schema10.enum !== undefined && schema10.tsEnumNames === undefined;
+  function isEnumTypeWithoutTsEnumNames(schema11) {
+    return schema11.type === "string" && schema11.enum !== undefined && schema11.tsEnumNames === undefined;
   }
-  rules.set('Remove `type=["null"]` if `enum=[null]`', (schema10) => {
-    if (Array.isArray(schema10.enum) && schema10.enum.some((e8) => e8 === null) && Array.isArray(schema10.type) && schema10.type.includes("null")) {
-      schema10.type = schema10.type.filter((type) => type !== "null");
+  rules.set('Remove `type=["null"]` if `enum=[null]`', (schema11) => {
+    if (Array.isArray(schema11.enum) && schema11.enum.some((e8) => e8 === null) && Array.isArray(schema11.type) && schema11.type.includes("null")) {
+      schema11.type = schema11.type.filter((type) => type !== "null");
     }
   });
-  rules.set("Destructure unary types", (schema10) => {
-    if (schema10.type && Array.isArray(schema10.type) && schema10.type.length === 1) {
-      schema10.type = schema10.type[0];
+  rules.set("Destructure unary types", (schema11) => {
+    if (schema11.type && Array.isArray(schema11.type) && schema11.type.length === 1) {
+      schema11.type = schema11.type[0];
     }
   });
-  rules.set("Add empty `required` property if none is defined", (schema10) => {
-    if (isObjectType(schema10) && !("required" in schema10)) {
-      schema10.required = [];
+  rules.set("Add empty `required` property if none is defined", (schema11) => {
+    if (isObjectType(schema11) && !("required" in schema11)) {
+      schema11.required = [];
     }
   });
-  rules.set("Transform `required`=false to `required`=[]", (schema10) => {
-    if (schema10.required === false) {
-      schema10.required = [];
+  rules.set("Transform `required`=false to `required`=[]", (schema11) => {
+    if (schema11.required === false) {
+      schema11.required = [];
     }
   });
-  rules.set("Default additionalProperties", (schema10, _10, options8) => {
-    if (isObjectType(schema10) && !("additionalProperties" in schema10) && schema10.patternProperties === undefined) {
-      schema10.additionalProperties = options8.additionalProperties;
+  rules.set("Default additionalProperties", (schema11, _10, options8) => {
+    if (isObjectType(schema11) && !("additionalProperties" in schema11) && schema11.patternProperties === undefined) {
+      schema11.additionalProperties = options8.additionalProperties;
     }
   });
-  rules.set("Transform id to $id", (schema10, fileName) => {
-    if (!(0, utils_1.isSchemaLike)(schema10)) {
+  rules.set("Transform id to $id", (schema11, fileName) => {
+    if (!(0, utils_1.isSchemaLike)(schema11)) {
       return;
     }
-    if (schema10.id && schema10.$id && schema10.id !== schema10.$id) {
-      throw ReferenceError(`Schema must define either id or $id, not both. Given id=${schema10.id}, $id=${schema10.$id} in ${fileName}`);
+    if (schema11.id && schema11.$id && schema11.id !== schema11.$id) {
+      throw ReferenceError(`Schema must define either id or $id, not both. Given id=${schema11.id}, $id=${schema11.$id} in ${fileName}`);
     }
-    if (schema10.id) {
-      schema10.$id = schema10.id;
-      delete schema10.id;
+    if (schema11.id) {
+      schema11.$id = schema11.id;
+      delete schema11.id;
     }
   });
-  rules.set("Add an $id to anything that needs it", (schema10, fileName, _options, _key, dereferencedPaths) => {
-    if (!(0, utils_1.isSchemaLike)(schema10)) {
+  rules.set("Add an $id to anything that needs it", (schema11, fileName, _options, _key, dereferencedPaths) => {
+    if (!(0, utils_1.isSchemaLike)(schema11)) {
       return;
     }
-    if (!schema10.$id && !schema10[JSONSchema_1.Parent]) {
-      schema10.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(fileName));
+    if (!schema11.$id && !schema11[JSONSchema_1.Parent]) {
+      schema11.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(fileName));
       return;
     }
-    if (!isArrayType(schema10) && !isObjectType(schema10)) {
+    if (!isArrayType(schema11) && !isObjectType(schema11)) {
       return;
     }
-    const dereferencedName = dereferencedPaths.get(schema10);
-    if (!schema10.$id && !schema10.title && dereferencedName) {
-      schema10.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(dereferencedName));
+    const dereferencedName = dereferencedPaths.get(schema11);
+    if (!schema11.$id && !schema11.title && dereferencedName) {
+      schema11.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(dereferencedName));
     }
     if (dereferencedName) {
-      dereferencedPaths.delete(schema10);
+      dereferencedPaths.delete(schema11);
     }
   });
-  rules.set("Escape closing JSDoc comment", (schema10) => {
-    (0, utils_1.escapeBlockComment)(schema10);
+  rules.set("Escape closing JSDoc comment", (schema11) => {
+    (0, utils_1.escapeBlockComment)(schema11);
   });
-  rules.set("Add JSDoc comments for minItems and maxItems", (schema10) => {
-    if (!isArrayType(schema10)) {
+  rules.set("Add JSDoc comments for minItems and maxItems", (schema11) => {
+    if (!isArrayType(schema11)) {
       return;
     }
     const commentsToAppend = [
-      "minItems" in schema10 ? `@minItems ${schema10.minItems}` : "",
-      "maxItems" in schema10 ? `@maxItems ${schema10.maxItems}` : ""
+      "minItems" in schema11 ? `@minItems ${schema11.minItems}` : "",
+      "maxItems" in schema11 ? `@maxItems ${schema11.maxItems}` : ""
     ].filter(Boolean);
     if (commentsToAppend.length) {
-      schema10.description = (0, utils_1.appendToDescription)(schema10.description, ...commentsToAppend);
+      schema11.description = (0, utils_1.appendToDescription)(schema11.description, ...commentsToAppend);
     }
   });
-  rules.set("Optionally remove maxItems and minItems", (schema10, _fileName, options8) => {
-    if (!isArrayType(schema10)) {
+  rules.set("Optionally remove maxItems and minItems", (schema11, _fileName, options8) => {
+    if (!isArrayType(schema11)) {
       return;
     }
-    if ("minItems" in schema10 && options8.ignoreMinAndMaxItems) {
-      delete schema10.minItems;
+    if ("minItems" in schema11 && options8.ignoreMinAndMaxItems) {
+      delete schema11.minItems;
     }
-    if ("maxItems" in schema10 && (options8.ignoreMinAndMaxItems || options8.maxItems === -1)) {
-      delete schema10.maxItems;
+    if ("maxItems" in schema11 && (options8.ignoreMinAndMaxItems || options8.maxItems === -1)) {
+      delete schema11.maxItems;
     }
   });
-  rules.set("Normalize schema.minItems", (schema10, _fileName, options8) => {
+  rules.set("Normalize schema.minItems", (schema11, _fileName, options8) => {
     if (options8.ignoreMinAndMaxItems) {
       return;
     }
-    if (!isArrayType(schema10)) {
+    if (!isArrayType(schema11)) {
       return;
     }
-    const { minItems } = schema10;
-    schema10.minItems = typeof minItems === "number" ? minItems : 0;
+    const { minItems } = schema11;
+    schema11.minItems = typeof minItems === "number" ? minItems : 0;
   });
-  rules.set("Remove maxItems if it is big enough to likely cause OOMs", (schema10, _fileName, options8) => {
+  rules.set("Remove maxItems if it is big enough to likely cause OOMs", (schema11, _fileName, options8) => {
     if (options8.ignoreMinAndMaxItems || options8.maxItems === -1) {
       return;
     }
-    if (!isArrayType(schema10)) {
+    if (!isArrayType(schema11)) {
       return;
     }
-    const { maxItems, minItems } = schema10;
+    const { maxItems, minItems } = schema11;
     if (maxItems !== undefined && maxItems - minItems > options8.maxItems) {
-      delete schema10.maxItems;
+      delete schema11.maxItems;
     }
   });
-  rules.set("Normalize schema.items", (schema10, _fileName, options8) => {
+  rules.set("Normalize schema.items", (schema11, _fileName, options8) => {
     if (options8.ignoreMinAndMaxItems) {
       return;
     }
-    const { maxItems, minItems } = schema10;
+    const { maxItems, minItems } = schema11;
     const hasMaxItems = typeof maxItems === "number" && maxItems >= 0;
     const hasMinItems = typeof minItems === "number" && minItems > 0;
-    if (schema10.items && !Array.isArray(schema10.items) && (hasMaxItems || hasMinItems)) {
-      const items = schema10.items;
+    if (schema11.items && !Array.isArray(schema11.items) && (hasMaxItems || hasMinItems)) {
+      const items = schema11.items;
       const newItems = Array(maxItems || minItems || 0).fill(items);
       if (!hasMaxItems) {
-        schema10.additionalItems = items;
+        schema11.additionalItems = items;
       }
-      schema10.items = newItems;
+      schema11.items = newItems;
     }
-    if (Array.isArray(schema10.items) && hasMaxItems && maxItems < schema10.items.length) {
-      schema10.items = schema10.items.slice(0, maxItems);
+    if (Array.isArray(schema11.items) && hasMaxItems && maxItems < schema11.items.length) {
+      schema11.items = schema11.items.slice(0, maxItems);
     }
-    return schema10;
+    return schema11;
   });
-  rules.set("Remove extends, if it is empty", (schema10) => {
-    if (!schema10.hasOwnProperty("extends")) {
+  rules.set("Remove extends, if it is empty", (schema11) => {
+    if (!schema11.hasOwnProperty("extends")) {
       return;
     }
-    if (schema10.extends == null || Array.isArray(schema10.extends) && schema10.extends.length === 0) {
-      delete schema10.extends;
+    if (schema11.extends == null || Array.isArray(schema11.extends) && schema11.extends.length === 0) {
+      delete schema11.extends;
     }
   });
-  rules.set("Make extends always an array, if it is defined", (schema10) => {
-    if (schema10.extends == null) {
+  rules.set("Make extends always an array, if it is defined", (schema11) => {
+    if (schema11.extends == null) {
       return;
     }
-    if (!Array.isArray(schema10.extends)) {
-      schema10.extends = [schema10.extends];
+    if (!Array.isArray(schema11.extends)) {
+      schema11.extends = [schema11.extends];
     }
   });
-  rules.set("Transform definitions to $defs", (schema10, fileName) => {
-    if (schema10.definitions && schema10.$defs && !(0, util_1.isDeepStrictEqual)(schema10.definitions, schema10.$defs)) {
-      throw ReferenceError(`Schema must define either definitions or $defs, not both. Given id=${schema10.id} in ${fileName}`);
+  rules.set("Transform definitions to $defs", (schema11, fileName) => {
+    if (schema11.definitions && schema11.$defs && !(0, util_1.isDeepStrictEqual)(schema11.definitions, schema11.$defs)) {
+      throw ReferenceError(`Schema must define either definitions or $defs, not both. Given id=${schema11.id} in ${fileName}`);
     }
-    if (schema10.definitions) {
-      schema10.$defs = schema10.definitions;
-      delete schema10.definitions;
+    if (schema11.definitions) {
+      schema11.$defs = schema11.definitions;
+      delete schema11.definitions;
     }
   });
-  rules.set("Transform const to singleton enum", (schema10) => {
-    if (schema10.const !== undefined) {
-      schema10.enum = [schema10.const];
-      delete schema10.const;
+  rules.set("Transform const to singleton enum", (schema11) => {
+    if (schema11.const !== undefined) {
+      schema11.enum = [schema11.const];
+      delete schema11.const;
     }
   });
-  rules.set("Add tsEnumNames to enum types", (schema10, _10, options8) => {
+  rules.set("Add tsEnumNames to enum types", (schema11, _10, options8) => {
     var _a7;
-    if (isEnumTypeWithoutTsEnumNames(schema10) && options8.inferStringEnumKeysFromValues) {
-      schema10.tsEnumNames = (_a7 = schema10.enum) === null || _a7 === undefined ? undefined : _a7.map(String);
+    if (isEnumTypeWithoutTsEnumNames(schema11) && options8.inferStringEnumKeysFromValues) {
+      schema11.tsEnumNames = (_a7 = schema11.enum) === null || _a7 === undefined ? undefined : _a7.map(String);
     }
   });
-  rules.set("Pre-calculate schema types and intersections", (schema10) => {
-    if (schema10 !== null && typeof schema10 === "object") {
-      (0, applySchemaTyping_1.applySchemaTyping)(schema10);
+  rules.set("Pre-calculate schema types and intersections", (schema11) => {
+    if (schema11 !== null && typeof schema11 === "object") {
+      (0, applySchemaTyping_1.applySchemaTyping)(schema11);
     }
   });
   function normalize2(rootSchema, dereferencedPaths, filename, options8) {
-    rules.forEach((rule) => (0, utils_1.traverse)(rootSchema, (schema10, key2) => rule(schema10, filename, options8, key2, dereferencedPaths)));
+    rules.forEach((rule) => (0, utils_1.traverse)(rootSchema, (schema11, key2) => rule(schema11, filename, options8, key2, dereferencedPaths)));
     return rootSchema;
   }
   exports.normalize = normalize2;
@@ -142172,37 +142172,37 @@ var require_parser2 = __commonJS((exports) => {
   var AST_1 = require_AST();
   var JSONSchema_1 = require_JSONSchema();
   var utils_1 = require_utils7();
-  function parse11(schema10, options8, keyName, processed = new Map, usedNames = new Set) {
-    if ((0, JSONSchema_1.isPrimitive)(schema10)) {
-      if ((0, JSONSchema_1.isBoolean)(schema10)) {
-        return parseBooleanSchema(schema10, keyName, options8);
+  function parse11(schema11, options8, keyName, processed = new Map, usedNames = new Set) {
+    if ((0, JSONSchema_1.isPrimitive)(schema11)) {
+      if ((0, JSONSchema_1.isBoolean)(schema11)) {
+        return parseBooleanSchema(schema11, keyName, options8);
       }
-      return parseLiteral(schema10, keyName);
+      return parseLiteral(schema11, keyName);
     }
-    const intersection2 = schema10[JSONSchema_1.Intersection];
-    const types = schema10[JSONSchema_1.Types];
+    const intersection2 = schema11[JSONSchema_1.Intersection];
+    const types = schema11[JSONSchema_1.Types];
     if (intersection2) {
       const ast = parseAsTypeWithCache(intersection2, "ALL_OF", options8, keyName, processed, usedNames);
       types.forEach((type) => {
-        ast.params.push(parseAsTypeWithCache(schema10, type, options8, keyName, processed, usedNames));
+        ast.params.push(parseAsTypeWithCache(schema11, type, options8, keyName, processed, usedNames));
       });
-      (0, utils_1.log)("blue", "parser", "Types:", [...types], "Input:", schema10, "Output:", ast);
+      (0, utils_1.log)("blue", "parser", "Types:", [...types], "Input:", schema11, "Output:", ast);
       return ast;
     }
     if (types.size === 1) {
       const type = [...types][0];
-      const ast = parseAsTypeWithCache(schema10, type, options8, keyName, processed, usedNames);
-      (0, utils_1.log)("blue", "parser", "Type:", type, "Input:", schema10, "Output:", ast);
+      const ast = parseAsTypeWithCache(schema11, type, options8, keyName, processed, usedNames);
+      (0, utils_1.log)("blue", "parser", "Type:", type, "Input:", schema11, "Output:", ast);
       return ast;
     }
     throw new ReferenceError("Expected intersection schema. Please file an issue on GitHub.");
   }
   exports.parse = parse11;
-  function parseAsTypeWithCache(schema10, type, options8, keyName, processed = new Map, usedNames = new Set) {
-    let cachedTypeMap = processed.get(schema10);
+  function parseAsTypeWithCache(schema11, type, options8, keyName, processed = new Map, usedNames = new Set) {
+    let cachedTypeMap = processed.get(schema11);
     if (!cachedTypeMap) {
       cachedTypeMap = new Map;
-      processed.set(schema10, cachedTypeMap);
+      processed.set(schema11, cachedTypeMap);
     }
     const cachedAST = cachedTypeMap.get(type);
     if (cachedAST) {
@@ -142210,10 +142210,10 @@ var require_parser2 = __commonJS((exports) => {
     }
     const ast = {};
     cachedTypeMap.set(type, ast);
-    return Object.assign(ast, parseNonLiteral(schema10, type, options8, keyName, processed, usedNames));
+    return Object.assign(ast, parseNonLiteral(schema11, type, options8, keyName, processed, usedNames));
   }
-  function parseBooleanSchema(schema10, keyName, options8) {
-    if (schema10) {
+  function parseBooleanSchema(schema11, keyName, options8) {
+    if (schema11) {
       return {
         keyName,
         type: options8.unknownAny ? "UNKNOWN" : "ANY"
@@ -142224,157 +142224,157 @@ var require_parser2 = __commonJS((exports) => {
       type: "NEVER"
     };
   }
-  function parseLiteral(schema10, keyName) {
+  function parseLiteral(schema11, keyName) {
     return {
       keyName,
-      params: schema10,
+      params: schema11,
       type: "LITERAL"
     };
   }
-  function parseNonLiteral(schema10, type, options8, keyName, processed, usedNames) {
-    const definitions = getDefinitionsMemoized((0, JSONSchema_1.getRootSchema)(schema10));
-    const keyNameFromDefinition = (0, lodash_1.findKey)(definitions, (_10) => _10 === schema10);
+  function parseNonLiteral(schema11, type, options8, keyName, processed, usedNames) {
+    const definitions = getDefinitionsMemoized((0, JSONSchema_1.getRootSchema)(schema11));
+    const keyNameFromDefinition = (0, lodash_1.findKey)(definitions, (_10) => _10 === schema11);
     switch (type) {
       case "ALL_OF":
         return {
-          comment: schema10.description,
-          deprecated: schema10.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
-          params: schema10.allOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
+          params: schema11.allOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
           type: "INTERSECTION"
         };
       case "ANY":
-        return Object.assign(Object.assign({}, options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY), { comment: schema10.description, deprecated: schema10.deprecated, keyName, standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8) });
+        return Object.assign(Object.assign({}, options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY), { comment: schema11.description, deprecated: schema11.deprecated, keyName, standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8) });
       case "ANY_OF":
         return {
-          comment: schema10.description,
-          deprecated: schema10.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
-          params: schema10.anyOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
+          params: schema11.anyOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
           type: "UNION"
         };
       case "BOOLEAN":
         return {
-          comment: schema10.description,
-          deprecated: schema10.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
           type: "BOOLEAN"
         };
       case "CUSTOM_TYPE":
         return {
-          comment: schema10.description,
-          deprecated: schema10.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          params: schema10.tsType,
-          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
+          params: schema11.tsType,
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
           type: "CUSTOM_TYPE"
         };
       case "NAMED_ENUM":
         return {
-          comment: schema10.description,
-          deprecated: schema10.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema10, keyNameFromDefinition !== null && keyNameFromDefinition !== undefined ? keyNameFromDefinition : keyName, usedNames, options8),
-          params: schema10.enum.map((_10, n5) => ({
+          standaloneName: standaloneName(schema11, keyNameFromDefinition !== null && keyNameFromDefinition !== undefined ? keyNameFromDefinition : keyName, usedNames, options8),
+          params: schema11.enum.map((_10, n5) => ({
             ast: parseLiteral(_10, undefined),
-            keyName: schema10.tsEnumNames[n5]
+            keyName: schema11.tsEnumNames[n5]
           })),
           type: "ENUM"
         };
       case "NAMED_SCHEMA":
-        return newInterface(schema10, options8, processed, usedNames, keyName);
+        return newInterface(schema11, options8, processed, usedNames, keyName);
       case "NEVER":
         return {
-          comment: schema10.description,
-          deprecated: schema10.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
           type: "NEVER"
         };
       case "NULL":
         return {
-          comment: schema10.description,
-          deprecated: schema10.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
           type: "NULL"
         };
       case "NUMBER":
         return {
-          comment: schema10.description,
-          deprecated: schema10.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
           type: "NUMBER"
         };
       case "OBJECT":
         return {
-          comment: schema10.description,
+          comment: schema11.description,
           keyName,
-          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
           type: "OBJECT",
-          deprecated: schema10.deprecated
+          deprecated: schema11.deprecated
         };
       case "ONE_OF":
         return {
-          comment: schema10.description,
-          deprecated: schema10.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
-          params: schema10.oneOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
+          params: schema11.oneOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
           type: "UNION"
         };
       case "REFERENCE":
-        throw Error((0, util_1.format)("Refs should have been resolved by the resolver!", schema10));
+        throw Error((0, util_1.format)("Refs should have been resolved by the resolver!", schema11));
       case "STRING":
         return {
-          comment: schema10.description,
-          deprecated: schema10.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
           type: "STRING"
         };
       case "TYPED_ARRAY":
-        if (Array.isArray(schema10.items)) {
-          const minItems2 = schema10.minItems;
-          const maxItems2 = schema10.maxItems;
+        if (Array.isArray(schema11.items)) {
+          const minItems2 = schema11.minItems;
+          const maxItems2 = schema11.maxItems;
           const arrayType = {
-            comment: schema10.description,
-            deprecated: schema10.deprecated,
+            comment: schema11.description,
+            deprecated: schema11.deprecated,
             keyName,
             maxItems: maxItems2,
             minItems: minItems2,
-            standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
-            params: schema10.items.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
+            standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
+            params: schema11.items.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
             type: "TUPLE"
           };
-          if (schema10.additionalItems === true) {
+          if (schema11.additionalItems === true) {
             arrayType.spreadParam = options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY;
-          } else if (schema10.additionalItems) {
-            arrayType.spreadParam = parse11(schema10.additionalItems, options8, undefined, processed, usedNames);
+          } else if (schema11.additionalItems) {
+            arrayType.spreadParam = parse11(schema11.additionalItems, options8, undefined, processed, usedNames);
           }
           return arrayType;
         } else {
           return {
-            comment: schema10.description,
-            deprecated: schema10.deprecated,
+            comment: schema11.description,
+            deprecated: schema11.deprecated,
             keyName,
-            standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
-            params: parse11(schema10.items, options8, `{keyNameFromDefinition}Items`, processed, usedNames),
+            standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
+            params: parse11(schema11.items, options8, `{keyNameFromDefinition}Items`, processed, usedNames),
             type: "ARRAY"
           };
         }
       case "UNION":
         return {
-          comment: schema10.description,
-          deprecated: schema10.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
-          params: schema10.type.map((type2) => {
-            const member = Object.assign(Object.assign({}, (0, lodash_1.omit)(schema10, "$id", "description", "title")), { type: type2 });
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
+          params: schema11.type.map((type2) => {
+            const member = Object.assign(Object.assign({}, (0, lodash_1.omit)(schema11, "$id", "description", "title")), { type: type2 });
             (0, utils_1.maybeStripDefault)(member);
             (0, applySchemaTyping_1.applySchemaTyping)(member);
             return parse11(member, options8, undefined, processed, usedNames);
@@ -142383,80 +142383,80 @@ var require_parser2 = __commonJS((exports) => {
         };
       case "UNNAMED_ENUM":
         return {
-          comment: schema10.description,
-          deprecated: schema10.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
-          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
-          params: schema10.enum.map((_10) => parseLiteral(_10, undefined)),
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
+          params: schema11.enum.map((_10) => parseLiteral(_10, undefined)),
           type: "UNION"
         };
       case "UNNAMED_SCHEMA":
-        return newInterface(schema10, options8, processed, usedNames, keyName, keyNameFromDefinition);
+        return newInterface(schema11, options8, processed, usedNames, keyName, keyNameFromDefinition);
       case "UNTYPED_ARRAY":
-        const minItems = schema10.minItems;
-        const maxItems = typeof schema10.maxItems === "number" ? schema10.maxItems : -1;
+        const minItems = schema11.minItems;
+        const maxItems = typeof schema11.maxItems === "number" ? schema11.maxItems : -1;
         const params = options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY;
         if (minItems > 0 || maxItems >= 0) {
           return {
-            comment: schema10.description,
-            deprecated: schema10.deprecated,
+            comment: schema11.description,
+            deprecated: schema11.deprecated,
             keyName,
-            maxItems: schema10.maxItems,
+            maxItems: schema11.maxItems,
             minItems,
             params: Array(Math.max(maxItems, minItems) || 0).fill(params),
             spreadParam: maxItems >= 0 ? undefined : params,
-            standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
+            standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
             type: "TUPLE"
           };
         }
         return {
-          comment: schema10.description,
-          deprecated: schema10.deprecated,
+          comment: schema11.description,
+          deprecated: schema11.deprecated,
           keyName,
           params,
-          standaloneName: standaloneName(schema10, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema11, keyNameFromDefinition, usedNames, options8),
           type: "ARRAY"
         };
     }
   }
-  function standaloneName(schema10, keyNameFromDefinition, usedNames, options8) {
+  function standaloneName(schema11, keyNameFromDefinition, usedNames, options8) {
     var _a7;
-    const name2 = ((_a7 = options8.customName) === null || _a7 === undefined ? undefined : _a7.call(options8, schema10, keyNameFromDefinition)) || schema10.title || schema10.$id || keyNameFromDefinition;
+    const name2 = ((_a7 = options8.customName) === null || _a7 === undefined ? undefined : _a7.call(options8, schema11, keyNameFromDefinition)) || schema11.title || schema11.$id || keyNameFromDefinition;
     if (name2) {
       return (0, utils_1.generateName)(name2, usedNames);
     }
   }
-  function newInterface(schema10, options8, processed, usedNames, keyName, keyNameFromDefinition) {
-    const name2 = standaloneName(schema10, keyNameFromDefinition, usedNames, options8);
+  function newInterface(schema11, options8, processed, usedNames, keyName, keyNameFromDefinition) {
+    const name2 = standaloneName(schema11, keyNameFromDefinition, usedNames, options8);
     return {
-      comment: schema10.description,
-      deprecated: schema10.deprecated,
+      comment: schema11.description,
+      deprecated: schema11.deprecated,
       keyName,
-      params: parseSchema(schema10, options8, processed, usedNames, name2),
+      params: parseSchema(schema11, options8, processed, usedNames, name2),
       standaloneName: name2,
-      superTypes: parseSuperTypes(schema10, options8, processed, usedNames),
+      superTypes: parseSuperTypes(schema11, options8, processed, usedNames),
       type: "INTERFACE"
     };
   }
-  function parseSuperTypes(schema10, options8, processed, usedNames) {
-    const superTypes = schema10.extends;
+  function parseSuperTypes(schema11, options8, processed, usedNames) {
+    const superTypes = schema11.extends;
     if (!superTypes) {
       return [];
     }
     return superTypes.map((_10) => parse11(_10, options8, undefined, processed, usedNames));
   }
-  function parseSchema(schema10, options8, processed, usedNames, parentSchemaName) {
-    let asts = (0, lodash_1.map)(schema10.properties, (value, key2) => ({
+  function parseSchema(schema11, options8, processed, usedNames, parentSchemaName) {
+    let asts = (0, lodash_1.map)(schema11.properties, (value, key2) => ({
       ast: parse11(value, options8, key2, processed, usedNames),
       isPatternProperty: false,
-      isRequired: (0, lodash_1.includes)(schema10.required || [], key2),
+      isRequired: (0, lodash_1.includes)(schema11.required || [], key2),
       isUnreachableDefinition: false,
       keyName: key2
     }));
     let singlePatternProperty = false;
-    if (schema10.patternProperties) {
-      singlePatternProperty = !schema10.additionalProperties && Object.keys(schema10.patternProperties).length === 1;
-      asts = asts.concat((0, lodash_1.map)(schema10.patternProperties, (value, key2) => {
+    if (schema11.patternProperties) {
+      singlePatternProperty = !schema11.additionalProperties && Object.keys(schema11.patternProperties).length === 1;
+      asts = asts.concat((0, lodash_1.map)(schema11.patternProperties, (value, key2) => {
         const ast = parse11(value, options8, key2, processed, usedNames);
         const comment = `This interface was referenced by \`${parentSchemaName}\`'s JSON-Schema definition
 via the \`patternProperty\` "${key2.replace("*/", "*\\/")}".`;
@@ -142466,14 +142466,14 @@ ${comment}` : comment;
         return {
           ast,
           isPatternProperty: !singlePatternProperty,
-          isRequired: singlePatternProperty || (0, lodash_1.includes)(schema10.required || [], key2),
+          isRequired: singlePatternProperty || (0, lodash_1.includes)(schema11.required || [], key2),
           isUnreachableDefinition: false,
           keyName: singlePatternProperty ? "[k: string]" : key2
         };
       }));
     }
     if (options8.unreachableDefinitions) {
-      asts = asts.concat((0, lodash_1.map)(schema10.$defs, (value, key2) => {
+      asts = asts.concat((0, lodash_1.map)(schema11.$defs, (value, key2) => {
         const ast = parse11(value, options8, key2, processed, usedNames);
         const comment = `This interface was referenced by \`${parentSchemaName}\`'s JSON-Schema
 via the \`definition\` "${key2}".`;
@@ -142483,13 +142483,13 @@ ${comment}` : comment;
         return {
           ast,
           isPatternProperty: false,
-          isRequired: (0, lodash_1.includes)(schema10.required || [], key2),
+          isRequired: (0, lodash_1.includes)(schema11.required || [], key2),
           isUnreachableDefinition: true,
           keyName: key2
         };
       }));
     }
-    switch (schema10.additionalProperties) {
+    switch (schema11.additionalProperties) {
       case undefined:
       case true:
         if (singlePatternProperty) {
@@ -142506,7 +142506,7 @@ ${comment}` : comment;
         return asts;
       default:
         return asts.concat({
-          ast: parse11(schema10.additionalProperties, options8, "[k: string]", processed, usedNames),
+          ast: parse11(schema11.additionalProperties, options8, "[k: string]", processed, usedNames),
           isPatternProperty: false,
           isRequired: true,
           isUnreachableDefinition: false,
@@ -142514,22 +142514,22 @@ ${comment}` : comment;
         });
     }
   }
-  function getDefinitions(schema10, isSchema = true, processed = new Set) {
-    if (processed.has(schema10)) {
+  function getDefinitions(schema11, isSchema = true, processed = new Set) {
+    if (processed.has(schema11)) {
       return {};
     }
-    processed.add(schema10);
-    if (Array.isArray(schema10)) {
-      return schema10.reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(cur, false, processed)), {});
+    processed.add(schema11);
+    if (Array.isArray(schema11)) {
+      return schema11.reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(cur, false, processed)), {});
     }
-    if ((0, lodash_1.isPlainObject)(schema10)) {
-      return Object.assign(Object.assign({}, isSchema && hasDefinitions(schema10) ? schema10.$defs : {}), Object.keys(schema10).reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(schema10[cur], false, processed)), {}));
+    if ((0, lodash_1.isPlainObject)(schema11)) {
+      return Object.assign(Object.assign({}, isSchema && hasDefinitions(schema11) ? schema11.$defs : {}), Object.keys(schema11).reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(schema11[cur], false, processed)), {}));
     }
     return {};
   }
   var getDefinitionsMemoized = (0, lodash_1.memoize)(getDefinitions);
-  function hasDefinitions(schema10) {
-    return "$defs" in schema10;
+  function hasDefinitions(schema11) {
+    return "$defs" in schema11;
   }
 });
 
@@ -142942,7 +142942,7 @@ var require_url = __commonJS((exports) => {
   };
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.parse = undefined;
-  exports.resolve = resolve12;
+  exports.resolve = resolve13;
   exports.cwd = cwd;
   exports.getProtocol = getProtocol;
   exports.getExtension = getExtension;
@@ -142970,7 +142970,7 @@ var require_url = __commonJS((exports) => {
   var urlDecodePatterns = [/%23/g, "#", /%24/g, "$", /%26/g, "&", /%2C/g, ",", /%40/g, "@"];
   var parse11 = (u4) => new URL(u4);
   exports.parse = parse11;
-  function resolve12(from, to5) {
+  function resolve13(from, to5) {
     const fromUrl = new URL((0, convert_path_to_posix_1.default)(from), "https://aaa.nonexistanturl.com");
     const resolvedUrl = new URL((0, convert_path_to_posix_1.default)(to5), fromUrl);
     const endSpaces = to5.match(/(\s*)$/)?.[1] || "";
@@ -143106,7 +143106,7 @@ var require_url = __commonJS((exports) => {
   }
   function relative4(from, to5) {
     if (!isFileSystemPath(from) || !isFileSystemPath(to5)) {
-      return resolve12(from, to5);
+      return resolve13(from, to5);
     }
     const fromDir = path_1.default.dirname(stripHash(from));
     const toPath4 = stripHash(to5);
@@ -143782,7 +143782,7 @@ var require_plugins = __commonJS((exports) => {
     let plugin;
     let lastError;
     let index = 0;
-    return new Promise((resolve12, reject) => {
+    return new Promise((resolve13, reject) => {
       runNextPlugin();
       function runNextPlugin() {
         plugin = plugins[index++];
@@ -143810,7 +143810,7 @@ var require_plugins = __commonJS((exports) => {
         }
       }
       function onSuccess(result) {
-        resolve12({
+        resolve13({
           plugin,
           result
         });
@@ -144353,7 +144353,7 @@ var require_normalize_args = __commonJS((exports) => {
   var options_js_1 = require_options();
   function normalizeArgs(_args) {
     let path18;
-    let schema10;
+    let schema11;
     let options8;
     let callback;
     const args = Array.prototype.slice.call(_args);
@@ -144363,15 +144363,15 @@ var require_normalize_args = __commonJS((exports) => {
     if (typeof args[0] === "string") {
       path18 = args[0];
       if (typeof args[2] === "object") {
-        schema10 = args[1];
+        schema11 = args[1];
         options8 = args[2];
       } else {
-        schema10 = undefined;
+        schema11 = undefined;
         options8 = args[1];
       }
     } else {
       path18 = "";
-      schema10 = args[0];
+      schema11 = args[0];
       options8 = args[1];
     }
     try {
@@ -144379,12 +144379,12 @@ var require_normalize_args = __commonJS((exports) => {
     } catch (e8) {
       console.error(`JSON Schema Ref Parser: Error normalizing options: ${e8}`);
     }
-    if (!options8.mutateInputSchema && typeof schema10 === "object") {
-      schema10 = JSON.parse(JSON.stringify(schema10));
+    if (!options8.mutateInputSchema && typeof schema11 === "object") {
+      schema11 = JSON.parse(JSON.stringify(schema11));
     }
     return {
       path: path18,
-      schema: schema10,
+      schema: schema11,
       options: options8,
       callback
     };
@@ -145143,11 +145143,11 @@ var require_lib3 = __commonJS((exports) => {
 var require_resolver = __commonJS((exports) => {
   var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P9, generator) {
     function adopt(value) {
-      return value instanceof P9 ? value : new P9(function(resolve12) {
-        resolve12(value);
+      return value instanceof P9 ? value : new P9(function(resolve13) {
+        resolve13(value);
       });
     }
-    return new (P9 || (P9 = Promise))(function(resolve12, reject) {
+    return new (P9 || (P9 = Promise))(function(resolve13, reject) {
       function fulfilled(value) {
         try {
           step(generator.next(value));
@@ -145163,7 +145163,7 @@ var require_resolver = __commonJS((exports) => {
         }
       }
       function step(result) {
-        result.done ? resolve12(result.value) : adopt(result.value).then(fulfilled, rejected);
+        result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
       }
       step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
@@ -145173,12 +145173,12 @@ var require_resolver = __commonJS((exports) => {
   var json_schema_ref_parser_1 = require_lib3();
   var utils_1 = require_utils7();
   function dereference(schema_1, _a7) {
-    return __awaiter(this, arguments, undefined, function* (schema10, { cwd, $refOptions }) {
-      (0, utils_1.log)("green", "dereferencer", "Dereferencing input schema:", cwd, schema10);
+    return __awaiter(this, arguments, undefined, function* (schema11, { cwd, $refOptions }) {
+      (0, utils_1.log)("green", "dereferencer", "Dereferencing input schema:", cwd, schema11);
       const parser2 = new json_schema_ref_parser_1.$RefParser;
       const dereferencedPaths = new WeakMap;
-      const dereferencedSchema = yield parser2.dereference(cwd, schema10, Object.assign(Object.assign({}, $refOptions), { dereference: Object.assign(Object.assign({}, $refOptions.dereference), { onDereference($ref, schema11) {
-        dereferencedPaths.set(schema11, $ref);
+      const dereferencedSchema = yield parser2.dereference(cwd, schema11, Object.assign(Object.assign({}, $refOptions), { dereference: Object.assign(Object.assign({}, $refOptions.dereference), { onDereference($ref, schema12) {
+        dereferencedPaths.set(schema12, $ref);
       } }) }));
       return { dereferencedPaths, dereferencedSchema };
     });
@@ -145192,46 +145192,46 @@ var require_validator = __commonJS((exports) => {
   exports.validate = undefined;
   var utils_1 = require_utils7();
   var rules = new Map;
-  rules.set("Enum members and tsEnumNames must be of the same length", (schema10) => {
-    if (schema10.enum && schema10.tsEnumNames && schema10.enum.length !== schema10.tsEnumNames.length) {
+  rules.set("Enum members and tsEnumNames must be of the same length", (schema11) => {
+    if (schema11.enum && schema11.tsEnumNames && schema11.enum.length !== schema11.tsEnumNames.length) {
       return false;
     }
   });
-  rules.set("tsEnumNames must be an array of strings", (schema10) => {
-    if (schema10.tsEnumNames && schema10.tsEnumNames.some((_10) => typeof _10 !== "string")) {
+  rules.set("tsEnumNames must be an array of strings", (schema11) => {
+    if (schema11.tsEnumNames && schema11.tsEnumNames.some((_10) => typeof _10 !== "string")) {
       return false;
     }
   });
-  rules.set("When both maxItems and minItems are present, maxItems >= minItems", (schema10) => {
-    const { maxItems, minItems } = schema10;
+  rules.set("When both maxItems and minItems are present, maxItems >= minItems", (schema11) => {
+    const { maxItems, minItems } = schema11;
     if (typeof maxItems === "number" && typeof minItems === "number") {
       return maxItems >= minItems;
     }
   });
-  rules.set("When maxItems exists, maxItems >= 0", (schema10) => {
-    const { maxItems } = schema10;
+  rules.set("When maxItems exists, maxItems >= 0", (schema11) => {
+    const { maxItems } = schema11;
     if (typeof maxItems === "number") {
       return maxItems >= 0;
     }
   });
-  rules.set("When minItems exists, minItems >= 0", (schema10) => {
-    const { minItems } = schema10;
+  rules.set("When minItems exists, minItems >= 0", (schema11) => {
+    const { minItems } = schema11;
     if (typeof minItems === "number") {
       return minItems >= 0;
     }
   });
-  rules.set("deprecated must be a boolean", (schema10) => {
-    const typeOfDeprecated = typeof schema10.deprecated;
+  rules.set("deprecated must be a boolean", (schema11) => {
+    const typeOfDeprecated = typeof schema11.deprecated;
     return typeOfDeprecated === "boolean" || typeOfDeprecated === "undefined";
   });
-  function validate2(schema10, filename) {
+  function validate2(schema11, filename) {
     const errors5 = [];
     rules.forEach((rule, ruleName) => {
-      (0, utils_1.traverse)(schema10, (schema11, key2) => {
-        if (rule(schema11) === false) {
+      (0, utils_1.traverse)(schema11, (schema12, key2) => {
+        if (rule(schema12) === false) {
           errors5.push(`Error at key "${key2}" in file "${filename}": ${ruleName}`);
         }
-        return schema11;
+        return schema12;
       });
     });
     return errors5;
@@ -145245,25 +145245,25 @@ var require_linker = __commonJS((exports) => {
   exports.link = undefined;
   var JSONSchema_1 = require_JSONSchema();
   var lodash_1 = require_lodash8();
-  function link2(schema10, parent = null) {
-    if (!Array.isArray(schema10) && !(0, lodash_1.isPlainObject)(schema10)) {
-      return schema10;
+  function link2(schema11, parent = null) {
+    if (!Array.isArray(schema11) && !(0, lodash_1.isPlainObject)(schema11)) {
+      return schema11;
     }
-    if (schema10.hasOwnProperty(JSONSchema_1.Parent)) {
-      return schema10;
+    if (schema11.hasOwnProperty(JSONSchema_1.Parent)) {
+      return schema11;
     }
-    Object.defineProperty(schema10, JSONSchema_1.Parent, {
+    Object.defineProperty(schema11, JSONSchema_1.Parent, {
       enumerable: false,
       value: parent,
       writable: false
     });
-    if (Array.isArray(schema10)) {
-      schema10.forEach((child) => link2(child, schema10));
+    if (Array.isArray(schema11)) {
+      schema11.forEach((child) => link2(child, schema11));
     }
-    for (const key2 in schema10) {
-      link2(schema10[key2], schema10);
+    for (const key2 in schema11) {
+      link2(schema11[key2], schema11);
     }
-    return schema10;
+    return schema11;
   }
   exports.link = link2;
 });
@@ -145284,11 +145284,11 @@ var require_optionValidator = __commonJS((exports) => {
 var require_src3 = __commonJS((exports) => {
   var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P9, generator) {
     function adopt(value) {
-      return value instanceof P9 ? value : new P9(function(resolve12) {
-        resolve12(value);
+      return value instanceof P9 ? value : new P9(function(resolve13) {
+        resolve13(value);
       });
     }
-    return new (P9 || (P9 = Promise))(function(resolve12, reject) {
+    return new (P9 || (P9 = Promise))(function(resolve13, reject) {
       function fulfilled(value) {
         try {
           step(generator.next(value));
@@ -145304,7 +145304,7 @@ var require_src3 = __commonJS((exports) => {
         }
       }
       function step(result) {
-        result.done ? resolve12(result.value) : adopt(result.value).then(fulfilled, rejected);
+        result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
       }
       step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
@@ -145355,8 +145355,8 @@ var require_src3 = __commonJS((exports) => {
     unknownAny: true
   };
   function compileFromFile(filename, options8 = exports.DEFAULT_OPTIONS) {
-    const schema10 = parseAsJSONSchema(filename);
-    return compile(schema10, (0, utils_1.stripExtension)(filename), Object.assign({ cwd: (0, path_1.dirname)(filename) }, options8));
+    const schema11 = parseAsJSONSchema(filename);
+    return compile(schema11, (0, utils_1.stripExtension)(filename), Object.assign({ cwd: (0, path_1.dirname)(filename) }, options8));
   }
   exports.compileFromFile = compileFromFile;
   function parseAsJSONSchema(filename) {
@@ -145366,7 +145366,7 @@ var require_src3 = __commonJS((exports) => {
     return (0, utils_1.parseFileAsJSONSchema)(filename, contents.toString());
   }
   function compile(schema_1, name_1) {
-    return __awaiter(this, arguments, undefined, function* (schema10, name2, options8 = {}) {
+    return __awaiter(this, arguments, undefined, function* (schema11, name2, options8 = {}) {
       (0, optionValidator_1.validateOptions)(options8);
       const _options = (0, lodash_1.merge)({}, exports.DEFAULT_OPTIONS, options8);
       const start = Date.now();
@@ -145376,7 +145376,7 @@ var require_src3 = __commonJS((exports) => {
       if (!(0, lodash_1.endsWith)(_options.cwd, "/")) {
         _options.cwd += "/";
       }
-      const _schema = (0, lodash_1.cloneDeep)(schema10);
+      const _schema = (0, lodash_1.cloneDeep)(schema11);
       const { dereferencedPaths, dereferencedSchema } = yield (0, resolver_1.dereference)(_schema, _options);
       if (process.env.VERBOSE) {
         if ((0, util_1.isDeepStrictEqual)(_schema, dereferencedSchema)) {
@@ -150819,11 +150819,11 @@ var require_raw_body = __commonJS((exports, module) => {
     if (done) {
       return readStream(stream, encoding, length, limit, wrap(done));
     }
-    return new Promise(function executor(resolve12, reject) {
+    return new Promise(function executor(resolve13, reject) {
       readStream(stream, encoding, length, limit, function onRead2(err, buf) {
         if (err)
           return reject(err);
-        resolve12(buf);
+        resolve13(buf);
       });
     });
   }
@@ -163948,7 +163948,7 @@ var require_view = __commonJS((exports, module) => {
   var basename6 = path18.basename;
   var extname2 = path18.extname;
   var join25 = path18.join;
-  var resolve12 = path18.resolve;
+  var resolve13 = path18.resolve;
   module.exports = View;
   function View(name2, options8) {
     var opts = options8 || {};
@@ -163982,7 +163982,7 @@ var require_view = __commonJS((exports, module) => {
     debug('lookup "%s"', name2);
     for (var i5 = 0;i5 < roots.length && !path19; i5++) {
       var root2 = roots[i5];
-      var loc = resolve12(root2, name2);
+      var loc = resolve13(root2, name2);
       var dir = dirname19(loc);
       var file2 = basename6(loc);
       path19 = this.resolve(dir, file2);
@@ -164007,7 +164007,7 @@ var require_view = __commonJS((exports, module) => {
     });
     sync = false;
   };
-  View.prototype.resolve = function resolve13(dir, file2) {
+  View.prototype.resolve = function resolve14(dir, file2) {
     var ext = this.ext;
     var path19 = join25(dir, file2);
     var stat2 = tryStat(path19);
@@ -166166,7 +166166,7 @@ var require_application = __commonJS((exports, module) => {
   var compileETag = require_utils10().compileETag;
   var compileQueryParser = require_utils10().compileQueryParser;
   var compileTrust = require_utils10().compileTrust;
-  var resolve12 = __require("node:path").resolve;
+  var resolve13 = __require("node:path").resolve;
   var once9 = require_once();
   var Router = require_router();
   var slice = Array.prototype.slice;
@@ -166220,7 +166220,7 @@ var require_application = __commonJS((exports, module) => {
     this.mountpath = "/";
     this.locals.settings = this.settings;
     this.set("view", View);
-    this.set("views", resolve12("views"));
+    this.set("views", resolve13("views"));
     this.set("jsonp callback name", "callback");
     if (env3 === "production") {
       this.enable("view cache");
@@ -167711,7 +167711,7 @@ var require_send = __commonJS((exports, module) => {
   var extname2 = path18.extname;
   var join25 = path18.join;
   var normalize2 = path18.normalize;
-  var resolve12 = path18.resolve;
+  var resolve13 = path18.resolve;
   var sep = path18.sep;
   var BYTES_RANGE_REGEXP = /^ *bytes=/;
   var MAX_MAXAGE = 60 * 60 * 24 * 365 * 1000;
@@ -167740,7 +167740,7 @@ var require_send = __commonJS((exports, module) => {
     this._maxage = opts.maxAge || opts.maxage;
     this._maxage = typeof this._maxage === "string" ? ms9(this._maxage) : Number(this._maxage);
     this._maxage = !isNaN(this._maxage) ? Math.min(Math.max(0, this._maxage), MAX_MAXAGE) : 0;
-    this._root = opts.root ? resolve12(opts.root) : null;
+    this._root = opts.root ? resolve13(opts.root) : null;
   }
   util2.inherits(SendStream, Stream2);
   SendStream.prototype.error = function error48(status, err) {
@@ -167889,7 +167889,7 @@ var require_send = __commonJS((exports, module) => {
         return res;
       }
       parts = normalize2(path19).split(sep);
-      path19 = resolve12(path19);
+      path19 = resolve13(path19);
     }
     if (containsDotFile(parts)) {
       debug('%s dotfile "%s"', this._dotfiles, path19);
@@ -168217,7 +168217,7 @@ var require_response = __commonJS((exports, module) => {
   var cookie = require_cookie();
   var send = require_send();
   var extname2 = path18.extname;
-  var resolve12 = path18.resolve;
+  var resolve13 = path18.resolve;
   var vary = require_vary();
   var { Buffer: Buffer7 } = __require("node:buffer");
   var res = Object.create(http.ServerResponse.prototype);
@@ -168426,7 +168426,7 @@ var require_response = __commonJS((exports, module) => {
     }
     opts = Object.create(opts);
     opts.headers = headers;
-    var fullPath = !opts.root ? resolve12(path19) : path19;
+    var fullPath = !opts.root ? resolve13(path19) : path19;
     return this.sendFile(fullPath, opts, done);
   };
   res.contentType = res.type = function contentType(type) {
@@ -168687,7 +168687,7 @@ var require_serve_static = __commonJS((exports, module) => {
   var encodeUrl = require_encodeurl();
   var escapeHtml = require_escape_html();
   var parseUrl = require_parseurl();
-  var resolve12 = __require("path").resolve;
+  var resolve13 = __require("path").resolve;
   var send = require_send();
   var url3 = __require("url");
   module.exports = serveStatic;
@@ -168706,7 +168706,7 @@ var require_serve_static = __commonJS((exports, module) => {
       throw new TypeError("option setHeaders must be function");
     }
     opts.maxage = opts.maxage || opts.maxAge || 0;
-    opts.root = resolve12(root2);
+    opts.root = resolve13(root2);
     var onDirectory = redirect ? createRedirectDirectoryListener() : createNotFoundDirectoryListener();
     return function serveStatic2(req, res, next) {
       if (req.method !== "GET" && req.method !== "HEAD") {
@@ -172080,8 +172080,8 @@ var require_executor = __commonJS((exports, module) => {
     }
     resetBuffer() {
       this.buffer = new Waterfall;
-      this.buffer.chain(new Promise((resolve12) => {
-        this._triggerBuffer = resolve12;
+      this.buffer.chain(new Promise((resolve13) => {
+        this._triggerBuffer = resolve13;
       }));
       if (this.ready)
         this._triggerBuffer();
@@ -173101,7 +173101,7 @@ var require_storage = __commonJS((exports, module) => {
       throw e8;
     }
   };
-  var writeFileLinesAsync = (filename, lines, mode = DEFAULT_FILE_MODE) => new Promise((resolve12, reject) => {
+  var writeFileLinesAsync = (filename, lines, mode = DEFAULT_FILE_MODE) => new Promise((resolve13, reject) => {
     try {
       const stream = writeFileStream(filename, { mode });
       const readable2 = Readable6.from(lines);
@@ -173118,7 +173118,7 @@ var require_storage = __commonJS((exports, module) => {
           if (err)
             reject(err);
           else
-            resolve12();
+            resolve13();
         });
       });
       readable2.on("error", (err) => {
@@ -173289,7 +173289,7 @@ var require_persistence = __commonJS((exports, module) => {
       return { data: tdata, indexes };
     }
     treatRawStreamAsync(rawStream) {
-      return new Promise((resolve12, reject) => {
+      return new Promise((resolve13, reject) => {
         const dataById = {};
         const indexes = {};
         let corruptItems = 0;
@@ -173332,7 +173332,7 @@ var require_persistence = __commonJS((exports, module) => {
             }
           }
           const data = Object.values(dataById);
-          resolve12({ data, indexes });
+          resolve13({ data, indexes });
         });
         lineStream.on("error", function(err) {
           reject(err, null);
@@ -198943,13 +198943,13 @@ var require_broadcast_operator = __commonJS((exports) => {
       return true;
     }
     emitWithAck(ev2, ...args) {
-      return new Promise((resolve12, reject) => {
+      return new Promise((resolve13, reject) => {
         args.push((err, responses) => {
           if (err) {
             err.responses = responses;
             return reject(err);
           } else {
-            return resolve12(responses);
+            return resolve13(responses);
           }
         });
         this.emit(ev2, ...args);
@@ -199137,12 +199137,12 @@ var require_socket2 = __commonJS((exports) => {
     }
     emitWithAck(ev2, ...args) {
       const withErr = this.flags.timeout !== undefined;
-      return new Promise((resolve12, reject) => {
+      return new Promise((resolve13, reject) => {
         args.push((arg1, arg2) => {
           if (withErr) {
-            return arg1 ? reject(arg1) : resolve12(arg2);
+            return arg1 ? reject(arg1) : resolve13(arg2);
           } else {
-            return resolve12(arg1);
+            return resolve13(arg1);
           }
         });
         this.emit(ev2, ...args);
@@ -199597,13 +199597,13 @@ var require_namespace = __commonJS((exports) => {
       return true;
     }
     serverSideEmitWithAck(ev2, ...args) {
-      return new Promise((resolve12, reject) => {
+      return new Promise((resolve13, reject) => {
         args.push((err, responses) => {
           if (err) {
             err.responses = responses;
             return reject(err);
           } else {
-            return resolve12(responses);
+            return resolve13(responses);
           }
         });
         this.serverSideEmit(ev2, ...args);
@@ -200287,7 +200287,7 @@ var require_cluster_adapter = __commonJS((exports) => {
         return localSockets;
       }
       const requestId = randomId();
-      return new Promise((resolve12, reject) => {
+      return new Promise((resolve13, reject) => {
         const timeout3 = setTimeout(() => {
           const storedRequest2 = this.requests.get(requestId);
           if (storedRequest2) {
@@ -200297,7 +200297,7 @@ var require_cluster_adapter = __commonJS((exports) => {
         }, opts.flags.timeout || DEFAULT_TIMEOUT);
         const storedRequest = {
           type: MessageType.FETCH_SOCKETS,
-          resolve: resolve12,
+          resolve: resolve13,
           timeout: timeout3,
           current: 0,
           expected: expectedResponseCount,
@@ -200507,7 +200507,7 @@ var require_cluster_adapter = __commonJS((exports) => {
         return localSockets;
       }
       const requestId = randomId();
-      return new Promise((resolve12, reject) => {
+      return new Promise((resolve13, reject) => {
         const timeout3 = setTimeout(() => {
           const storedRequest2 = this.customRequests.get(requestId);
           if (storedRequest2) {
@@ -200517,7 +200517,7 @@ var require_cluster_adapter = __commonJS((exports) => {
         }, opts.flags.timeout || DEFAULT_TIMEOUT);
         const storedRequest = {
           type: MessageType.FETCH_SOCKETS,
-          resolve: resolve12,
+          resolve: resolve13,
           timeout: timeout3,
           missingUids: new Set([...this.nodesMap.keys()]),
           responses: localSockets
@@ -201246,13 +201246,13 @@ var require_dist4 = __commonJS((exports, module) => {
       this.engine.close();
       (0, uws_1.restoreAdapter)();
       if (this.httpServer) {
-        return new Promise((resolve12) => {
+        return new Promise((resolve13) => {
           this.httpServer.close((err) => {
             fn9 && fn9(err);
             if (err) {
               debug("server was not running");
             }
-            resolve12();
+            resolve13();
           });
         });
       } else {
@@ -215914,14 +215914,14 @@ var require_async_iterator = __commonJS((exports, module) => {
     };
   }
   function readAndResolve(iter) {
-    var resolve12 = iter[kLastResolve];
-    if (resolve12 !== null) {
+    var resolve13 = iter[kLastResolve];
+    if (resolve13 !== null) {
       var data = iter[kStream].read();
       if (data !== null) {
         iter[kLastPromise] = null;
         iter[kLastResolve] = null;
         iter[kLastReject] = null;
-        resolve12(createIterResult(data, false));
+        resolve13(createIterResult(data, false));
       }
     }
   }
@@ -215929,13 +215929,13 @@ var require_async_iterator = __commonJS((exports, module) => {
     process.nextTick(readAndResolve, iter);
   }
   function wrapForNext(lastPromise, iter) {
-    return function(resolve12, reject) {
+    return function(resolve13, reject) {
       lastPromise.then(function() {
         if (iter[kEnded]) {
-          resolve12(createIterResult(undefined, true));
+          resolve13(createIterResult(undefined, true));
           return;
         }
-        iter[kHandlePromise](resolve12, reject);
+        iter[kHandlePromise](resolve13, reject);
       }, reject);
     };
   }
@@ -215954,12 +215954,12 @@ var require_async_iterator = __commonJS((exports, module) => {
         return Promise.resolve(createIterResult(undefined, true));
       }
       if (this[kStream].destroyed) {
-        return new Promise(function(resolve12, reject) {
+        return new Promise(function(resolve13, reject) {
           process.nextTick(function() {
             if (_this[kError]) {
               reject(_this[kError]);
             } else {
-              resolve12(createIterResult(undefined, true));
+              resolve13(createIterResult(undefined, true));
             }
           });
         });
@@ -215982,13 +215982,13 @@ var require_async_iterator = __commonJS((exports, module) => {
     return this;
   }), _defineProperty(_Object$setPrototypeO, "return", function _return() {
     var _this2 = this;
-    return new Promise(function(resolve12, reject) {
+    return new Promise(function(resolve13, reject) {
       _this2[kStream].destroy(null, function(err) {
         if (err) {
           reject(err);
           return;
         }
-        resolve12(createIterResult(undefined, true));
+        resolve13(createIterResult(undefined, true));
       });
     });
   }), _Object$setPrototypeO), AsyncIteratorPrototype);
@@ -216010,15 +216010,15 @@ var require_async_iterator = __commonJS((exports, module) => {
       value: stream._readableState.endEmitted,
       writable: true
     }), _defineProperty(_Object$create, kHandlePromise, {
-      value: function value(resolve12, reject) {
+      value: function value(resolve13, reject) {
         var data = iterator[kStream].read();
         if (data) {
           iterator[kLastPromise] = null;
           iterator[kLastResolve] = null;
           iterator[kLastReject] = null;
-          resolve12(createIterResult(data, false));
+          resolve13(createIterResult(data, false));
         } else {
-          iterator[kLastResolve] = resolve12;
+          iterator[kLastResolve] = resolve13;
           iterator[kLastReject] = reject;
         }
       },
@@ -216037,12 +216037,12 @@ var require_async_iterator = __commonJS((exports, module) => {
         iterator[kError] = err;
         return;
       }
-      var resolve12 = iterator[kLastResolve];
-      if (resolve12 !== null) {
+      var resolve13 = iterator[kLastResolve];
+      if (resolve13 !== null) {
         iterator[kLastPromise] = null;
         iterator[kLastResolve] = null;
         iterator[kLastReject] = null;
-        resolve12(createIterResult(undefined, true));
+        resolve13(createIterResult(undefined, true));
       }
       iterator[kEnded] = true;
     });
@@ -216054,7 +216054,7 @@ var require_async_iterator = __commonJS((exports, module) => {
 
 // ../../node_modules/readable-stream/lib/internal/streams/from.js
 var require_from = __commonJS((exports, module) => {
-  function asyncGeneratorStep(gen, resolve12, reject, _next, _throw, key2, arg) {
+  function asyncGeneratorStep(gen, resolve13, reject, _next, _throw, key2, arg) {
     try {
       var info = gen[key2](arg);
       var value = info.value;
@@ -216063,7 +216063,7 @@ var require_from = __commonJS((exports, module) => {
       return;
     }
     if (info.done) {
-      resolve12(value);
+      resolve13(value);
     } else {
       Promise.resolve(value).then(_next, _throw);
     }
@@ -216071,13 +216071,13 @@ var require_from = __commonJS((exports, module) => {
   function _asyncToGenerator(fn9) {
     return function() {
       var self2 = this, args = arguments;
-      return new Promise(function(resolve12, reject) {
+      return new Promise(function(resolve13, reject) {
         var gen = fn9.apply(self2, args);
         function _next(value) {
-          asyncGeneratorStep(gen, resolve12, reject, _next, _throw, "next", value);
+          asyncGeneratorStep(gen, resolve13, reject, _next, _throw, "next", value);
         }
         function _throw(err) {
-          asyncGeneratorStep(gen, resolve12, reject, _next, _throw, "throw", err);
+          asyncGeneratorStep(gen, resolve13, reject, _next, _throw, "throw", err);
         }
         _next(undefined);
       });
@@ -218279,6 +218279,7 @@ var CONFIG_FILE_EXTENSION = "jsonc";
 var CONFIG_FILE_EXTENSION_GLOB = "{json,jsonc}";
 var FUNCTION_CONFIG_GLOB = `**/function.${CONFIG_FILE_EXTENSION_GLOB}`;
 var ENTRY_FILE_GLOB = "**/entry.{js,ts}";
+var BACKEND_FILE_GLOB = "**/*.{js,ts,json,jsonc}";
 var ENTRY_IGNORE_DOT_PATHS = ["**/*.*/**"];
 var APP_CONFIG_PATTERN = `**/.app.${CONFIG_FILE_EXTENSION_GLOB}`;
 var PROJECT_CONFIG_PATTERNS = [
@@ -233819,6 +233820,9 @@ class ApiError extends SystemError {
         }
       ];
     }
+    if (statusCode && statusCode < 500) {
+      return [];
+    }
     return [{ message: "Check your network connection and try again" }];
   }
   static getReasonHints(parsedResponse) {
@@ -236040,11 +236044,13 @@ var PluginMetadataSchema = exports_external.object({
 var PluginReferenceSchema = exports_external.object({
   source: exports_external.string().min(1, "Plugin source cannot be empty")
 });
+var VISIBILITY_LEVELS = ["public", "private", "workspace"];
 var ProjectConfigSchema = exports_external.object({
   name: exports_external.string({
     error: "App name cannot be empty"
   }).min(1, "App name cannot be empty"),
   description: exports_external.string().optional(),
+  visibility: exports_external.enum(VISIBILITY_LEVELS).optional(),
   site: SiteConfigSchema.optional(),
   entitiesDir: exports_external.string().optional().default("entities"),
   functionsDir: exports_external.string().optional().default("functions"),
@@ -236060,6 +236066,15 @@ var AppConfigSchema = exports_external.object({
 var CreateProjectResponseSchema = exports_external.looseObject({
   id: exports_external.string()
 });
+var AppDetailSchema = exports_external.looseObject({
+  id: exports_external.string(),
+  name: exports_external.string().optional(),
+  organization_id: exports_external.string().nullish()
+}).transform((data) => ({
+  id: data.id,
+  name: data.name,
+  organizationId: data.organization_id ?? undefined
+}));
 var ProjectSchema = exports_external.object({
   id: exports_external.string(),
   name: exports_external.string(),
@@ -241839,7 +241854,12 @@ var PublishedUrlResponseSchema = exports_external.object({
 });
 
 // src/core/project/api.ts
-async function createProject(projectName, description) {
+var PUBLIC_SETTINGS = {
+  public: "public_without_login",
+  private: "private_with_login",
+  workspace: "workspace_with_login"
+};
+async function createProject(projectName, description, organizationId) {
   let response;
   try {
     response = await base44Client.post("api/apps", {
@@ -241847,7 +241867,8 @@ async function createProject(projectName, description) {
         name: projectName,
         user_description: description ?? `Backend for '${projectName}'`,
         is_managed_source_code: false,
-        public_settings: "public_without_login"
+        public_settings: PUBLIC_SETTINGS.public,
+        ...organizationId ? { organization_id: organizationId } : {}
       }
     });
   } catch (error48) {
@@ -241861,6 +241882,18 @@ async function createProject(projectName, description) {
     projectId: result.data.id
   };
 }
+async function setAppVisibility(visibility) {
+  if (!visibility)
+    return;
+  const { id } = getAppContext();
+  try {
+    await base44Client.put(`api/apps/${id}`, {
+      json: { public_settings: PUBLIC_SETTINGS[visibility] }
+    });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "updating app visibility");
+  }
+}
 async function listProjects() {
   let response;
   try {
@@ -241880,6 +241913,21 @@ async function listProjects() {
   }
   return result.data;
 }
+async function getApp(appId) {
+  let response;
+  try {
+    response = await base44Client.get(`api/apps/${appId}`, {
+      searchParams: { fields: "id,name,organization_id" }
+    });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "fetching app");
+  }
+  const result = AppDetailSchema.safeParse(await response.json());
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid response from server", result.error);
+  }
+  return result.data;
+}
 async function downloadProject(projectId, projectPath) {
   let response;
   try {
@@ -243569,7 +243617,14 @@ async function fetchFunctionLogs(functionName, filters = {}) {
   return result.data;
 }
 // src/core/resources/function/config.ts
-import { basename as basename3, dirname as dirname6, join as join8, relative } from "node:path";
+import { basename as basename3, dirname as dirname6, join as join8, relative, resolve as resolve2 } from "node:path";
+async function readSharedFiles(functionsDir) {
+  const sharedDir = resolve2(functionsDir, "..", "shared");
+  if (!await pathExists(sharedDir)) {
+    return [];
+  }
+  return globby(BACKEND_FILE_GLOB, { cwd: sharedDir, absolute: true });
+}
 async function readFunctionConfig(configPath) {
   const parsed = await readJsonFile(configPath);
   const result = FunctionConfigSchema.safeParse(parsed);
@@ -243578,7 +243633,7 @@ async function readFunctionConfig(configPath) {
   }
   return result.data;
 }
-async function readFunction(configPath) {
+async function readFunction(configPath, sharedFiles) {
   const config7 = await readFunctionConfig(configPath);
   const functionDir = dirname6(configPath);
   const entryPath = join8(functionDir, config7.entry);
@@ -243587,14 +243642,15 @@ async function readFunction(configPath) {
       hints: [{ message: "Check the 'entry' field in your function config" }]
     });
   }
-  const filePaths = await globby("**/*.{js,ts,json}", {
+  const filePaths = await globby(BACKEND_FILE_GLOB, {
     cwd: functionDir,
     absolute: true
   });
+  const allFilePaths = [...new Set([...filePaths, ...sharedFiles])];
   const functionData = {
     ...config7,
     entryPath,
-    filePaths,
+    filePaths: allFilePaths,
     source: { type: "project" }
   };
   return functionData;
@@ -243614,13 +243670,15 @@ async function readAllFunctions(functionsDir) {
   });
   const configFilesDirs = new Set(configFiles.map((f) => dirname6(f)));
   const entryFilesWithoutConfig = entryFiles.filter((entryFile) => !configFilesDirs.has(dirname6(entryFile)));
-  const functionsFromConfig = await Promise.all(configFiles.map((configPath) => readFunction(configPath)));
+  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 filePaths = await globby("**/*.{js,ts,json}", {
+    const filePaths = await globby(BACKEND_FILE_GLOB, {
       cwd: functionDir,
       absolute: true
     });
+    const allFilePaths = [...new Set([...filePaths, ...sharedFiles])];
     const name2 = relative(functionsDir, functionDir).split(/[/\\]/).join("/");
     if (!name2) {
       throw new InvalidInputError("entry.ts found directly in the functions directory — it must be inside a named subfolder", {
@@ -243636,7 +243694,7 @@ async function readAllFunctions(functionsDir) {
       name: name2,
       entry,
       entryPath: entryFile,
-      filePaths,
+      filePaths: allFilePaths,
       source: { type: "project" }
     };
     return functionData;
@@ -243953,7 +244011,7 @@ import { join as join11 } from "node:path";
 // package.json
 var package_default = {
   name: "base44",
-  version: "0.1.3",
+  version: "0.1.4",
   description: "Base44 CLI - Unified interface for managing Base44 applications",
   type: "module",
   bin: {
@@ -244130,9 +244188,15 @@ async function assertProjectNotExists(dirPath) {
   }
 }
 async function createProjectFiles(options) {
-  const { name: name2, description, path: basePath, template } = options;
+  const {
+    name: name2,
+    description,
+    path: basePath,
+    template,
+    organizationId
+  } = options;
   await assertProjectNotExists(basePath);
-  const { projectId } = await createProject(name2, description);
+  const { projectId } = await createProject(name2, description, organizationId);
   await renderTemplate(template, basePath, { name: name2, description, projectId });
   return {
     projectId,
@@ -244163,7 +244227,7 @@ async function createProjectFilesForExistingProject(options) {
   };
 }
 // src/core/project/deploy.ts
-import { resolve as resolve2 } from "node:path";
+import { resolve as resolve3 } from "node:path";
 
 // src/core/site/api.ts
 async function uploadSite(archivePath) {
@@ -244239,10 +244303,15 @@ function hasResourcesToDeploy(projectData) {
   const hasAgents = agents.length > 0;
   const hasConnectors = connectors.length > 0;
   const hasAuthConfig = authConfig.length > 0;
-  return hasEntities || hasFunctions || hasAgents || hasConnectors || hasAuthConfig || hasSite;
+  const hasVisibility = Boolean(project.visibility);
+  return hasEntities || hasFunctions || hasAgents || hasConnectors || hasAuthConfig || hasVisibility || hasSite;
 }
 async function deployAll(projectData, options) {
   const { project, entities, functions, agents, connectors, authConfig } = projectData;
+  await setAppVisibility(project.visibility);
+  if (project.visibility) {
+    options?.onVisibilitySet?.(project.visibility);
+  }
   await entityResource.push(entities);
   await deployFunctionsSequentially(functions, {
     onStart: options?.onFunctionStart,
@@ -244253,7 +244322,7 @@ async function deployAll(projectData, options) {
   const skipConnectorSync = connectors.length === 0 && hasWorkspaceApiKeyAuth();
   const connectorResults = skipConnectorSync ? [] : (await pushConnectors(connectors)).results;
   if (project.site?.outputDirectory) {
-    const outputDir = resolve2(project.root, project.site.outputDirectory);
+    const outputDir = resolve3(project.root, project.site.outputDirectory);
     const { appUrl } = await deploySite(outputDir);
     return { appUrl, connectorResults };
   }
@@ -246089,8 +246158,8 @@ var disconnect = (anyProcess) => {
 // ../../node_modules/execa/lib/utils/deferred.js
 var createDeferred = () => {
   const methods = {};
-  const promise2 = new Promise((resolve3, reject) => {
-    Object.assign(methods, { resolve: resolve3, reject });
+  const promise2 = new Promise((resolve4, reject) => {
+    Object.assign(methods, { resolve: resolve4, reject });
   });
   return Object.assign(promise2, methods);
 };
@@ -250454,11 +250523,11 @@ var addConcurrentStream = (concurrentStreams, stream, waitName) => {
   const promises = weakMap.get(stream);
   const promise2 = createDeferred();
   promises.push(promise2);
-  const resolve3 = promise2.resolve.bind(promise2);
-  return { resolve: resolve3, promises };
+  const resolve4 = promise2.resolve.bind(promise2);
+  return { resolve: resolve4, promises };
 };
-var waitForConcurrentStreams = async ({ resolve: resolve3, promises }, subprocess) => {
-  resolve3();
+var waitForConcurrentStreams = async ({ resolve: resolve4, promises }, subprocess) => {
+  resolve4();
   const [isSubprocessExit] = await Promise.race([
     Promise.allSettled([true, subprocess]),
     Promise.all([false, ...promises])
@@ -251453,6 +251522,78 @@ function verifyDenoInstalled(context) {
     });
   }
 }
+// src/core/workspace/schema.ts
+var WorkspaceSchema = exports_external.object({
+  id: exports_external.string(),
+  name: exports_external.string(),
+  user_role: exports_external.string().nullish(),
+  subscription_tier: exports_external.string().nullish(),
+  is_enterprise: exports_external.boolean().nullish()
+}).transform((data) => ({
+  id: data.id,
+  name: data.name,
+  userRole: data.user_role ?? undefined,
+  subscriptionTier: data.subscription_tier ?? undefined,
+  isEnterprise: data.is_enterprise ?? undefined
+}));
+var WorkspaceListResponseSchema = exports_external.object({
+  workspaces: exports_external.array(WorkspaceSchema)
+});
+var MoveAppResponseSchema = exports_external.looseObject({
+  success: exports_external.boolean().optional(),
+  message: exports_external.string().optional(),
+  app_id: exports_external.string().optional(),
+  new_workspace_id: exports_external.string().optional()
+}).transform((data) => ({
+  success: data.success ?? true,
+  message: data.message,
+  appId: data.app_id,
+  newWorkspaceId: data.new_workspace_id
+}));
+var APP_EDITOR_ROLES = ["owner", "admin", "editor"];
+function canCreateAppsInWorkspace(role) {
+  return role !== undefined && APP_EDITOR_ROLES.includes(role.toLowerCase());
+}
+
+// src/core/workspace/api.ts
+async function listWorkspaces() {
+  let response;
+  try {
+    response = await base44Client.get("api/workspace/workspaces");
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "listing workspaces");
+  }
+  const result = WorkspaceListResponseSchema.safeParse(await response.json());
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid response from server", result.error);
+  }
+  return result.data.workspaces.map((workspace, index) => ({
+    ...workspace,
+    isPersonal: index === 0
+  }));
+}
+async function getWorkspace(id) {
+  const workspaces = await listWorkspaces();
+  return workspaces.find((w) => w.id === id);
+}
+async function moveAppToWorkspace(appId, targetWorkspaceId, options = {}) {
+  let response;
+  try {
+    response = await base44Client.post(`api/apps/${appId}/metadata/move-to-workspace`, {
+      json: {
+        target_workspace_id: targetWorkspaceId,
+        disconnect_integrations: options.disconnectIntegrations ?? false
+      }
+    });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "moving app to workspace");
+  }
+  const result = MoveAppResponseSchema.safeParse(await response.json());
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid response from server", result.error);
+  }
+  return result.data;
+}
 // src/cli/commands/agents/pull.ts
 async function pullAgentsAction({
   log,
@@ -251620,7 +251761,7 @@ function getAuthPushCommand() {
 }
 
 // src/cli/commands/auth/social-login.ts
-import { dirname as dirname13, join as join17, resolve as resolve3 } from "node:path";
+import { dirname as dirname13, join as join17, resolve as resolve4 } from "node:path";
 var PROVIDER_LABELS = {
   google: "Google",
   microsoft: "Microsoft",
@@ -251660,7 +251801,7 @@ async function socialLoginAction({ log, isNonInteractive, runTask: runTask2 }, p
   let clientSecret;
   if (useCustomOAuth && oauth && oauthCli && hasSecretOptions(options)) {
     if (options.envFile) {
-      const secrets = await parseEnvFile(resolve3(options.envFile));
+      const secrets = await parseEnvFile(resolve4(options.envFile));
       const value = secrets[oauthCli.envVar];
       if (!value) {
         throw new InvalidInputError(`Key "${oauthCli.envVar}" not found in ${options.envFile}.`);
@@ -251716,7 +251857,7 @@ function getSocialLoginCommand() {
 }
 
 // src/cli/commands/auth/sso.ts
-import { dirname as dirname14, join as join18, resolve as resolve4 } from "node:path";
+import { dirname as dirname14, join as join18, resolve as resolve5 } from "node:path";
 var SSOConfigFileSchema = exports_external.object({
   provider: exports_external.enum(Object.values(KNOWN_SSO_PROVIDERS)),
   clientId: exports_external.string(),
@@ -251732,7 +251873,7 @@ var SSOConfigFileSchema = exports_external.object({
   ssoName: exports_external.string().optional()
 });
 async function loadSSOConfigFile(filePath) {
-  const resolved = resolve4(filePath);
+  const resolved = resolve5(filePath);
   const raw2 = await readJsonFile(resolved);
   const result = SSOConfigFileSchema.safeParse(raw2);
   if (!result.success) {
@@ -251820,7 +251961,7 @@ async function ssoEnableAction({ isNonInteractive, runTask: runTask2 }, options)
   }
   let clientSecret;
   if (merged.envFile && !merged.clientSecret) {
-    const secrets2 = await parseEnvFile(resolve4(merged.envFile));
+    const secrets2 = await parseEnvFile(resolve5(merged.envFile));
     const value = secrets2.sso_client_secret;
     if (!value) {
       throw new InvalidInputError(`Key "sso_client_secret" not found in ${merged.envFile}.`);
@@ -252458,19 +252599,19 @@ var baseOpen = async (options) => {
   }
   const subprocess = childProcess3.spawn(command2, cliArguments, childProcessOptions);
   if (options.wait) {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       subprocess.once("error", reject);
       subprocess.once("close", (exitCode) => {
         if (!options.allowNonzeroExitCode && exitCode !== 0) {
           reject(new Error(`Exited with code ${exitCode}`));
           return;
         }
-        resolve5(subprocess);
+        resolve6(subprocess);
       });
     });
   }
   if (isFallbackAttempt) {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       subprocess.once("error", reject);
       subprocess.once("spawn", () => {
         subprocess.once("close", (exitCode) => {
@@ -252480,17 +252621,17 @@ var baseOpen = async (options) => {
             return;
           }
           subprocess.unref();
-          resolve5(subprocess);
+          resolve6(subprocess);
         });
       });
     });
   }
   subprocess.unref();
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     subprocess.once("error", reject);
     subprocess.once("spawn", () => {
       subprocess.off("error", reject);
-      resolve5(subprocess);
+      resolve6(subprocess);
     });
   });
 };
@@ -252753,10 +252894,10 @@ function getConnectorsListAvailableCommand() {
 }
 
 // src/cli/commands/connectors/pull.ts
-import { dirname as dirname15, join as join19, resolve as resolve5 } from "node:path";
+import { dirname as dirname15, join as join19, resolve as resolve6 } from "node:path";
 async function resolveConnectorsDir(options) {
   if (!getAppContext().projectRoot) {
-    return resolve5(options.dir ?? "connectors");
+    return resolve6(options.dir ?? "connectors");
   }
   const { project: project2 } = await readProjectConfig();
   return join19(dirname15(project2.configPath), project2.connectorsDir);
@@ -252800,10 +252941,10 @@ function getConnectorsPullCommand() {
 }
 
 // src/cli/commands/connectors/push.ts
-import { resolve as resolve6 } from "node:path";
+import { resolve as resolve7 } from "node:path";
 async function readConnectorsToPush(options) {
   if (!getAppContext().projectRoot) {
-    return readAllConnectors(resolve6(options.dir ?? "connectors"));
+    return readAllConnectors(resolve7(options.dir ?? "connectors"));
   }
   const { connectors } = await readProjectConfig();
   return connectors;
@@ -253215,7 +253356,7 @@ function getFunctionsCommand() {
 }
 
 // src/cli/commands/project/create.ts
-import { basename as basename4, resolve as resolve7 } from "node:path";
+import { basename as basename4, resolve as resolve8 } from "node:path";
 var import_kebabCase = __toESM(require_kebabCase(), 1);
 
 // src/cli/commands/project/scaffold-shared.ts
@@ -253313,6 +253454,58 @@ function printProjectSummary({ name: name2, dashboardUrl, appUrl }, log) {
   }
 }
 
+// src/cli/commands/project/workspace-select.ts
+function fetchWorkspaces(ctx) {
+  return ctx.runTask("Fetching workspaces...", () => listWorkspaces(), {
+    successMessage: "Workspaces fetched",
+    errorMessage: "Failed to fetch workspaces"
+  });
+}
+function workspaceHints(workspaces) {
+  return [
+    { message: "Run 'base44 workspace list' to see available workspaces" },
+    ...workspaces.filter((w) => canCreateAppsInWorkspace(w.userRole)).map((w) => ({ message: `${w.name} — ${w.id}` }))
+  ];
+}
+function workspaceLabel(workspace2) {
+  const suffix = workspace2.isPersonal ? "personal" : workspace2.userRole ?? "member";
+  return `${workspace2.name} (${suffix})`;
+}
+async function resolveWorkspaceId(ctx, flagWorkspaceId, isInteractive) {
+  if (flagWorkspaceId) {
+    const workspaces2 = await fetchWorkspaces(ctx);
+    const match = workspaces2.find((w) => w.id === flagWorkspaceId);
+    if (!match) {
+      throw new InvalidInputError(`Workspace "${flagWorkspaceId}" not found, or you are not a member of it.`, { hints: workspaceHints(workspaces2) });
+    }
+    if (!canCreateAppsInWorkspace(match.userRole)) {
+      throw new InvalidInputError(`You don't have permission to create apps in workspace "${match.name}" (your role: ${match.userRole ?? "unknown"}).`);
+    }
+    return match.id;
+  }
+  if (!isInteractive) {
+    return;
+  }
+  const workspaces = await fetchWorkspaces(ctx);
+  const eligible = workspaces.filter((w) => canCreateAppsInWorkspace(w.userRole));
+  if (eligible.length <= 1) {
+    return;
+  }
+  const options = eligible.map((w) => ({
+    value: w.id,
+    label: workspaceLabel(w)
+  }));
+  const selected = await Je({
+    message: "Which workspace should this app belong to?",
+    options,
+    initialValue: eligible[0].id
+  });
+  if (Ct(selected)) {
+    onPromptCancel();
+  }
+  return selected;
+}
+
 // src/cli/commands/project/create.ts
 function validateCreateOptions(command2) {
   const { appId } = command2.optsWithGlobals();
@@ -253365,11 +253558,12 @@ async function createInteractive(options, ctx) {
     projectPath: result.projectPath,
     deploy: options.deploy,
     skills: options.skills,
+    workspaceId: options.workspace ?? options.org,
     isInteractive: true
   }, ctx);
 }
 async function createNonInteractive(options, ctx) {
-  ctx.log.info(`Creating a new project at ${resolve7(options.path)}`);
+  ctx.log.info(`Creating a new project at ${resolve8(options.path)}`);
   const template2 = await getTemplateById(options.template ?? DEFAULT_TEMPLATE_ID);
   return await executeCreate({
     template: template2,
@@ -253377,6 +253571,7 @@ async function createNonInteractive(options, ctx) {
     projectPath: options.path,
     deploy: options.deploy,
     skills: options.skills,
+    workspaceId: options.workspace ?? options.org,
     isInteractive: false
   }, ctx);
 }
@@ -253387,17 +253582,20 @@ async function executeCreate({
   projectPath,
   deploy: deploy5,
   skills,
+  workspaceId: flagWorkspaceId,
   isInteractive
 }, ctx) {
   const { log, runTask: runTask2 } = ctx;
   const name2 = rawName.trim();
-  const resolvedPath = resolve7(projectPath);
+  const resolvedPath = resolve8(projectPath);
+  const organizationId = await resolveWorkspaceId(ctx, flagWorkspaceId, isInteractive);
   const { projectId } = await runTask2("Setting up your project...", async () => {
     return await createProjectFiles({
       name: name2,
       description: description?.trim(),
       path: resolvedPath,
-      template: template2
+      template: template2,
+      organizationId
     });
   }, {
     successMessage: theme.colors.base44Orange("Project created successfully"),
@@ -253431,11 +253629,12 @@ function getCreateCommand() {
   return new Base44Command("create", {
     requireAppContext: false,
     fullBanner: true
-  }).description("Create a new Base44 project").addArgument(new Argument("name", "Project name").argOptional()).option("-p, --path <path>", "Path where to create the project").option("-t, --template <id>", "Template ID (e.g., backend-only, backend-and-client)").option("--deploy", "Build and deploy the site").option("--no-skills", "Skip AI agent skills installation").addHelpText("after", `
+  }).description("Create a new Base44 project").addArgument(new Argument("name", "Project name").argOptional()).option("-p, --path <path>", "Path where to create the project").option("-t, --template <id>", "Template ID (e.g., backend-only, backend-and-client)").option("--deploy", "Build and deploy the site").option("--no-skills", "Skip AI agent skills installation").option("-w, --workspace <id>", "Workspace (organization) ID to create the app in (defaults to your personal workspace)").addOption(new Option("--org <id>", "Alias for --workspace").hideHelp()).addHelpText("after", `
 Examples:
   $ base44 create my-app                                         Creates a base44 project at ./my-app
   $ base44 create my-todo-app --template backend-and-client      Creates a base44 backend-and-client project at ./my-todo-app
-  $ base44 create my-app --path ./projects/my-app --deploy       Creates a base44 project at ./project/my-app and deploys it`).hook("preAction", validateCreateOptions).action(createAction);
+  $ base44 create my-app --path ./projects/my-app --deploy       Creates a base44 project at ./project/my-app and deploys it
+  $ base44 create my-app --workspace 507f1f77bcf86cd799439011     Creates a base44 project in the given workspace`).hook("preAction", validateCreateOptions).action(createAction);
 }
 
 // src/cli/commands/project/deploy.ts
@@ -253466,6 +253665,9 @@ async function deployAction({ isNonInteractive, log }, options = {}) {
   if (authConfig.length > 0) {
     summaryLines.push("  - Auth config");
   }
+  if (project2.visibility) {
+    summaryLines.push(`  - Visibility: ${project2.visibility}`);
+  }
   if (project2.site?.outputDirectory) {
     summaryLines.push(`  - Site from ${project2.site.outputDirectory}`);
   }
@@ -253487,6 +253689,9 @@ ${summaryLines.join(`
   let functionCompleted = 0;
   const functionTotal = functions.length;
   const result = await deployAll(projectData, {
+    onVisibilitySet: (level) => {
+      log.success(`App visibility set to ${level}`);
+    },
     onFunctionStart: (names) => {
       const label = names.length === 1 ? names[0] : `${names.length} functions`;
       log.step(theme.styles.dim(`[${functionCompleted + 1}/${functionTotal}] Deploying ${label}...`));
@@ -253685,8 +253890,9 @@ async function link(ctx, options, command2) {
   }
   if (action === "create") {
     const { name: name2, description } = options.create ? { name: options.name.trim(), description: options.description?.trim() } : await promptForNewProjectDetails();
+    const organizationId = await resolveWorkspaceId(ctx, options.workspace ?? options.org, !isNonInteractive);
     const { projectId } = await runTask2("Creating project on Base44...", async () => {
-      return await createProject(name2, description);
+      return await createProject(name2, description, organizationId);
     }, {
       successMessage: "Project created successfully",
       errorMessage: "Failed to create project"
@@ -253701,7 +253907,7 @@ async function link(ctx, options, command2) {
 function getLinkCommand() {
   return new Base44Command("link", {
     requireAppContext: false
-  }).description("Link a local project to a Base44 project (create new or link existing)").configureHelp({ showGlobalOptions: true }).option("-c, --create", "Create a new project (skip selection prompt)").option("-n, --name <name>", "Project name (required when --create is used)").option("-d, --description <description>", "Project description").addOption(new Option("-p, --project-id <id>", "Project ID to link to an existing project").hideHelp()).addOption(new Option("--projectId <id>", "Project ID to link to an existing project").hideHelp()).hook("preAction", validateNonInteractiveFlags).action(link);
+  }).description("Link a local project to a Base44 project (create new or link existing)").configureHelp({ showGlobalOptions: true }).option("-c, --create", "Create a new project (skip selection prompt)").option("-n, --name <name>", "Project name (required when --create is used)").option("-d, --description <description>", "Project description").option("-w, --workspace <id>", "Workspace (organization) ID to create the app in when using --create (defaults to your personal workspace)").addOption(new Option("--org <id>", "Alias for --workspace").hideHelp()).addOption(new Option("-p, --project-id <id>", "Project ID to link to an existing project").hideHelp()).addOption(new Option("--projectId <id>", "Project ID to link to an existing project").hideHelp()).hook("preAction", validateNonInteractiveFlags).action(link);
 }
 
 // src/cli/commands/project/logs.ts
@@ -253787,7 +253993,7 @@ async function followLogs(functionNames, options, availableFunctionNames, jsonMo
     for (const entry of fresh)
       writeFollowLine(entry, jsonMode);
     first = false;
-    await new Promise((resolve8) => setTimeout(resolve8, 2000));
+    await new Promise((resolve9) => setTimeout(resolve9, 2000));
   }
 }
 function formatLogs(entries, env3) {
@@ -253901,7 +254107,7 @@ function getLogsCommand() {
 }
 
 // src/cli/commands/project/scaffold.ts
-import { basename as basename5, resolve as resolve8 } from "node:path";
+import { basename as basename5, resolve as resolve9 } from "node:path";
 function resolveAppId(options) {
   const appId = options.appId;
   if (!appId) {
@@ -253917,7 +254123,7 @@ function resolveAppId(options) {
 async function scaffoldAction(ctx, name2, options, command2) {
   const { log, runTask: runTask2 } = ctx;
   const appId = resolveAppId(command2.optsWithGlobals());
-  const resolvedPath = resolve8("./");
+  const resolvedPath = resolve9("./");
   const projectName = (name2 ?? basename5(resolvedPath)).trim();
   const template2 = await getTemplateById("backend-only");
   log.info(`Scaffolding project at ${resolvedPath}`);
@@ -253954,6 +254160,17 @@ Examples:
   $ base44 scaffold my-app --app-id app_123  Scaffolds the current dir, named "my-app"`).action(scaffoldAction);
 }
 
+// src/cli/commands/project/visibility.ts
+async function setVisibility({ runTask: runTask2 }, level) {
+  await runTask2(`Setting app visibility to ${level}`, () => setAppVisibility(level));
+  return { outroMessage: `App visibility set to ${level}` };
+}
+function getVisibilityCommand() {
+  return new Base44Command("visibility").description("Set the app's visibility on the server (public, private, or workspace)").addArgument(new Argument("<level>", "Visibility level").choices([
+    ...VISIBILITY_LEVELS
+  ])).action(setVisibility);
+}
+
 // src/core/resources/sandbox/schema.ts
 var FileErrorSchema = exports_external.object({
   code: exports_external.string(),
@@ -254072,7 +254289,7 @@ function withSandboxAuthHint(error48) {
     cause: error48
   });
 }
-async function callTool(appId, tool, payload, schema10, context, timeout2 = 60000) {
+async function callTool(appId, tool, payload, schema11, context, timeout2 = 60000) {
   const client = getSandboxClient(appId);
   let response;
   try {
@@ -254080,7 +254297,7 @@ async function callTool(appId, tool, payload, schema10, context, timeout2 = 6000
   } catch (error48) {
     throw withSandboxAuthHint(await ApiError.fromHttpError(error48, context));
   }
-  const result = schema10.safeParse(await response.json());
+  const result = schema11.safeParse(await response.json());
   if (!result.success) {
     throw new SchemaValidationError("Invalid response from server", result.error);
   }
@@ -254307,7 +254524,7 @@ function getSecretsListCommand() {
 }
 
 // src/cli/commands/secrets/set.ts
-import { resolve as resolve9 } from "node:path";
+import { resolve as resolve10 } from "node:path";
 function parseEntries(entries) {
   const secrets = {};
   for (const entry of entries) {
@@ -254338,7 +254555,7 @@ async function setSecretsAction({ log, runTask: runTask2 }, entries, options) {
   validateInput(entries, options);
   let secrets;
   if (options.envFile) {
-    secrets = await parseEnvFile(resolve9(options.envFile));
+    secrets = await parseEnvFile(resolve10(options.envFile));
     if (Object.keys(secrets).length === 0) {
       throw new InvalidInputError("The env file contains no valid KEY=VALUE entries.");
     }
@@ -254367,7 +254584,7 @@ function getSecretsCommand() {
 }
 
 // src/cli/commands/site/deploy.ts
-import { resolve as resolve10 } from "node:path";
+import { resolve as resolve11 } from "node:path";
 async function deployAction2({ isNonInteractive, runTask: runTask2 }, options) {
   if (isNonInteractive && !options.yes) {
     throw new InvalidInputError("--yes is required in non-interactive mode");
@@ -254382,7 +254599,7 @@ async function deployAction2({ isNonInteractive, runTask: runTask2 }, options) {
       ]
     });
   }
-  const outputDir = resolve10(project2.root, project2.site.outputDirectory);
+  const outputDir = resolve11(project2.root, project2.site.outputDirectory);
   if (!options.yes) {
     const shouldDeploy = await Re({
       message: `Deploy site from ${project2.site.outputDirectory}?`
@@ -254478,9 +254695,9 @@ async function generateContent(input) {
 `);
 }
 async function compileEntity(entity2) {
-  const { name: name2, source: _source, ...schema10 } = entity2;
+  const { name: name2, source: _source, ...schema11 } = entity2;
   const jsonSchema = {
-    ...schema10,
+    ...schema11,
     title: name2,
     additionalProperties: false
   };
@@ -254558,6 +254775,166 @@ function getTypesCommand() {
   return new Command("types").description("Manage TypeScript type generation").addCommand(getTypesGenerateCommand());
 }
 
+// src/cli/commands/workspace/shared.ts
+function toJsonStdout2(result) {
+  return `${JSON.stringify(result, null, 2)}
+`;
+}
+function workspaceTag(workspace2) {
+  const role = workspace2.userRole ?? "member";
+  return workspace2.isPersonal ? `personal, ${role}` : role;
+}
+
+// src/cli/commands/workspace/get.ts
+async function getWorkspaceAction({ runTask: runTask2, log, jsonMode }, workspaceId) {
+  const workspace2 = await runTask2("Fetching workspace...", () => getWorkspace(workspaceId), { errorMessage: "Failed to fetch workspace" });
+  if (!workspace2) {
+    throw new InvalidInputError(`Workspace "${workspaceId}" not found, or you are not a member of it.`, {
+      hints: [
+        { message: "Run 'base44 workspace list' to see your workspaces" }
+      ]
+    });
+  }
+  if (jsonMode) {
+    return {
+      outroMessage: workspace2.name,
+      stdout: toJsonStdout2(workspace2)
+    };
+  }
+  log.message(`  ${theme.styles.bold(workspace2.name)} ${theme.styles.dim(`[${workspaceTag(workspace2)}]`)}
+  ${theme.styles.dim(workspace2.id)}${workspace2.subscriptionTier ? theme.styles.dim(`
+  tier: ${workspace2.subscriptionTier}`) : ""}`);
+  return { outroMessage: workspace2.name };
+}
+function getWorkspaceGetCommand() {
+  return new Base44Command("get", { requireAppContext: false }).description("Show details for a single workspace by ID").argument("<workspace-id>", "Workspace (organization) ID").action(getWorkspaceAction);
+}
+
+// src/cli/commands/workspace/list.ts
+function pluralize2(n5) {
+  return `${n5} workspace${n5 !== 1 ? "s" : ""}`;
+}
+async function listWorkspacesAction({ log, runTask: runTask2, jsonMode }, options8) {
+  let workspaces = await runTask2("Fetching workspaces...", () => listWorkspaces(), { errorMessage: "Failed to fetch workspaces" });
+  if (options8.canCreate) {
+    workspaces = workspaces.filter((w8) => canCreateAppsInWorkspace(w8.userRole));
+  }
+  if (options8.role) {
+    const role = options8.role.toLowerCase();
+    workspaces = workspaces.filter((w8) => w8.userRole?.toLowerCase() === role);
+  }
+  if (jsonMode) {
+    return {
+      outroMessage: pluralize2(workspaces.length),
+      stdout: toJsonStdout2(workspaces)
+    };
+  }
+  for (const workspace2 of workspaces) {
+    log.message(`  ${theme.styles.bold(workspace2.name)} ${theme.styles.dim(`[${workspaceTag(workspace2)}]`)}
+  ${theme.styles.dim(workspace2.id)}`);
+  }
+  return { outroMessage: pluralize2(workspaces.length) };
+}
+function getWorkspaceListCommand() {
+  return new Base44Command("list", { requireAppContext: false }).description("List the workspaces you belong to").option("--can-create", "Only workspaces you can create or move apps into (owner/admin/editor)").option("--role <role>", "Only workspaces where your role matches (owner, admin, editor, viewer)").action(listWorkspacesAction);
+}
+
+// src/cli/commands/workspace/move.ts
+function workspaceName(workspaces, id2) {
+  if (!id2)
+    return "unknown workspace";
+  return workspaces.find((w8) => w8.id === id2)?.name ?? id2;
+}
+async function resolveTargetWorkspace(target, workspaces, currentWorkspaceId, isInteractive) {
+  const eligible = workspaces.filter((w8) => canCreateAppsInWorkspace(w8.userRole) && w8.id !== currentWorkspaceId);
+  if (target) {
+    const match = workspaces.find((w8) => w8.id === target);
+    if (!match) {
+      throw new InvalidInputError(`Workspace "${target}" not found, or you are not a member of it.`, {
+        hints: [
+          { message: "Run 'base44 workspace list' to see your workspaces" }
+        ]
+      });
+    }
+    if (target === currentWorkspaceId) {
+      throw new InvalidInputError("The app is already in that workspace.");
+    }
+    if (!canCreateAppsInWorkspace(match.userRole)) {
+      throw new InvalidInputError(`You don't have permission to move apps into workspace "${match.name}" (your role: ${match.userRole ?? "unknown"}).`);
+    }
+    return match.id;
+  }
+  if (!isInteractive) {
+    throw new InvalidInputError("A target workspace ID is required in non-interactive mode.", {
+      hints: [
+        { message: "Usage: base44 workspace move <workspace-id>" },
+        { message: "Run 'base44 workspace list' to see your workspaces" }
+      ]
+    });
+  }
+  if (eligible.length === 0) {
+    throw new InvalidInputError("No other workspaces available to move this app into.");
+  }
+  const options8 = eligible.map((w8) => ({
+    value: w8.id,
+    label: `${w8.name} (${w8.userRole ?? "member"})`
+  }));
+  const selected = await Je({
+    message: "Move the app to which workspace?",
+    options: options8
+  });
+  if (Ct(selected)) {
+    onPromptCancel();
+  }
+  return selected;
+}
+async function moveAction(ctx, target, options8) {
+  const { runTask: runTask2, isNonInteractive, jsonMode } = ctx;
+  const isInteractive = !isNonInteractive && !jsonMode;
+  const { id: appId } = getAppContext();
+  const { workspaces, currentWorkspaceId } = await runTask2("Fetching workspaces...", async () => {
+    const [workspaces2, app] = await Promise.all([
+      listWorkspaces(),
+      getApp(appId)
+    ]);
+    return { workspaces: workspaces2, currentWorkspaceId: app.organizationId };
+  }, { errorMessage: "Failed to fetch workspaces" });
+  const targetWorkspaceId = await resolveTargetWorkspace(target, workspaces, currentWorkspaceId, isInteractive);
+  if (isInteractive && !options8.yes) {
+    const proceed = await Re({
+      message: `Move this app from ${theme.styles.bold(workspaceName(workspaces, currentWorkspaceId))} to ${theme.styles.bold(workspaceName(workspaces, targetWorkspaceId))}?`
+    });
+    if (Ct(proceed)) {
+      onPromptCancel();
+    }
+    if (!proceed) {
+      return { outroMessage: "Move cancelled" };
+    }
+  }
+  const result = await runTask2("Moving app to workspace...", () => moveAppToWorkspace(appId, targetWorkspaceId, {
+    disconnectIntegrations: options8.disconnectIntegrations
+  }), { errorMessage: "Failed to move app" });
+  const targetName = workspaceName(workspaces, targetWorkspaceId);
+  if (jsonMode) {
+    return {
+      outroMessage: `App moved to ${targetName}`,
+      stdout: toJsonStdout2(result)
+    };
+  }
+  return { outroMessage: `App moved to ${theme.styles.bold(targetName)}` };
+}
+function getWorkspaceMoveCommand() {
+  return new Base44Command("move").description("Move the current app to another workspace").argument("[workspace-id]", "Target workspace (organization) ID").option("--disconnect-integrations", "Disconnect the app's OAuth integrations as part of the move").option("-y, --yes", "Skip the confirmation prompt").addHelpText("after", `
+Examples:
+  $ base44 workspace move 507f1f77bcf86cd799439011      Move the linked app to the given workspace
+  $ base44 workspace move --app-id <id> <workspace-id>  Move a specific app`).action(moveAction);
+}
+
+// src/cli/commands/workspace/index.ts
+function getWorkspaceCommand() {
+  return new Command("workspace").description("List workspaces, inspect one, and move apps between them").addCommand(getWorkspaceListCommand()).addCommand(getWorkspaceGetCommand()).addCommand(getWorkspaceMoveCommand());
+}
+
 // src/cli/dev/dev-server/main.ts
 var import_cors = __toESM(require_lib4(), 1);
 var import_express6 = __toESM(require_express(), 1);
@@ -254588,14 +254965,14 @@ var getLocalHosts = () => {
   }
   return results;
 };
-var checkAvailablePort = (options8) => new Promise((resolve12, reject) => {
+var checkAvailablePort = (options8) => new Promise((resolve13, reject) => {
   const server = net.createServer();
   server.unref();
   server.on("error", reject);
   server.listen(options8, () => {
     const { port } = server.address();
     server.close(() => {
-      resolve12(port);
+      resolve13(port);
     });
   });
 });
@@ -254854,7 +255231,7 @@ class FunctionManager {
     });
   }
   waitForReady(name2, runningFunc) {
-    return new Promise((resolve12, reject) => {
+    return new Promise((resolve13, reject) => {
       runningFunc.process.on("exit", (code2) => {
         if (!runningFunc.ready) {
           clearTimeout(timeout3);
@@ -254877,7 +255254,7 @@ class FunctionManager {
           runningFunc.ready = true;
           clearTimeout(timeout3);
           runningFunc.process.stdout?.off("data", onData);
-          resolve12(runningFunc.port);
+          resolve13(runningFunc.port);
         }
       };
       runningFunc.process.stdout?.on("data", onData);
@@ -255223,22 +255600,22 @@ class Database {
     this.schemas.clear();
   }
   validate(entityName, record2, partial2 = false) {
-    const schema10 = this.schemas.get(this.normalizeName(entityName));
-    if (!schema10) {
+    const schema11 = this.schemas.get(this.normalizeName(entityName));
+    if (!schema11) {
       throw new Error(`Entity "${entityName}" not found`);
     }
-    return this.validator.validate(record2, schema10, partial2);
+    return this.validator.validate(record2, schema11, partial2);
   }
   prepareRecord(entityName, record2, partial2 = false) {
-    const schema10 = this.schemas.get(this.normalizeName(entityName));
-    if (!schema10) {
+    const schema11 = this.schemas.get(this.normalizeName(entityName));
+    if (!schema11) {
       throw new Error(`Entity "${entityName}" not found`);
     }
-    const filteredRecord = this.validator.filterFields(record2, schema10);
+    const filteredRecord = this.validator.filterFields(record2, schema11);
     if (partial2) {
       return filteredRecord;
     }
-    return this.validator.applyDefaults(filteredRecord, schema10);
+    return this.validator.applyDefaults(filteredRecord, schema11);
   }
   normalizeName(entityName) {
     return entityName.toLowerCase();
@@ -255532,13 +255909,13 @@ function checkRLS(rule, record2, user) {
     return false;
   return evaluateCondition(rule, record2, user);
 }
-function applyFLS(record2, schema10, user, operation) {
+function applyFLS(record2, schema11, user, operation) {
   if (Array.isArray(record2)) {
-    return record2.map((r5) => applyFLS(r5, schema10, user, operation));
+    return record2.map((r5) => applyFLS(r5, schema11, user, operation));
   }
   const result = {};
   for (const [key2, value] of Object.entries(record2)) {
-    const rule = schema10.properties[key2]?.rls?.[operation];
+    const rule = schema11.properties[key2]?.rls?.[operation];
     if (rule === undefined || checkRLS(rule, record2, user)) {
       result[key2] = value;
     }
@@ -255766,14 +256143,14 @@ async function createEntityRoutes(db2, logger2, broadcast) {
         res.status(404).json({ error: `Entity "${entityName}" not found` });
         return;
       }
-      const schema10 = db2.getSchema(entityName);
-      if (!schema10) {
+      const schema11 = db2.getSchema(entityName);
+      if (!schema11) {
         res.status(404).json({ error: `Schema for "${entityName}" not found` });
         return;
       }
       const currentUserResult = await resolveCurrentUser(db2, req);
       const currentUser = currentUserResult.ok ? currentUserResult.user : undefined;
-      await handler(req, res, collection, schema10, currentUser);
+      await handler(req, res, collection, schema11, currentUser);
     };
   }
   function emit(appId, entityName, type, data) {
@@ -255791,19 +256168,19 @@ async function createEntityRoutes(db2, logger2, broadcast) {
     }
     broadcast(appId, entityName, createData(data));
   }
-  function prepareCreateRecord(entityName, body, schema10, currentUser, now) {
+  function prepareCreateRecord(entityName, body, schema11, currentUser, now) {
     const { _id, ...recordBody } = body;
     const ownerFields = {
       created_by: currentUser?.email,
       created_by_id: currentUser?.id
     };
-    if (!checkRLS(schema10.rls?.create, {
+    if (!checkRLS(schema11.rls?.create, {
       ...recordBody,
       ...ownerFields
     }, currentUser)) {
       return;
     }
-    const filteredBody = applyFLS(db2.prepareRecord(entityName, recordBody), schema10, currentUser, "write");
+    const filteredBody = applyFLS(db2.prepareRecord(entityName, recordBody), schema11, currentUser, "write");
     db2.validate(entityName, filteredBody);
     return {
       ...filteredBody,
@@ -255815,7 +256192,7 @@ async function createEntityRoutes(db2, logger2, broadcast) {
   }
   const userRouter = createUserRouter(db2, logger2);
   router.use("/User", userRouter);
-  router.get("/:entityName/:id", withCollection(async (req, res, collection, schema10, currentUser) => {
+  router.get("/:entityName/:id", withCollection(async (req, res, collection, schema11, currentUser) => {
     const { entityName, id: id2 } = req.params;
     try {
       const doc2 = await collection.findOneAsync({ id: id2 });
@@ -255823,27 +256200,27 @@ async function createEntityRoutes(db2, logger2, broadcast) {
         res.status(404).json({ error: `Record with id "${id2}" not found` });
         return;
       }
-      if (!checkRLS(schema10.rls?.read, doc2, currentUser)) {
+      if (!checkRLS(schema11.rls?.read, doc2, currentUser)) {
         res.status(404).json({
           message: `Entity ${entityName} with ID ${id2} not found`
         });
         return;
       }
-      const result = applyFLS(stripInternalFields(doc2), schema10, currentUser, "read");
+      const result = applyFLS(stripInternalFields(doc2), schema11, currentUser, "read");
       res.json(result);
     } catch (error48) {
       logger2.error(`Error in GET /${entityName}/${id2}:`, error48);
       res.status(500).json({ error: "Internal server error" });
     }
   }));
-  router.get("/:entityName", withCollection(async (req, res, collection, schema10, currentUser) => {
+  router.get("/:entityName", withCollection(async (req, res, collection, schema11, currentUser) => {
     const { entityName } = req.params;
     try {
       let results = stripInternalFields(await queryEntity(collection, req.query));
-      if (schema10.rls?.read !== undefined && schema10.rls.read !== true) {
-        results = results.filter((doc2) => checkRLS(schema10.rls.read, doc2, currentUser));
+      if (schema11.rls?.read !== undefined && schema11.rls.read !== true) {
+        results = results.filter((doc2) => checkRLS(schema11.rls.read, doc2, currentUser));
       }
-      results = results.map((doc2) => applyFLS(doc2, schema10, currentUser, "read"));
+      results = results.map((doc2) => applyFLS(doc2, schema11, currentUser, "read"));
       res.json(results);
     } catch (error48) {
       if (error48 instanceof InvalidInputError) {
@@ -255854,16 +256231,16 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       }
     }
   }));
-  router.post("/:entityName", parseBody, withCollection(async (req, res, collection, schema10, currentUser) => {
+  router.post("/:entityName", parseBody, withCollection(async (req, res, collection, schema11, currentUser) => {
     const { appId, entityName } = req.params;
     try {
       const now = new Date().toISOString();
-      const record2 = prepareCreateRecord(entityName, req.body, schema10, currentUser, now);
+      const record2 = prepareCreateRecord(entityName, req.body, schema11, currentUser, now);
       if (!record2) {
         res.status(403).json({ error: "Permission denied" });
         return;
       }
-      const inserted = applyFLS(stripInternalFields(await collection.insertAsync(record2)), schema10, currentUser, "read");
+      const inserted = applyFLS(stripInternalFields(await collection.insertAsync(record2)), schema11, currentUser, "read");
       emit(appId, entityName, "create", inserted);
       res.status(201).json(inserted);
     } catch (error48) {
@@ -255875,7 +256252,7 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       res.status(500).json({ error: "Internal server error" });
     }
   }));
-  router.post("/:entityName/bulk", parseBody, withCollection(async (req, res, collection, schema10, currentUser) => {
+  router.post("/:entityName/bulk", parseBody, withCollection(async (req, res, collection, schema11, currentUser) => {
     const { appId, entityName } = req.params;
     if (!Array.isArray(req.body)) {
       res.status(400).json({ error: "Request body must be an array" });
@@ -255885,14 +256262,14 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       const now = new Date().toISOString();
       const records = [];
       for (const body of req.body) {
-        const record2 = prepareCreateRecord(entityName, body, schema10, currentUser, now);
+        const record2 = prepareCreateRecord(entityName, body, schema11, currentUser, now);
         if (!record2) {
           res.status(403).json({ error: "Permission denied" });
           return;
         }
         records.push(record2);
       }
-      const inserted = applyFLS(stripInternalFields(await collection.insertAsync(records)), schema10, currentUser, "read");
+      const inserted = applyFLS(stripInternalFields(await collection.insertAsync(records)), schema11, currentUser, "read");
       emit(appId, entityName, "create", inserted);
       res.status(201).json(inserted);
     } catch (error48) {
@@ -255904,24 +256281,24 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       res.status(500).json({ error: "Internal server error" });
     }
   }));
-  router.put("/:entityName/:id", parseBody, withCollection(async (req, res, collection, schema10, currentUser) => {
+  router.put("/:entityName/:id", parseBody, withCollection(async (req, res, collection, schema11, currentUser) => {
     const { appId, entityName, id: id2 } = req.params;
     const { id: _id, created_date: _created_date, ...body } = req.body;
     try {
-      if (schema10.rls?.update !== undefined) {
+      if (schema11.rls?.update !== undefined) {
         const existing = await collection.findOneAsync({ id: id2 });
         if (!existing) {
           res.status(404).json({ error: `Record with id "${id2}" not found` });
           return;
         }
-        if (!checkRLS(schema10.rls.update, existing, currentUser)) {
+        if (!checkRLS(schema11.rls.update, existing, currentUser)) {
           res.status(404).json({
             message: `Entity ${entityName} with ID ${id2} not found`
           });
           return;
         }
       }
-      const filteredBody = applyFLS(db2.prepareRecord(entityName, body, true), schema10, currentUser, "write");
+      const filteredBody = applyFLS(db2.prepareRecord(entityName, body, true), schema11, currentUser, "write");
       db2.validate(entityName, filteredBody, true);
       const updateData = {
         ...filteredBody,
@@ -255932,7 +256309,7 @@ async function createEntityRoutes(db2, logger2, broadcast) {
         res.status(404).json({ error: `Record with id "${id2}" not found` });
         return;
       }
-      const updated = applyFLS(stripInternalFields(result.affectedDocuments), schema10, currentUser, "read");
+      const updated = applyFLS(stripInternalFields(result.affectedDocuments), schema11, currentUser, "read");
       emit(appId, entityName, "update", updated);
       res.json(updated);
     } catch (error48) {
@@ -255944,7 +256321,7 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       res.status(500).json({ error: "Internal server error" });
     }
   }));
-  router.delete("/:entityName/:id", withCollection(async (req, res, collection, schema10, currentUser) => {
+  router.delete("/:entityName/:id", withCollection(async (req, res, collection, schema11, currentUser) => {
     const { appId, entityName, id: id2 } = req.params;
     try {
       const doc2 = await collection.findOneAsync({ id: id2 });
@@ -255952,7 +256329,7 @@ async function createEntityRoutes(db2, logger2, broadcast) {
         res.status(404).json({ error: `Record with id "${id2}" not found` });
         return;
       }
-      if (!checkRLS(schema10.rls?.delete, doc2, currentUser)) {
+      if (!checkRLS(schema11.rls?.delete, doc2, currentUser)) {
         res.status(404).json({
           message: `Entity ${entityName} with ID ${id2} not found`
         });
@@ -255966,11 +256343,11 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       res.status(500).json({ error: "Internal server error" });
     }
   }));
-  router.delete("/:entityName", parseBody, withCollection(async (req, res, collection, schema10, currentUser) => {
+  router.delete("/:entityName", parseBody, withCollection(async (req, res, collection, schema11, currentUser) => {
     const { entityName } = req.params;
     try {
       const query = req.body || {};
-      const rlsDelete = schema10?.rls?.delete;
+      const rlsDelete = schema11?.rls?.delete;
       if (rlsDelete !== undefined && rlsDelete !== true) {
         if (rlsDelete === false && currentUser?.is_service !== true) {
           res.status(403).json({ error: "Permission denied" });
@@ -256135,15 +256512,15 @@ class ServeRunner {
       return;
     }
     this.stopping = true;
-    const exited = new Promise((resolve12) => child.once("exit", () => resolve12()));
+    const exited = new Promise((resolve13) => child.once("exit", () => resolve13()));
     if (process21.platform === "win32" && child.pid) {
       const taskkill = spawn3("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
         stdio: "ignore",
         windowsHide: true
       });
-      await new Promise((resolve12) => {
-        taskkill.once("exit", () => resolve12());
-        taskkill.once("error", () => resolve12());
+      await new Promise((resolve13) => {
+        taskkill.once("exit", () => resolve13());
+        taskkill.once("error", () => resolve13());
       });
     } else if (child.pid) {
       try {
@@ -257037,7 +257414,7 @@ class NodeFsHandler {
         this._addToNodeFs(path19, initialAdd, wh2, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
-    return new Promise((resolve13, reject) => {
+    return new Promise((resolve14, reject) => {
       if (!stream)
         return reject();
       stream.once(STR_END, () => {
@@ -257046,7 +257423,7 @@ class NodeFsHandler {
           return;
         }
         const wasThrottled = throttler ? throttler.clear() : false;
-        resolve13(undefined);
+        resolve14(undefined);
         previous.getChildren().filter((item) => {
           return item !== directory && !current.has(item);
         }).forEach((item) => {
@@ -257963,7 +258340,7 @@ async function createDevServer(options8) {
     }
     remoteProxy(req, res, next);
   });
-  const server = await new Promise((resolve14, reject) => {
+  const server = await new Promise((resolve15, reject) => {
     const s5 = app.listen(port, "127.0.0.1", (err) => {
       if (err) {
         if ("code" in err && err.code === "EADDRINUSE") {
@@ -257972,7 +258349,7 @@ async function createDevServer(options8) {
           reject(err);
         }
       } else {
-        resolve14(s5);
+        resolve15(s5);
       }
     });
   });
@@ -258035,13 +258412,13 @@ async function createDevServer(options8) {
     if (!server.listening) {
       return;
     }
-    await new Promise((resolve14, reject) => {
+    await new Promise((resolve15, reject) => {
       server.close((error48) => {
         if (error48) {
           reject(error48);
           return;
         }
-        resolve14();
+        resolve15();
       });
     });
   };
@@ -258150,13 +258527,13 @@ async function runScript(options8) {
 }
 // src/cli/commands/exec.ts
 function readStdin2() {
-  return new Promise((resolve14, reject) => {
+  return new Promise((resolve15, reject) => {
     let data = "";
     process.stdin.setEncoding("utf-8");
     process.stdin.on("data", (chunk) => {
       data += chunk;
     });
-    process.stdin.on("end", () => resolve14(data));
+    process.stdin.on("end", () => resolve15(data));
     process.stdin.on("error", reject);
   });
 }
@@ -258198,7 +258575,7 @@ Examples:
 }
 
 // src/cli/commands/project/eject.ts
-import { resolve as resolve14 } from "node:path";
+import { resolve as resolve15 } from "node:path";
 var import_kebabCase2 = __toESM(require_kebabCase(), 1);
 async function eject(ctx, options8, command2) {
   const { log, runTask: runTask2, isNonInteractive } = ctx;
@@ -258262,7 +258639,7 @@ async function eject(ctx, options8, command2) {
     Ne("Operation cancelled.");
     throw new CLIExitError(0);
   }
-  const resolvedPath = resolve14(selectedPath);
+  const resolvedPath = resolve15(selectedPath);
   await runTask2("Downloading your project's code...", async (updateMessage) => {
     await createProjectFilesForExistingProject({
       projectId,
@@ -258325,8 +258702,10 @@ function createProgram(context) {
   program2.addCommand(getScaffoldCommand());
   program2.addCommand(getDashboardCommand());
   program2.addCommand(getDeployCommand2());
+  program2.addCommand(getVisibilityCommand());
   program2.addCommand(getLinkCommand());
   program2.addCommand(getEjectCommand());
+  program2.addCommand(getWorkspaceCommand());
   program2.addCommand(getEntitiesPushCommand());
   program2.addCommand(getAgentsCommand());
   program2.addCommand(getConnectorsCommand());
@@ -260634,14 +261013,14 @@ async function addSourceContext(frames) {
   return frames;
 }
 function getContextLinesFromFile(path19, ranges, output) {
-  return new Promise((resolve15) => {
+  return new Promise((resolve16) => {
     const stream = createReadStream2(path19);
     const lineReaded = createInterface2({
       input: stream
     });
     function destroyStreamAndResolve() {
       stream.destroy();
-      resolve15();
+      resolve16();
     }
     let lineNumber = 0;
     let currentRangeIndex = 0;
@@ -261753,15 +262132,15 @@ class PostHogBackendClient extends PostHogCoreStateless {
       return true;
     if (this.featureFlagsPoller === undefined)
       return false;
-    return new Promise((resolve15) => {
+    return new Promise((resolve16) => {
       const timeout3 = setTimeout(() => {
         cleanup();
-        resolve15(false);
+        resolve16(false);
       }, timeoutMs);
       const cleanup = this._events.on("localEvaluationFlagsLoaded", (count2) => {
         clearTimeout(timeout3);
         cleanup();
-        resolve15(count2 > 0);
+        resolve16(count2 > 0);
       });
     });
   }
@@ -262586,4 +262965,4 @@ export {
   CLIExitError
 };
 
-//# debugId=611A3D05C584224D64756E2164756E21
+//# debugId=B9D4F09248278B0364756E2164756E21