@base44-preview/cli 0.0.37-pr.362.d9c1e3b → 0.0.37-pr.364.15494ed

package/dist/cli/index.js

@@ -13211,58 +13211,34 @@ var require_cross_spawn = __commonJS((exports, module) => {
   module.exports._enoent = enoent;
 });
 
-// node_modules/lodash.kebabcase/index.js
-var require_lodash = __commonJS((exports, module) => {
-  var INFINITY = 1 / 0;
-  var symbolTag = "[object Symbol]";
-  var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
-  var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
-  var rsAstralRange = "\\ud800-\\udfff";
-  var rsComboMarksRange = "\\u0300-\\u036f\\ufe20-\\ufe23";
-  var rsComboSymbolsRange = "\\u20d0-\\u20f0";
-  var rsDingbatRange = "\\u2700-\\u27bf";
-  var rsLowerRange = "a-z\\xdf-\\xf6\\xf8-\\xff";
-  var rsMathOpRange = "\\xac\\xb1\\xd7\\xf7";
-  var rsNonCharRange = "\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf";
-  var rsPunctuationRange = "\\u2000-\\u206f";
-  var rsSpaceRange = " \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000";
-  var rsUpperRange = "A-Z\\xc0-\\xd6\\xd8-\\xde";
-  var rsVarRange = "\\ufe0e\\ufe0f";
-  var rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;
-  var rsApos = "['’]";
-  var rsBreak = "[" + rsBreakRange + "]";
-  var rsCombo = "[" + rsComboMarksRange + rsComboSymbolsRange + "]";
-  var rsDigits = "\\d+";
-  var rsDingbat = "[" + rsDingbatRange + "]";
-  var rsLower = "[" + rsLowerRange + "]";
-  var rsMisc = "[^" + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + "]";
-  var rsFitz = "\\ud83c[\\udffb-\\udfff]";
-  var rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")";
-  var rsNonAstral = "[^" + rsAstralRange + "]";
-  var rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}";
-  var rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]";
-  var rsUpper = "[" + rsUpperRange + "]";
-  var rsZWJ = "\\u200d";
-  var rsLowerMisc = "(?:" + rsLower + "|" + rsMisc + ")";
-  var rsUpperMisc = "(?:" + rsUpper + "|" + rsMisc + ")";
-  var rsOptLowerContr = "(?:" + rsApos + "(?:d|ll|m|re|s|t|ve))?";
-  var rsOptUpperContr = "(?:" + rsApos + "(?:D|LL|M|RE|S|T|VE))?";
-  var reOptMod = rsModifier + "?";
-  var rsOptVar = "[" + rsVarRange + "]?";
-  var rsOptJoin = "(?:" + rsZWJ + "(?:" + [rsNonAstral, rsRegional, rsSurrPair].join("|") + ")" + rsOptVar + reOptMod + ")*";
-  var rsSeq = rsOptVar + reOptMod + rsOptJoin;
-  var rsEmoji = "(?:" + [rsDingbat, rsRegional, rsSurrPair].join("|") + ")" + rsSeq;
-  var reApos = RegExp(rsApos, "g");
-  var reComboMark = RegExp(rsCombo, "g");
-  var reUnicodeWord = RegExp([
-    rsUpper + "?" + rsLower + "+" + rsOptLowerContr + "(?=" + [rsBreak, rsUpper, "$"].join("|") + ")",
-    rsUpperMisc + "+" + rsOptUpperContr + "(?=" + [rsBreak, rsUpper + rsLowerMisc, "$"].join("|") + ")",
-    rsUpper + "?" + rsLowerMisc + "+" + rsOptLowerContr,
-    rsUpper + "+" + rsOptUpperContr,
-    rsDigits,
-    rsEmoji
-  ].join("|"), "g");
-  var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2,}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
+// node_modules/lodash/_arrayReduce.js
+var require__arrayReduce = __commonJS((exports, module) => {
+  function arrayReduce(array2, iteratee, accumulator, initAccum) {
+    var index = -1, length = array2 == null ? 0 : array2.length;
+    if (initAccum && length) {
+      accumulator = array2[++index];
+    }
+    while (++index < length) {
+      accumulator = iteratee(accumulator, array2[index], index, array2);
+    }
+    return accumulator;
+  }
+  module.exports = arrayReduce;
+});
+
+// node_modules/lodash/_basePropertyOf.js
+var require__basePropertyOf = __commonJS((exports, module) => {
+  function basePropertyOf(object2) {
+    return function(key) {
+      return object2 == null ? undefined : object2[key];
+    };
+  }
+  module.exports = basePropertyOf;
+});
+
+// node_modules/lodash/_deburrLetter.js
+var require__deburrLetter = __commonJS((exports, module) => {
+  var basePropertyOf = require__basePropertyOf();
   var deburredLetters = {
     "À": "A",
     "Á": "A",
@@ -13453,72 +13429,256 @@ var require_lodash = __commonJS((exports, module) => {
     "Œ": "Oe",
     "œ": "oe",
     "ʼn": "'n",
-    "ſ": "ss"
+    "ſ": "s"
   };
+  var deburrLetter = basePropertyOf(deburredLetters);
+  module.exports = deburrLetter;
+});
+
+// node_modules/lodash/_freeGlobal.js
+var require__freeGlobal = __commonJS((exports, module) => {
   var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+  module.exports = freeGlobal;
+});
+
+// node_modules/lodash/_root.js
+var require__root = __commonJS((exports, module) => {
+  var freeGlobal = require__freeGlobal();
   var freeSelf = typeof self == "object" && self && self.Object === Object && self;
   var root = freeGlobal || freeSelf || Function("return this")();
-  function arrayReduce(array2, iteratee, accumulator, initAccum) {
-    var index = -1, length = array2 ? array2.length : 0;
-    if (initAccum && length) {
-      accumulator = array2[++index];
-    }
+  module.exports = root;
+});
+
+// node_modules/lodash/_Symbol.js
+var require__Symbol = __commonJS((exports, module) => {
+  var root = require__root();
+  var Symbol2 = root.Symbol;
+  module.exports = Symbol2;
+});
+
+// node_modules/lodash/_arrayMap.js
+var require__arrayMap = __commonJS((exports, module) => {
+  function arrayMap(array2, iteratee) {
+    var index = -1, length = array2 == null ? 0 : array2.length, result = Array(length);
     while (++index < length) {
-      accumulator = iteratee(accumulator, array2[index], index, array2);
+      result[index] = iteratee(array2[index], index, array2);
     }
-    return accumulator;
+    return result;
   }
-  function asciiWords(string4) {
-    return string4.match(reAsciiWord) || [];
+  module.exports = arrayMap;
+});
+
+// node_modules/lodash/isArray.js
+var require_isArray = __commonJS((exports, module) => {
+  var isArray = Array.isArray;
+  module.exports = isArray;
+});
+
+// node_modules/lodash/_getRawTag.js
+var require__getRawTag = __commonJS((exports, module) => {
+  var Symbol2 = require__Symbol();
+  var objectProto = Object.prototype;
+  var hasOwnProperty = objectProto.hasOwnProperty;
+  var nativeObjectToString = objectProto.toString;
+  var symToStringTag = Symbol2 ? Symbol2.toStringTag : undefined;
+  function getRawTag(value) {
+    var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+    try {
+      value[symToStringTag] = undefined;
+      var unmasked = true;
+    } catch (e2) {}
+    var result = nativeObjectToString.call(value);
+    if (unmasked) {
+      if (isOwn) {
+        value[symToStringTag] = tag;
+      } else {
+        delete value[symToStringTag];
+      }
+    }
+    return result;
   }
-  function basePropertyOf(object2) {
-    return function(key) {
-      return object2 == null ? undefined : object2[key];
-    };
+  module.exports = getRawTag;
+});
+
+// node_modules/lodash/_objectToString.js
+var require__objectToString = __commonJS((exports, module) => {
+  var objectProto = Object.prototype;
+  var nativeObjectToString = objectProto.toString;
+  function objectToString3(value) {
+    return nativeObjectToString.call(value);
   }
-  var deburrLetter = basePropertyOf(deburredLetters);
-  function hasUnicodeWord(string4) {
-    return reHasUnicodeWord.test(string4);
+  module.exports = objectToString3;
+});
+
+// node_modules/lodash/_baseGetTag.js
+var require__baseGetTag = __commonJS((exports, module) => {
+  var Symbol2 = require__Symbol();
+  var getRawTag = require__getRawTag();
+  var objectToString3 = require__objectToString();
+  var nullTag = "[object Null]";
+  var undefinedTag = "[object Undefined]";
+  var symToStringTag = Symbol2 ? Symbol2.toStringTag : undefined;
+  function baseGetTag(value) {
+    if (value == null) {
+      return value === undefined ? undefinedTag : nullTag;
+    }
+    return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString3(value);
   }
-  function unicodeWords(string4) {
-    return string4.match(reUnicodeWord) || [];
+  module.exports = baseGetTag;
+});
+
+// node_modules/lodash/isObjectLike.js
+var require_isObjectLike = __commonJS((exports, module) => {
+  function isObjectLike(value) {
+    return value != null && typeof value == "object";
   }
-  var objectProto = Object.prototype;
-  var objectToString3 = objectProto.toString;
-  var Symbol2 = root.Symbol;
+  module.exports = isObjectLike;
+});
+
+// node_modules/lodash/isSymbol.js
+var require_isSymbol = __commonJS((exports, module) => {
+  var baseGetTag = require__baseGetTag();
+  var isObjectLike = require_isObjectLike();
+  var symbolTag = "[object Symbol]";
+  function isSymbol(value) {
+    return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag;
+  }
+  module.exports = isSymbol;
+});
+
+// node_modules/lodash/_baseToString.js
+var require__baseToString = __commonJS((exports, module) => {
+  var Symbol2 = require__Symbol();
+  var arrayMap = require__arrayMap();
+  var isArray = require_isArray();
+  var isSymbol = require_isSymbol();
+  var INFINITY = 1 / 0;
   var symbolProto = Symbol2 ? Symbol2.prototype : undefined;
   var symbolToString = symbolProto ? symbolProto.toString : undefined;
   function baseToString(value) {
     if (typeof value == "string") {
       return value;
     }
+    if (isArray(value)) {
+      return arrayMap(value, baseToString) + "";
+    }
     if (isSymbol(value)) {
       return symbolToString ? symbolToString.call(value) : "";
     }
     var result = value + "";
     return result == "0" && 1 / value == -INFINITY ? "-0" : result;
   }
-  function createCompounder(callback) {
-    return function(string4) {
-      return arrayReduce(words(deburr(string4).replace(reApos, "")), callback, "");
-    };
-  }
-  function isObjectLike(value) {
-    return !!value && typeof value == "object";
-  }
-  function isSymbol(value) {
-    return typeof value == "symbol" || isObjectLike(value) && objectToString3.call(value) == symbolTag;
-  }
+  module.exports = baseToString;
+});
+
+// node_modules/lodash/toString.js
+var require_toString = __commonJS((exports, module) => {
+  var baseToString = require__baseToString();
   function toString2(value) {
     return value == null ? "" : baseToString(value);
   }
+  module.exports = toString2;
+});
+
+// node_modules/lodash/deburr.js
+var require_deburr = __commonJS((exports, module) => {
+  var deburrLetter = require__deburrLetter();
+  var toString2 = require_toString();
+  var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
+  var rsComboMarksRange = "\\u0300-\\u036f";
+  var reComboHalfMarksRange = "\\ufe20-\\ufe2f";
+  var rsComboSymbolsRange = "\\u20d0-\\u20ff";
+  var rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange;
+  var rsCombo = "[" + rsComboRange + "]";
+  var reComboMark = RegExp(rsCombo, "g");
   function deburr(string4) {
     string4 = toString2(string4);
     return string4 && string4.replace(reLatin, deburrLetter).replace(reComboMark, "");
   }
-  var kebabCase = createCompounder(function(result, word, index) {
-    return result + (index ? "-" : "") + word.toLowerCase();
-  });
+  module.exports = deburr;
+});
+
+// node_modules/lodash/_asciiWords.js
+var require__asciiWords = __commonJS((exports, module) => {
+  var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
+  function asciiWords(string4) {
+    return string4.match(reAsciiWord) || [];
+  }
+  module.exports = asciiWords;
+});
+
+// node_modules/lodash/_hasUnicodeWord.js
+var require__hasUnicodeWord = __commonJS((exports, module) => {
+  var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
+  function hasUnicodeWord(string4) {
+    return reHasUnicodeWord.test(string4);
+  }
+  module.exports = hasUnicodeWord;
+});
+
+// node_modules/lodash/_unicodeWords.js
+var require__unicodeWords = __commonJS((exports, module) => {
+  var rsAstralRange = "\\ud800-\\udfff";
+  var rsComboMarksRange = "\\u0300-\\u036f";
+  var reComboHalfMarksRange = "\\ufe20-\\ufe2f";
+  var rsComboSymbolsRange = "\\u20d0-\\u20ff";
+  var rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange;
+  var rsDingbatRange = "\\u2700-\\u27bf";
+  var rsLowerRange = "a-z\\xdf-\\xf6\\xf8-\\xff";
+  var rsMathOpRange = "\\xac\\xb1\\xd7\\xf7";
+  var rsNonCharRange = "\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf";
+  var rsPunctuationRange = "\\u2000-\\u206f";
+  var rsSpaceRange = " \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000";
+  var rsUpperRange = "A-Z\\xc0-\\xd6\\xd8-\\xde";
+  var rsVarRange = "\\ufe0e\\ufe0f";
+  var rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;
+  var rsApos = "['’]";
+  var rsBreak = "[" + rsBreakRange + "]";
+  var rsCombo = "[" + rsComboRange + "]";
+  var rsDigits = "\\d+";
+  var rsDingbat = "[" + rsDingbatRange + "]";
+  var rsLower = "[" + rsLowerRange + "]";
+  var rsMisc = "[^" + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + "]";
+  var rsFitz = "\\ud83c[\\udffb-\\udfff]";
+  var rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")";
+  var rsNonAstral = "[^" + rsAstralRange + "]";
+  var rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}";
+  var rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]";
+  var rsUpper = "[" + rsUpperRange + "]";
+  var rsZWJ = "\\u200d";
+  var rsMiscLower = "(?:" + rsLower + "|" + rsMisc + ")";
+  var rsMiscUpper = "(?:" + rsUpper + "|" + rsMisc + ")";
+  var rsOptContrLower = "(?:" + rsApos + "(?:d|ll|m|re|s|t|ve))?";
+  var rsOptContrUpper = "(?:" + rsApos + "(?:D|LL|M|RE|S|T|VE))?";
+  var reOptMod = rsModifier + "?";
+  var rsOptVar = "[" + rsVarRange + "]?";
+  var rsOptJoin = "(?:" + rsZWJ + "(?:" + [rsNonAstral, rsRegional, rsSurrPair].join("|") + ")" + rsOptVar + reOptMod + ")*";
+  var rsOrdLower = "\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])";
+  var rsOrdUpper = "\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])";
+  var rsSeq = rsOptVar + reOptMod + rsOptJoin;
+  var rsEmoji = "(?:" + [rsDingbat, rsRegional, rsSurrPair].join("|") + ")" + rsSeq;
+  var reUnicodeWord = RegExp([
+    rsUpper + "?" + rsLower + "+" + rsOptContrLower + "(?=" + [rsBreak, rsUpper, "$"].join("|") + ")",
+    rsMiscUpper + "+" + rsOptContrUpper + "(?=" + [rsBreak, rsUpper + rsMiscLower, "$"].join("|") + ")",
+    rsUpper + "?" + rsMiscLower + "+" + rsOptContrLower,
+    rsUpper + "+" + rsOptContrUpper,
+    rsOrdUpper,
+    rsOrdLower,
+    rsDigits,
+    rsEmoji
+  ].join("|"), "g");
+  function unicodeWords(string4) {
+    return string4.match(reUnicodeWord) || [];
+  }
+  module.exports = unicodeWords;
+});
+
+// node_modules/lodash/words.js
+var require_words = __commonJS((exports, module) => {
+  var asciiWords = require__asciiWords();
+  var hasUnicodeWord = require__hasUnicodeWord();
+  var toString2 = require_toString();
+  var unicodeWords = require__unicodeWords();
   function words(string4, pattern, guard) {
     string4 = toString2(string4);
     pattern = guard ? undefined : pattern;
@@ -13527,6 +13687,30 @@ var require_lodash = __commonJS((exports, module) => {
     }
     return string4.match(pattern) || [];
   }
+  module.exports = words;
+});
+
+// node_modules/lodash/_createCompounder.js
+var require__createCompounder = __commonJS((exports, module) => {
+  var arrayReduce = require__arrayReduce();
+  var deburr = require_deburr();
+  var words = require_words();
+  var rsApos = "['’]";
+  var reApos = RegExp(rsApos, "g");
+  function createCompounder(callback) {
+    return function(string4) {
+      return arrayReduce(words(deburr(string4).replace(reApos, "")), callback, "");
+    };
+  }
+  module.exports = createCompounder;
+});
+
+// node_modules/lodash/kebabCase.js
+var require_kebabCase = __commonJS((exports, module) => {
+  var createCompounder = require__createCompounder();
+  var kebabCase = createCompounder(function(result, word, index) {
+    return result + (index ? "-" : "") + word.toLowerCase();
+  });
   module.exports = kebabCase;
 });
 
@@ -14609,7 +14793,7 @@ var require_lib2 = __commonJS((exports) => {
 });
 
 // node_modules/lodash/lodash.js
-var require_lodash2 = __commonJS((exports, module) => {
+var require_lodash = __commonJS((exports, module) => {
   (function() {
     var undefined2;
     var VERSION = "4.17.23";
@@ -127599,7 +127783,7 @@ var require_AST = __commonJS((exports) => {
 var require_JSONSchema = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.isCompound = exports.isPrimitive = exports.isBoolean = exports.getRootSchema = exports.Intersection = exports.Types = exports.Parent = undefined;
-  var lodash_1 = require_lodash2();
+  var lodash_1 = require_lodash();
   exports.Parent = Symbol("Parent");
   exports.Types = Symbol("Types");
   exports.Intersection = Symbol("Intersection");
@@ -130406,7 +130590,7 @@ var require_utils7 = __commonJS((exports) => {
   };
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.parseFileAsJSONSchema = exports.isSchemaLike = exports.appendToDescription = exports.maybeStripDefault = exports.pathTransform = exports.escapeBlockComment = exports.log = exports.error = exports.generateName = exports.toSafeString = exports.stripExtension = exports.justName = exports.traverse = exports.Try = undefined;
-  var lodash_1 = require_lodash2();
+  var lodash_1 = require_lodash();
   var path_1 = __require("path");
   var JSONSchema_1 = require_JSONSchema();
   var js_yaml_1 = __importDefault(require_js_yaml3());
@@ -130737,7 +130921,7 @@ ${values.join(`
 var require_generator = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.generateType = exports.generate = undefined;
-  var lodash_1 = require_lodash2();
+  var lodash_1 = require_lodash();
   var index_1 = require_src3();
   var AST_1 = require_AST();
   var utils_1 = require_utils7();
@@ -131000,7 +131184,7 @@ var require_generator = __commonJS((exports) => {
 var require_typesOfSchema = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.typesOfSchema = undefined;
-  var lodash_1 = require_lodash2();
+  var lodash_1 = require_lodash();
   var JSONSchema_1 = require_JSONSchema();
   function typesOfSchema(schema9) {
     if (schema9.tsType) {
@@ -131359,7 +131543,7 @@ var require_normalizer = __commonJS((exports) => {
 var require_optimizer = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.optimize = undefined;
-  var lodash_1 = require_lodash2();
+  var lodash_1 = require_lodash();
   var generator_1 = require_generator();
   var AST_1 = require_AST();
   var utils_1 = require_utils7();
@@ -131425,7 +131609,7 @@ var require_optimizer = __commonJS((exports) => {
 var require_parser = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.parse = undefined;
-  var lodash_1 = require_lodash2();
+  var lodash_1 = require_lodash();
   var util_1 = __require("util");
   var applySchemaTyping_1 = require_applySchemaTyping();
   var AST_1 = require_AST();
@@ -137278,7 +137462,7 @@ var require_linker = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.link = undefined;
   var JSONSchema_1 = require_JSONSchema();
-  var lodash_1 = require_lodash2();
+  var lodash_1 = require_lodash();
   function link2(schema9, parent = null) {
     if (!Array.isArray(schema9) && !(0, lodash_1.isPlainObject)(schema9)) {
       return schema9;
@@ -137346,7 +137530,7 @@ var require_src3 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.ValidationError = exports.compile = exports.compileFromFile = exports.DEFAULT_OPTIONS = undefined;
   var fs_1 = __require("fs");
-  var lodash_1 = require_lodash2();
+  var lodash_1 = require_lodash();
   var path_1 = __require("path");
   var formatter_1 = require_formatter();
   var generator_1 = require_generator();
@@ -210218,6 +210402,168 @@ var require_multer = __commonJS((exports, module) => {
   module.exports.MulterError = MulterError;
 });
 
+// node_modules/lodash/isObject.js
+var require_isObject = __commonJS((exports, module) => {
+  function isObject5(value) {
+    var type = typeof value;
+    return value != null && (type == "object" || type == "function");
+  }
+  module.exports = isObject5;
+});
+
+// node_modules/lodash/now.js
+var require_now = __commonJS((exports, module) => {
+  var root2 = require__root();
+  var now = function() {
+    return root2.Date.now();
+  };
+  module.exports = now;
+});
+
+// node_modules/lodash/_trimmedEndIndex.js
+var require__trimmedEndIndex = __commonJS((exports, module) => {
+  var reWhitespace = /\s/;
+  function trimmedEndIndex(string4) {
+    var index = string4.length;
+    while (index-- && reWhitespace.test(string4.charAt(index))) {}
+    return index;
+  }
+  module.exports = trimmedEndIndex;
+});
+
+// node_modules/lodash/_baseTrim.js
+var require__baseTrim = __commonJS((exports, module) => {
+  var trimmedEndIndex = require__trimmedEndIndex();
+  var reTrimStart = /^\s+/;
+  function baseTrim(string4) {
+    return string4 ? string4.slice(0, trimmedEndIndex(string4) + 1).replace(reTrimStart, "") : string4;
+  }
+  module.exports = baseTrim;
+});
+
+// node_modules/lodash/toNumber.js
+var require_toNumber = __commonJS((exports, module) => {
+  var baseTrim = require__baseTrim();
+  var isObject5 = require_isObject();
+  var isSymbol = require_isSymbol();
+  var NAN = 0 / 0;
+  var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+  var reIsBinary = /^0b[01]+$/i;
+  var reIsOctal = /^0o[0-7]+$/i;
+  var freeParseInt = parseInt;
+  function toNumber(value) {
+    if (typeof value == "number") {
+      return value;
+    }
+    if (isSymbol(value)) {
+      return NAN;
+    }
+    if (isObject5(value)) {
+      var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+      value = isObject5(other) ? other + "" : other;
+    }
+    if (typeof value != "string") {
+      return value === 0 ? value : +value;
+    }
+    value = baseTrim(value);
+    var isBinary = reIsBinary.test(value);
+    return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+  }
+  module.exports = toNumber;
+});
+
+// node_modules/lodash/debounce.js
+var require_debounce = __commonJS((exports, module) => {
+  var isObject5 = require_isObject();
+  var now = require_now();
+  var toNumber = require_toNumber();
+  var FUNC_ERROR_TEXT = "Expected a function";
+  var nativeMax = Math.max;
+  var nativeMin = Math.min;
+  function debounce(func, wait, options8) {
+    var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
+    if (typeof func != "function") {
+      throw new TypeError(FUNC_ERROR_TEXT);
+    }
+    wait = toNumber(wait) || 0;
+    if (isObject5(options8)) {
+      leading = !!options8.leading;
+      maxing = "maxWait" in options8;
+      maxWait = maxing ? nativeMax(toNumber(options8.maxWait) || 0, wait) : maxWait;
+      trailing = "trailing" in options8 ? !!options8.trailing : trailing;
+    }
+    function invokeFunc(time3) {
+      var args = lastArgs, thisArg = lastThis;
+      lastArgs = lastThis = undefined;
+      lastInvokeTime = time3;
+      result = func.apply(thisArg, args);
+      return result;
+    }
+    function leadingEdge(time3) {
+      lastInvokeTime = time3;
+      timerId = setTimeout(timerExpired, wait);
+      return leading ? invokeFunc(time3) : result;
+    }
+    function remainingWait(time3) {
+      var timeSinceLastCall = time3 - lastCallTime, timeSinceLastInvoke = time3 - lastInvokeTime, timeWaiting = wait - timeSinceLastCall;
+      return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
+    }
+    function shouldInvoke(time3) {
+      var timeSinceLastCall = time3 - lastCallTime, timeSinceLastInvoke = time3 - lastInvokeTime;
+      return lastCallTime === undefined || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
+    }
+    function timerExpired() {
+      var time3 = now();
+      if (shouldInvoke(time3)) {
+        return trailingEdge(time3);
+      }
+      timerId = setTimeout(timerExpired, remainingWait(time3));
+    }
+    function trailingEdge(time3) {
+      timerId = undefined;
+      if (trailing && lastArgs) {
+        return invokeFunc(time3);
+      }
+      lastArgs = lastThis = undefined;
+      return result;
+    }
+    function cancel() {
+      if (timerId !== undefined) {
+        clearTimeout(timerId);
+      }
+      lastInvokeTime = 0;
+      lastArgs = lastCallTime = lastThis = timerId = undefined;
+    }
+    function flush() {
+      return timerId === undefined ? result : trailingEdge(now());
+    }
+    function debounced() {
+      var time3 = now(), isInvoking = shouldInvoke(time3);
+      lastArgs = arguments;
+      lastThis = this;
+      lastCallTime = time3;
+      if (isInvoking) {
+        if (timerId === undefined) {
+          return leadingEdge(lastCallTime);
+        }
+        if (maxing) {
+          clearTimeout(timerId);
+          timerId = setTimeout(timerExpired, wait);
+          return invokeFunc(lastCallTime);
+        }
+      }
+      if (timerId === undefined) {
+        timerId = setTimeout(timerExpired, wait);
+      }
+      return result;
+    }
+    debounced.cancel = cancel;
+    debounced.flush = flush;
+    return debounced;
+  }
+  module.exports = debounce;
+});
+
 // node_modules/@vercel/detect-agent/dist/index.js
 var require_dist5 = __commonJS((exports, module) => {
   var __defProp4 = Object.defineProperty;
@@ -210243,8 +210589,8 @@ var require_dist5 = __commonJS((exports, module) => {
     determineAgent: () => determineAgent
   });
   module.exports = __toCommonJS(src_exports);
-  var import_promises19 = __require("node:fs/promises");
-  var import_node_fs19 = __require("node:fs");
+  var import_promises22 = __require("node:fs/promises");
+  var import_node_fs21 = __require("node:fs");
   var DEVIN_LOCAL_PATH = "/opt/.devin";
   var CURSOR2 = "cursor";
   var CURSOR_CLI = "cursor-cli";
@@ -210301,7 +210647,7 @@ var require_dist5 = __commonJS((exports, module) => {
       return { isAgent: true, agent: { name: REPLIT } };
     }
     try {
-      await (0, import_promises19.access)(DEVIN_LOCAL_PATH, import_node_fs19.constants.F_OK);
+      await (0, import_promises22.access)(DEVIN_LOCAL_PATH, import_node_fs21.constants.F_OK);
       return { isAgent: true, agent: { name: DEVIN } };
     } catch (error48) {}
     return { isAgent: false, agent: undefined };
@@ -225867,8 +226213,6 @@ function getAuthFilePath() {
   return join(getBase44GlobalDir(), "auth", "auth.json");
 }
 function getTemplatesDir() {
-  if (globalThis.__BASE44_TEMPLATES_DIR)
-    return globalThis.__BASE44_TEMPLATES_DIR;
   return join(__dirname2, "../templates");
 }
 function getTemplatesIndexPath() {
@@ -241558,7 +241902,6 @@ var package_default = {
     "lint:fix": "biome check --write src tests",
     test: "vitest run",
     "test:watch": "vitest",
-    "build:binaries": "bun run infra/build-binaries.ts",
     knip: "knip",
     "knip:fix": "knip --fix"
   },
@@ -241584,11 +241927,12 @@ var package_default = {
     "@types/ejs": "^3.1.5",
     "@types/express": "^5.0.6",
     "@types/json-schema": "^7.0.15",
-    "@types/lodash.kebabcase": "^4.1.9",
-    "@types/node": "^22.10.5",
+    "@types/lodash": "^4.17.24",
     "@types/multer": "^2.0.0",
+    "@types/node": "^22.10.5",
     "@vercel/detect-agent": "^1.1.0",
     chalk: "^5.6.2",
+    chokidar: "^5.0.0",
     commander: "^12.1.0",
     "common-tags": "^1.8.2",
     cors: "^2.8.5",
@@ -241604,9 +241948,9 @@ var package_default = {
     json5: "^2.2.3",
     knip: "^5.83.1",
     ky: "^1.14.2",
-    "lodash.kebabcase": "^4.1.1",
-    multer: "^2.0.0",
+    lodash: "^4.17.23",
     msw: "^2.12.10",
+    multer: "^2.0.0",
     nanoid: "^5.1.6",
     open: "^11.0.0",
     "p-wait-for": "^6.0.0",
@@ -242733,7 +243077,7 @@ function getFunctionsDeployCommand(context) {
 
 // src/cli/commands/project/create.ts
 import { basename as basename3, join as join11, resolve as resolve2 } from "node:path";
-var import_lodash = __toESM(require_lodash(), 1);
+var import_kebabCase = __toESM(require_kebabCase(), 1);
 var DEFAULT_TEMPLATE_ID = "backend-only";
 async function getTemplateById(templateId) {
   const templates = await listTemplates();
@@ -242777,7 +243121,7 @@ async function createInteractive(options) {
       });
     },
     projectPath: async ({ results }) => {
-      const suggestedPath = await isDirEmpty() ? "./" : `./${import_lodash.default(results.name)}`;
+      const suggestedPath = await isDirEmpty() ? "./" : `./${import_kebabCase.default(results.name)}`;
       return Ze({
         message: "Where should we create your project?",
         placeholder: suggestedPath,
@@ -243540,6 +243884,7 @@ function getTypesCommand(context) {
 }
 
 // src/cli/dev/dev-server/main.ts
+import { dirname as dirname14, join as join18 } from "node:path";
 var import_cors = __toESM(require_lib4(), 1);
 var import_express4 = __toESM(require_express(), 1);
 
@@ -243701,7 +244046,7 @@ import { spawn as spawn2, spawnSync as spawnSync2 } from "node:child_process";
 import { dirname as dirname11, join as join15 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 var __dirname5 = dirname11(fileURLToPath7(import.meta.url));
-var WRAPPER_PATH = globalThis.__BASE44_DENO_WRAPPER_PATH ?? join15(__dirname5, "../deno-runtime/main.js");
+var WRAPPER_PATH = join15(__dirname5, "../deno-runtime/main.js");
 var READY_TIMEOUT = 30000;
 
 class FunctionManager {
@@ -243747,6 +244092,10 @@ class FunctionManager {
     try {
       return await promise2;
     } finally {
+      if (!this.starting.has(name2) && this.running.has(name2)) {
+        this.running.get(name2)?.process.kill();
+        this.running.delete(name2);
+      }
       this.starting.delete(name2);
     }
   }
@@ -243762,9 +244111,13 @@ class FunctionManager {
     this.setupProcessHandlers(name2, process21);
     return this.waitForReady(name2, runningFunc);
   }
+  reload(functions) {
+    this.stopAll();
+    this.functions = new Map(functions.map((f7) => [f7.name, f7]));
+  }
   stopAll() {
     for (const [name2, { process: process21 }] of this.running) {
-      this.logger.log(`[dev-server] Stopping function: ${name2}`);
+      this.logger.log(`Stopping function: ${name2}`);
       process21.kill();
     }
     this.running.clear();
@@ -243775,7 +244128,7 @@ class FunctionManager {
     return getPorts({ exclude: usedPorts });
   }
   spawnFunction(func, port) {
-    this.logger.log(`[dev-server] Spawning function "${func.name}" on port ${port}`);
+    this.logger.log(`Spawning function "${func.name}" on port ${port}`);
     const process21 = spawn2("deno", ["run", "--allow-all", WRAPPER_PATH], {
       env: {
         ...globalThis.process.env,
@@ -243803,11 +244156,13 @@ class FunctionManager {
       }
     });
     process21.on("exit", (code2) => {
-      this.logger.log(`[dev-server] Function "${name2}" exited with code ${code2}`);
+      if (code2 !== null) {
+        this.logger.log(`Function "${name2}" exited with code ${code2}`);
+      }
       this.running.delete(name2);
     });
     process21.on("error", (error48) => {
-      this.logger.error(`[dev-server] Function "${name2}" error:`, error48);
+      this.logger.error(`Function "${name2}" error:`, error48);
       this.running.delete(name2);
     });
   }
@@ -243892,9 +244247,8 @@ function createFunctionRouter(manager, logger) {
 var import_nedb = __toESM(require_nedb(), 1);
 
 class Database {
-  collections;
-  constructor(entities) {
-    this.collections = new Map;
+  collections = new Map;
+  load(entities) {
     for (const entity2 of entities) {
       this.collections.set(entity2.name, new import_nedb.default);
     }
@@ -243905,6 +244259,12 @@ class Database {
   getCollectionNames() {
     return Array.from(this.collections.keys());
   }
+  dropAll() {
+    for (const collection of this.collections.values()) {
+      collection.remove({}, { multi: true });
+    }
+    this.collections.clear();
+  }
 }
 
 // node_modules/socket.io/wrapper.mjs
@@ -244258,6 +244618,1702 @@ function createCustomIntegrationRoutes(remoteProxy, logger) {
   return router;
 }
 
+// src/cli/dev/dev-server/watcher.ts
+import { EventEmitter as EventEmitter4 } from "node:events";
+import { relative as relative4 } from "node:path";
+
+// node_modules/chokidar/index.js
+import { EventEmitter as EventEmitter3 } from "node:events";
+import { stat as statcb, Stats } from "node:fs";
+import { readdir as readdir3, stat as stat4 } from "node:fs/promises";
+import * as sp3 from "node:path";
+
+// node_modules/readdirp/index.js
+import { lstat as lstat2, readdir as readdir2, realpath, stat as stat2 } from "node:fs/promises";
+import { join as pjoin, relative as prelative, resolve as presolve, sep as psep } from "node:path";
+import { Readable as Readable6 } from "node:stream";
+var EntryTypes = {
+  FILE_TYPE: "files",
+  DIR_TYPE: "directories",
+  FILE_DIR_TYPE: "files_directories",
+  EVERYTHING_TYPE: "all"
+};
+var defaultOptions = {
+  root: ".",
+  fileFilter: (_entryInfo) => true,
+  directoryFilter: (_entryInfo) => true,
+  type: EntryTypes.FILE_TYPE,
+  lstat: false,
+  depth: 2147483648,
+  alwaysStat: false,
+  highWaterMark: 4096
+};
+Object.freeze(defaultOptions);
+var RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
+var NORMAL_FLOW_ERRORS = new Set(["ENOENT", "EPERM", "EACCES", "ELOOP", RECURSIVE_ERROR_CODE]);
+var ALL_TYPES = [
+  EntryTypes.DIR_TYPE,
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE,
+  EntryTypes.FILE_TYPE
+];
+var DIR_TYPES = new Set([
+  EntryTypes.DIR_TYPE,
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE
+]);
+var FILE_TYPES2 = new Set([
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE,
+  EntryTypes.FILE_TYPE
+]);
+var isNormalFlowError = (error48) => NORMAL_FLOW_ERRORS.has(error48.code);
+var wantBigintFsStats = process.platform === "win32";
+var emptyFn = (_entryInfo) => true;
+var normalizeFilter = (filter2) => {
+  if (filter2 === undefined)
+    return emptyFn;
+  if (typeof filter2 === "function")
+    return filter2;
+  if (typeof filter2 === "string") {
+    const fl6 = filter2.trim();
+    return (entry) => entry.basename === fl6;
+  }
+  if (Array.isArray(filter2)) {
+    const trItems = filter2.map((item) => item.trim());
+    return (entry) => trItems.some((f7) => entry.basename === f7);
+  }
+  return emptyFn;
+};
+
+class ReaddirpStream extends Readable6 {
+  parents;
+  reading;
+  parent;
+  _stat;
+  _maxDepth;
+  _wantsDir;
+  _wantsFile;
+  _wantsEverything;
+  _root;
+  _isDirent;
+  _statsProp;
+  _rdOptions;
+  _fileFilter;
+  _directoryFilter;
+  constructor(options8 = {}) {
+    super({
+      objectMode: true,
+      autoDestroy: true,
+      highWaterMark: options8.highWaterMark
+    });
+    const opts = { ...defaultOptions, ...options8 };
+    const { root: root2, type } = opts;
+    this._fileFilter = normalizeFilter(opts.fileFilter);
+    this._directoryFilter = normalizeFilter(opts.directoryFilter);
+    const statMethod = opts.lstat ? lstat2 : stat2;
+    if (wantBigintFsStats) {
+      this._stat = (path19) => statMethod(path19, { bigint: true });
+    } else {
+      this._stat = statMethod;
+    }
+    this._maxDepth = opts.depth != null && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions.depth;
+    this._wantsDir = type ? DIR_TYPES.has(type) : false;
+    this._wantsFile = type ? FILE_TYPES2.has(type) : false;
+    this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
+    this._root = presolve(root2);
+    this._isDirent = !opts.alwaysStat;
+    this._statsProp = this._isDirent ? "dirent" : "stats";
+    this._rdOptions = { encoding: "utf8", withFileTypes: this._isDirent };
+    this.parents = [this._exploreDir(root2, 1)];
+    this.reading = false;
+    this.parent = undefined;
+  }
+  async _read(batch) {
+    if (this.reading)
+      return;
+    this.reading = true;
+    try {
+      while (!this.destroyed && batch > 0) {
+        const par = this.parent;
+        const fil = par && par.files;
+        if (fil && fil.length > 0) {
+          const { path: path19, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path19));
+          const awaited = await Promise.all(slice);
+          for (const entry of awaited) {
+            if (!entry)
+              continue;
+            if (this.destroyed)
+              return;
+            const entryType = await this._getEntryType(entry);
+            if (entryType === "directory" && this._directoryFilter(entry)) {
+              if (depth <= this._maxDepth) {
+                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+              }
+              if (this._wantsDir) {
+                this.push(entry);
+                batch--;
+              }
+            } else if ((entryType === "file" || this._includeAsFile(entry)) && this._fileFilter(entry)) {
+              if (this._wantsFile) {
+                this.push(entry);
+                batch--;
+              }
+            }
+          }
+        } else {
+          const parent = this.parents.pop();
+          if (!parent) {
+            this.push(null);
+            break;
+          }
+          this.parent = await parent;
+          if (this.destroyed)
+            return;
+        }
+      }
+    } catch (error48) {
+      this.destroy(error48);
+    } finally {
+      this.reading = false;
+    }
+  }
+  async _exploreDir(path19, depth) {
+    let files;
+    try {
+      files = await readdir2(path19, this._rdOptions);
+    } catch (error48) {
+      this._onError(error48);
+    }
+    return { files, depth, path: path19 };
+  }
+  async _formatEntry(dirent, path19) {
+    let entry;
+    const basename4 = this._isDirent ? dirent.name : dirent;
+    try {
+      const fullPath = presolve(pjoin(path19, basename4));
+      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename4 };
+      entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+    } catch (err) {
+      this._onError(err);
+      return;
+    }
+    return entry;
+  }
+  _onError(err) {
+    if (isNormalFlowError(err) && !this.destroyed) {
+      this.emit("warn", err);
+    } else {
+      this.destroy(err);
+    }
+  }
+  async _getEntryType(entry) {
+    if (!entry && this._statsProp in entry) {
+      return "";
+    }
+    const stats = entry[this._statsProp];
+    if (stats.isFile())
+      return "file";
+    if (stats.isDirectory())
+      return "directory";
+    if (stats && stats.isSymbolicLink()) {
+      const full = entry.fullPath;
+      try {
+        const entryRealPath = await realpath(full);
+        const entryRealPathStats = await lstat2(entryRealPath);
+        if (entryRealPathStats.isFile()) {
+          return "file";
+        }
+        if (entryRealPathStats.isDirectory()) {
+          const len = entryRealPath.length;
+          if (full.startsWith(entryRealPath) && full.substr(len, 1) === psep) {
+            const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+            recursiveError.code = RECURSIVE_ERROR_CODE;
+            return this._onError(recursiveError);
+          }
+          return "directory";
+        }
+      } catch (error48) {
+        this._onError(error48);
+        return "";
+      }
+    }
+  }
+  _includeAsFile(entry) {
+    const stats = entry && entry[this._statsProp];
+    return stats && this._wantsEverything && !stats.isDirectory();
+  }
+}
+function readdirp(root2, options8 = {}) {
+  let type = options8.entryType || options8.type;
+  if (type === "both")
+    type = EntryTypes.FILE_DIR_TYPE;
+  if (type)
+    options8.type = type;
+  if (!root2) {
+    throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
+  } else if (typeof root2 !== "string") {
+    throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
+  } else if (type && !ALL_TYPES.includes(type)) {
+    throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
+  }
+  options8.root = root2;
+  return new ReaddirpStream(options8);
+}
+
+// node_modules/chokidar/handler.js
+import { watch as fs_watch, unwatchFile, watchFile } from "node:fs";
+import { realpath as fsrealpath, lstat as lstat3, open as open2, stat as stat3 } from "node:fs/promises";
+import { type as osType } from "node:os";
+import * as sp2 from "node:path";
+var STR_DATA = "data";
+var STR_END = "end";
+var STR_CLOSE = "close";
+var EMPTY_FN = () => {};
+var pl6 = process.platform;
+var isWindows4 = pl6 === "win32";
+var isMacos = pl6 === "darwin";
+var isLinux = pl6 === "linux";
+var isFreeBSD = pl6 === "freebsd";
+var isIBMi = osType() === "OS400";
+var EVENTS = {
+  ALL: "all",
+  READY: "ready",
+  ADD: "add",
+  CHANGE: "change",
+  ADD_DIR: "addDir",
+  UNLINK: "unlink",
+  UNLINK_DIR: "unlinkDir",
+  RAW: "raw",
+  ERROR: "error"
+};
+var EV = EVENTS;
+var THROTTLE_MODE_WATCH = "watch";
+var statMethods = { lstat: lstat3, stat: stat3 };
+var KEY_LISTENERS = "listeners";
+var KEY_ERR = "errHandlers";
+var KEY_RAW = "rawEmitters";
+var HANDLER_KEYS2 = [KEY_LISTENERS, KEY_ERR, KEY_RAW];
+var binaryExtensions = new Set([
+  "3dm",
+  "3ds",
+  "3g2",
+  "3gp",
+  "7z",
+  "a",
+  "aac",
+  "adp",
+  "afdesign",
+  "afphoto",
+  "afpub",
+  "ai",
+  "aif",
+  "aiff",
+  "alz",
+  "ape",
+  "apk",
+  "appimage",
+  "ar",
+  "arj",
+  "asf",
+  "au",
+  "avi",
+  "bak",
+  "baml",
+  "bh",
+  "bin",
+  "bk",
+  "bmp",
+  "btif",
+  "bz2",
+  "bzip2",
+  "cab",
+  "caf",
+  "cgm",
+  "class",
+  "cmx",
+  "cpio",
+  "cr2",
+  "cur",
+  "dat",
+  "dcm",
+  "deb",
+  "dex",
+  "djvu",
+  "dll",
+  "dmg",
+  "dng",
+  "doc",
+  "docm",
+  "docx",
+  "dot",
+  "dotm",
+  "dra",
+  "DS_Store",
+  "dsk",
+  "dts",
+  "dtshd",
+  "dvb",
+  "dwg",
+  "dxf",
+  "ecelp4800",
+  "ecelp7470",
+  "ecelp9600",
+  "egg",
+  "eol",
+  "eot",
+  "epub",
+  "exe",
+  "f4v",
+  "fbs",
+  "fh",
+  "fla",
+  "flac",
+  "flatpak",
+  "fli",
+  "flv",
+  "fpx",
+  "fst",
+  "fvt",
+  "g3",
+  "gh",
+  "gif",
+  "graffle",
+  "gz",
+  "gzip",
+  "h261",
+  "h263",
+  "h264",
+  "icns",
+  "ico",
+  "ief",
+  "img",
+  "ipa",
+  "iso",
+  "jar",
+  "jpeg",
+  "jpg",
+  "jpgv",
+  "jpm",
+  "jxr",
+  "key",
+  "ktx",
+  "lha",
+  "lib",
+  "lvp",
+  "lz",
+  "lzh",
+  "lzma",
+  "lzo",
+  "m3u",
+  "m4a",
+  "m4v",
+  "mar",
+  "mdi",
+  "mht",
+  "mid",
+  "midi",
+  "mj2",
+  "mka",
+  "mkv",
+  "mmr",
+  "mng",
+  "mobi",
+  "mov",
+  "movie",
+  "mp3",
+  "mp4",
+  "mp4a",
+  "mpeg",
+  "mpg",
+  "mpga",
+  "mxu",
+  "nef",
+  "npx",
+  "numbers",
+  "nupkg",
+  "o",
+  "odp",
+  "ods",
+  "odt",
+  "oga",
+  "ogg",
+  "ogv",
+  "otf",
+  "ott",
+  "pages",
+  "pbm",
+  "pcx",
+  "pdb",
+  "pdf",
+  "pea",
+  "pgm",
+  "pic",
+  "png",
+  "pnm",
+  "pot",
+  "potm",
+  "potx",
+  "ppa",
+  "ppam",
+  "ppm",
+  "pps",
+  "ppsm",
+  "ppsx",
+  "ppt",
+  "pptm",
+  "pptx",
+  "psd",
+  "pya",
+  "pyc",
+  "pyo",
+  "pyv",
+  "qt",
+  "rar",
+  "ras",
+  "raw",
+  "resources",
+  "rgb",
+  "rip",
+  "rlc",
+  "rmf",
+  "rmvb",
+  "rpm",
+  "rtf",
+  "rz",
+  "s3m",
+  "s7z",
+  "scpt",
+  "sgi",
+  "shar",
+  "snap",
+  "sil",
+  "sketch",
+  "slk",
+  "smv",
+  "snk",
+  "so",
+  "stl",
+  "suo",
+  "sub",
+  "swf",
+  "tar",
+  "tbz",
+  "tbz2",
+  "tga",
+  "tgz",
+  "thmx",
+  "tif",
+  "tiff",
+  "tlz",
+  "ttc",
+  "ttf",
+  "txz",
+  "udf",
+  "uvh",
+  "uvi",
+  "uvm",
+  "uvp",
+  "uvs",
+  "uvu",
+  "viv",
+  "vob",
+  "war",
+  "wav",
+  "wax",
+  "wbmp",
+  "wdp",
+  "weba",
+  "webm",
+  "webp",
+  "whl",
+  "wim",
+  "wm",
+  "wma",
+  "wmv",
+  "wmx",
+  "woff",
+  "woff2",
+  "wrm",
+  "wvx",
+  "xbm",
+  "xif",
+  "xla",
+  "xlam",
+  "xls",
+  "xlsb",
+  "xlsm",
+  "xlsx",
+  "xlt",
+  "xltm",
+  "xltx",
+  "xm",
+  "xmind",
+  "xpi",
+  "xpm",
+  "xwd",
+  "xz",
+  "z",
+  "zip",
+  "zipx"
+]);
+var isBinaryPath = (filePath) => binaryExtensions.has(sp2.extname(filePath).slice(1).toLowerCase());
+var foreach = (val, fn9) => {
+  if (val instanceof Set) {
+    val.forEach(fn9);
+  } else {
+    fn9(val);
+  }
+};
+var addAndConvert = (main, prop, item) => {
+  let container = main[prop];
+  if (!(container instanceof Set)) {
+    main[prop] = container = new Set([container]);
+  }
+  container.add(item);
+};
+var clearItem = (cont) => (key2) => {
+  const set2 = cont[key2];
+  if (set2 instanceof Set) {
+    set2.clear();
+  } else {
+    delete cont[key2];
+  }
+};
+var delFromSet = (main, prop, item) => {
+  const container = main[prop];
+  if (container instanceof Set) {
+    container.delete(item);
+  } else if (container === item) {
+    delete main[prop];
+  }
+};
+var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
+var FsWatchInstances = new Map;
+function createFsWatchInstance(path19, options8, listener, errHandler, emitRaw) {
+  const handleEvent = (rawEvent, evPath) => {
+    listener(path19);
+    emitRaw(rawEvent, evPath, { watchedPath: path19 });
+    if (evPath && path19 !== evPath) {
+      fsWatchBroadcast(sp2.resolve(path19, evPath), KEY_LISTENERS, sp2.join(path19, evPath));
+    }
+  };
+  try {
+    return fs_watch(path19, {
+      persistent: options8.persistent
+    }, handleEvent);
+  } catch (error48) {
+    errHandler(error48);
+    return;
+  }
+}
+var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
+  const cont = FsWatchInstances.get(fullPath);
+  if (!cont)
+    return;
+  foreach(cont[listenerType], (listener) => {
+    listener(val1, val2, val3);
+  });
+};
+var setFsWatchListener = (path19, fullPath, options8, handlers) => {
+  const { listener, errHandler, rawEmitter } = handlers;
+  let cont = FsWatchInstances.get(fullPath);
+  let watcher;
+  if (!options8.persistent) {
+    watcher = createFsWatchInstance(path19, options8, listener, errHandler, rawEmitter);
+    if (!watcher)
+      return;
+    return watcher.close.bind(watcher);
+  }
+  if (cont) {
+    addAndConvert(cont, KEY_LISTENERS, listener);
+    addAndConvert(cont, KEY_ERR, errHandler);
+    addAndConvert(cont, KEY_RAW, rawEmitter);
+  } else {
+    watcher = createFsWatchInstance(path19, options8, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
+    if (!watcher)
+      return;
+    watcher.on(EV.ERROR, async (error48) => {
+      const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
+      if (cont)
+        cont.watcherUnusable = true;
+      if (isWindows4 && error48.code === "EPERM") {
+        try {
+          const fd = await open2(path19, "r");
+          await fd.close();
+          broadcastErr(error48);
+        } catch (err) {}
+      } else {
+        broadcastErr(error48);
+      }
+    });
+    cont = {
+      listeners: listener,
+      errHandlers: errHandler,
+      rawEmitters: rawEmitter,
+      watcher
+    };
+    FsWatchInstances.set(fullPath, cont);
+  }
+  return () => {
+    delFromSet(cont, KEY_LISTENERS, listener);
+    delFromSet(cont, KEY_ERR, errHandler);
+    delFromSet(cont, KEY_RAW, rawEmitter);
+    if (isEmptySet(cont.listeners)) {
+      cont.watcher.close();
+      FsWatchInstances.delete(fullPath);
+      HANDLER_KEYS2.forEach(clearItem(cont));
+      cont.watcher = undefined;
+      Object.freeze(cont);
+    }
+  };
+};
+var FsWatchFileInstances = new Map;
+var setFsWatchFileListener = (path19, fullPath, options8, handlers) => {
+  const { listener, rawEmitter } = handlers;
+  let cont = FsWatchFileInstances.get(fullPath);
+  const copts = cont && cont.options;
+  if (copts && (copts.persistent < options8.persistent || copts.interval > options8.interval)) {
+    unwatchFile(fullPath);
+    cont = undefined;
+  }
+  if (cont) {
+    addAndConvert(cont, KEY_LISTENERS, listener);
+    addAndConvert(cont, KEY_RAW, rawEmitter);
+  } else {
+    cont = {
+      listeners: listener,
+      rawEmitters: rawEmitter,
+      options: options8,
+      watcher: watchFile(fullPath, options8, (curr, prev) => {
+        foreach(cont.rawEmitters, (rawEmitter2) => {
+          rawEmitter2(EV.CHANGE, fullPath, { curr, prev });
+        });
+        const currmtime = curr.mtimeMs;
+        if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
+          foreach(cont.listeners, (listener2) => listener2(path19, curr));
+        }
+      })
+    };
+    FsWatchFileInstances.set(fullPath, cont);
+  }
+  return () => {
+    delFromSet(cont, KEY_LISTENERS, listener);
+    delFromSet(cont, KEY_RAW, rawEmitter);
+    if (isEmptySet(cont.listeners)) {
+      FsWatchFileInstances.delete(fullPath);
+      unwatchFile(fullPath);
+      cont.options = cont.watcher = undefined;
+      Object.freeze(cont);
+    }
+  };
+};
+
+class NodeFsHandler {
+  fsw;
+  _boundHandleError;
+  constructor(fsW) {
+    this.fsw = fsW;
+    this._boundHandleError = (error48) => fsW._handleError(error48);
+  }
+  _watchWithNodeFs(path19, listener) {
+    const opts = this.fsw.options;
+    const directory = sp2.dirname(path19);
+    const basename5 = sp2.basename(path19);
+    const parent = this.fsw._getWatchedDir(directory);
+    parent.add(basename5);
+    const absolutePath = sp2.resolve(path19);
+    const options8 = {
+      persistent: opts.persistent
+    };
+    if (!listener)
+      listener = EMPTY_FN;
+    let closer;
+    if (opts.usePolling) {
+      const enableBin = opts.interval !== opts.binaryInterval;
+      options8.interval = enableBin && isBinaryPath(basename5) ? opts.binaryInterval : opts.interval;
+      closer = setFsWatchFileListener(path19, absolutePath, options8, {
+        listener,
+        rawEmitter: this.fsw._emitRaw
+      });
+    } else {
+      closer = setFsWatchListener(path19, absolutePath, options8, {
+        listener,
+        errHandler: this._boundHandleError,
+        rawEmitter: this.fsw._emitRaw
+      });
+    }
+    return closer;
+  }
+  _handleFile(file2, stats, initialAdd) {
+    if (this.fsw.closed) {
+      return;
+    }
+    const dirname13 = sp2.dirname(file2);
+    const basename5 = sp2.basename(file2);
+    const parent = this.fsw._getWatchedDir(dirname13);
+    let prevStats = stats;
+    if (parent.has(basename5))
+      return;
+    const listener = async (path19, newStats) => {
+      if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
+        return;
+      if (!newStats || newStats.mtimeMs === 0) {
+        try {
+          const newStats2 = await stat3(file2);
+          if (this.fsw.closed)
+            return;
+          const at13 = newStats2.atimeMs;
+          const mt12 = newStats2.mtimeMs;
+          if (!at13 || at13 <= mt12 || mt12 !== prevStats.mtimeMs) {
+            this.fsw._emit(EV.CHANGE, file2, newStats2);
+          }
+          if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
+            this.fsw._closeFile(path19);
+            prevStats = newStats2;
+            const closer2 = this._watchWithNodeFs(file2, listener);
+            if (closer2)
+              this.fsw._addPathCloser(path19, closer2);
+          } else {
+            prevStats = newStats2;
+          }
+        } catch (error48) {
+          this.fsw._remove(dirname13, basename5);
+        }
+      } else if (parent.has(basename5)) {
+        const at13 = newStats.atimeMs;
+        const mt12 = newStats.mtimeMs;
+        if (!at13 || at13 <= mt12 || mt12 !== prevStats.mtimeMs) {
+          this.fsw._emit(EV.CHANGE, file2, newStats);
+        }
+        prevStats = newStats;
+      }
+    };
+    const closer = this._watchWithNodeFs(file2, listener);
+    if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file2)) {
+      if (!this.fsw._throttle(EV.ADD, file2, 0))
+        return;
+      this.fsw._emit(EV.ADD, file2, stats);
+    }
+    return closer;
+  }
+  async _handleSymlink(entry, directory, path19, item) {
+    if (this.fsw.closed) {
+      return;
+    }
+    const full = entry.fullPath;
+    const dir = this.fsw._getWatchedDir(directory);
+    if (!this.fsw.options.followSymlinks) {
+      this.fsw._incrReadyCount();
+      let linkPath;
+      try {
+        linkPath = await fsrealpath(path19);
+      } catch (e8) {
+        this.fsw._emitReady();
+        return true;
+      }
+      if (this.fsw.closed)
+        return;
+      if (dir.has(item)) {
+        if (this.fsw._symlinkPaths.get(full) !== linkPath) {
+          this.fsw._symlinkPaths.set(full, linkPath);
+          this.fsw._emit(EV.CHANGE, path19, entry.stats);
+        }
+      } else {
+        dir.add(item);
+        this.fsw._symlinkPaths.set(full, linkPath);
+        this.fsw._emit(EV.ADD, path19, entry.stats);
+      }
+      this.fsw._emitReady();
+      return true;
+    }
+    if (this.fsw._symlinkPaths.has(full)) {
+      return true;
+    }
+    this.fsw._symlinkPaths.set(full, true);
+  }
+  _handleRead(directory, initialAdd, wh2, target, dir, depth, throttler) {
+    directory = sp2.join(directory, "");
+    const throttleKey = target ? `${directory}:${target}` : directory;
+    throttler = this.fsw._throttle("readdir", throttleKey, 1000);
+    if (!throttler)
+      return;
+    const previous = this.fsw._getWatchedDir(wh2.path);
+    const current = new Set;
+    let stream = this.fsw._readdirp(directory, {
+      fileFilter: (entry) => wh2.filterPath(entry),
+      directoryFilter: (entry) => wh2.filterDir(entry)
+    });
+    if (!stream)
+      return;
+    stream.on(STR_DATA, async (entry) => {
+      if (this.fsw.closed) {
+        stream = undefined;
+        return;
+      }
+      const item = entry.path;
+      let path19 = sp2.join(directory, item);
+      current.add(item);
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path19, item)) {
+        return;
+      }
+      if (this.fsw.closed) {
+        stream = undefined;
+        return;
+      }
+      if (item === target || !target && !previous.has(item)) {
+        this.fsw._incrReadyCount();
+        path19 = sp2.join(dir, sp2.relative(dir, path19));
+        this._addToNodeFs(path19, initialAdd, wh2, depth + 1);
+      }
+    }).on(EV.ERROR, this._boundHandleError);
+    return new Promise((resolve7, reject) => {
+      if (!stream)
+        return reject();
+      stream.once(STR_END, () => {
+        if (this.fsw.closed) {
+          stream = undefined;
+          return;
+        }
+        const wasThrottled = throttler ? throttler.clear() : false;
+        resolve7(undefined);
+        previous.getChildren().filter((item) => {
+          return item !== directory && !current.has(item);
+        }).forEach((item) => {
+          this.fsw._remove(directory, item);
+        });
+        stream = undefined;
+        if (wasThrottled)
+          this._handleRead(directory, false, wh2, target, dir, depth, throttler);
+      });
+    });
+  }
+  async _handleDir(dir, stats, initialAdd, depth, target, wh2, realpath2) {
+    const parentDir = this.fsw._getWatchedDir(sp2.dirname(dir));
+    const tracked = parentDir.has(sp2.basename(dir));
+    if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
+      this.fsw._emit(EV.ADD_DIR, dir, stats);
+    }
+    parentDir.add(sp2.basename(dir));
+    this.fsw._getWatchedDir(dir);
+    let throttler;
+    let closer;
+    const oDepth = this.fsw.options.depth;
+    if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath2)) {
+      if (!target) {
+        await this._handleRead(dir, initialAdd, wh2, target, dir, depth, throttler);
+        if (this.fsw.closed)
+          return;
+      }
+      closer = this._watchWithNodeFs(dir, (dirPath, stats2) => {
+        if (stats2 && stats2.mtimeMs === 0)
+          return;
+        this._handleRead(dirPath, false, wh2, target, dir, depth, throttler);
+      });
+    }
+    return closer;
+  }
+  async _addToNodeFs(path19, initialAdd, priorWh, depth, target) {
+    const ready = this.fsw._emitReady;
+    if (this.fsw._isIgnored(path19) || this.fsw.closed) {
+      ready();
+      return false;
+    }
+    const wh2 = this.fsw._getWatchHelpers(path19);
+    if (priorWh) {
+      wh2.filterPath = (entry) => priorWh.filterPath(entry);
+      wh2.filterDir = (entry) => priorWh.filterDir(entry);
+    }
+    try {
+      const stats = await statMethods[wh2.statMethod](wh2.watchPath);
+      if (this.fsw.closed)
+        return;
+      if (this.fsw._isIgnored(wh2.watchPath, stats)) {
+        ready();
+        return false;
+      }
+      const follow = this.fsw.options.followSymlinks;
+      let closer;
+      if (stats.isDirectory()) {
+        const absPath = sp2.resolve(path19);
+        const targetPath = follow ? await fsrealpath(path19) : path19;
+        if (this.fsw.closed)
+          return;
+        closer = await this._handleDir(wh2.watchPath, stats, initialAdd, depth, target, wh2, targetPath);
+        if (this.fsw.closed)
+          return;
+        if (absPath !== targetPath && targetPath !== undefined) {
+          this.fsw._symlinkPaths.set(absPath, targetPath);
+        }
+      } else if (stats.isSymbolicLink()) {
+        const targetPath = follow ? await fsrealpath(path19) : path19;
+        if (this.fsw.closed)
+          return;
+        const parent = sp2.dirname(wh2.watchPath);
+        this.fsw._getWatchedDir(parent).add(wh2.watchPath);
+        this.fsw._emit(EV.ADD, wh2.watchPath, stats);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path19, wh2, targetPath);
+        if (this.fsw.closed)
+          return;
+        if (targetPath !== undefined) {
+          this.fsw._symlinkPaths.set(sp2.resolve(path19), targetPath);
+        }
+      } else {
+        closer = this._handleFile(wh2.watchPath, stats, initialAdd);
+      }
+      ready();
+      if (closer)
+        this.fsw._addPathCloser(path19, closer);
+      return false;
+    } catch (error48) {
+      if (this.fsw._handleError(error48)) {
+        ready();
+        return path19;
+      }
+    }
+  }
+}
+
+// node_modules/chokidar/index.js
+/*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */
+var SLASH = "/";
+var SLASH_SLASH = "//";
+var ONE_DOT = ".";
+var TWO_DOTS = "..";
+var STRING_TYPE = "string";
+var BACK_SLASH_RE = /\\/g;
+var DOUBLE_SLASH_RE = /\/\//g;
+var DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+var REPLACER_RE = /^\.[/\\]/;
+function arrify(item) {
+  return Array.isArray(item) ? item : [item];
+}
+var isMatcherObject = (matcher) => typeof matcher === "object" && matcher !== null && !(matcher instanceof RegExp);
+function createPattern(matcher) {
+  if (typeof matcher === "function")
+    return matcher;
+  if (typeof matcher === "string")
+    return (string4) => matcher === string4;
+  if (matcher instanceof RegExp)
+    return (string4) => matcher.test(string4);
+  if (typeof matcher === "object" && matcher !== null) {
+    return (string4) => {
+      if (matcher.path === string4)
+        return true;
+      if (matcher.recursive) {
+        const relative4 = sp3.relative(matcher.path, string4);
+        if (!relative4) {
+          return false;
+        }
+        return !relative4.startsWith("..") && !sp3.isAbsolute(relative4);
+      }
+      return false;
+    };
+  }
+  return () => false;
+}
+function normalizePath(path19) {
+  if (typeof path19 !== "string")
+    throw new Error("string expected");
+  path19 = sp3.normalize(path19);
+  path19 = path19.replace(/\\/g, "/");
+  let prepend = false;
+  if (path19.startsWith("//"))
+    prepend = true;
+  path19 = path19.replace(DOUBLE_SLASH_RE, "/");
+  if (prepend)
+    path19 = "/" + path19;
+  return path19;
+}
+function matchPatterns(patterns, testString, stats) {
+  const path19 = normalizePath(testString);
+  for (let index = 0;index < patterns.length; index++) {
+    const pattern = patterns[index];
+    if (pattern(path19, stats)) {
+      return true;
+    }
+  }
+  return false;
+}
+function anymatch(matchers, testString) {
+  if (matchers == null) {
+    throw new TypeError("anymatch: specify first argument");
+  }
+  const matchersArray = arrify(matchers);
+  const patterns = matchersArray.map((matcher) => createPattern(matcher));
+  if (testString == null) {
+    return (testString2, stats) => {
+      return matchPatterns(patterns, testString2, stats);
+    };
+  }
+  return matchPatterns(patterns, testString);
+}
+var unifyPaths = (paths_) => {
+  const paths = arrify(paths_).flat();
+  if (!paths.every((p4) => typeof p4 === STRING_TYPE)) {
+    throw new TypeError(`Non-string provided as watch path: ${paths}`);
+  }
+  return paths.map(normalizePathToUnix);
+};
+var toUnix = (string4) => {
+  let str = string4.replace(BACK_SLASH_RE, SLASH);
+  let prepend = false;
+  if (str.startsWith(SLASH_SLASH)) {
+    prepend = true;
+  }
+  str = str.replace(DOUBLE_SLASH_RE, SLASH);
+  if (prepend) {
+    str = SLASH + str;
+  }
+  return str;
+};
+var normalizePathToUnix = (path19) => toUnix(sp3.normalize(toUnix(path19)));
+var normalizeIgnored = (cwd = "") => (path19) => {
+  if (typeof path19 === "string") {
+    return normalizePathToUnix(sp3.isAbsolute(path19) ? path19 : sp3.join(cwd, path19));
+  } else {
+    return path19;
+  }
+};
+var getAbsolutePath = (path19, cwd) => {
+  if (sp3.isAbsolute(path19)) {
+    return path19;
+  }
+  return sp3.join(cwd, path19);
+};
+var EMPTY_SET = Object.freeze(new Set);
+
+class DirEntry {
+  path;
+  _removeWatcher;
+  items;
+  constructor(dir, removeWatcher) {
+    this.path = dir;
+    this._removeWatcher = removeWatcher;
+    this.items = new Set;
+  }
+  add(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    if (item !== ONE_DOT && item !== TWO_DOTS)
+      items.add(item);
+  }
+  async remove(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    items.delete(item);
+    if (items.size > 0)
+      return;
+    const dir = this.path;
+    try {
+      await readdir3(dir);
+    } catch (err) {
+      if (this._removeWatcher) {
+        this._removeWatcher(sp3.dirname(dir), sp3.basename(dir));
+      }
+    }
+  }
+  has(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    return items.has(item);
+  }
+  getChildren() {
+    const { items } = this;
+    if (!items)
+      return [];
+    return [...items.values()];
+  }
+  dispose() {
+    this.items.clear();
+    this.path = "";
+    this._removeWatcher = EMPTY_FN;
+    this.items = EMPTY_SET;
+    Object.freeze(this);
+  }
+}
+var STAT_METHOD_F = "stat";
+var STAT_METHOD_L = "lstat";
+
+class WatchHelper {
+  fsw;
+  path;
+  watchPath;
+  fullWatchPath;
+  dirParts;
+  followSymlinks;
+  statMethod;
+  constructor(path19, follow, fsw) {
+    this.fsw = fsw;
+    const watchPath = path19;
+    this.path = path19 = path19.replace(REPLACER_RE, "");
+    this.watchPath = watchPath;
+    this.fullWatchPath = sp3.resolve(watchPath);
+    this.dirParts = [];
+    this.dirParts.forEach((parts) => {
+      if (parts.length > 1)
+        parts.pop();
+    });
+    this.followSymlinks = follow;
+    this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+  }
+  entryPath(entry) {
+    return sp3.join(this.watchPath, sp3.relative(this.watchPath, entry.fullPath));
+  }
+  filterPath(entry) {
+    const { stats } = entry;
+    if (stats && stats.isSymbolicLink())
+      return this.filterDir(entry);
+    const resolvedPath = this.entryPath(entry);
+    return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
+  }
+  filterDir(entry) {
+    return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+  }
+}
+
+class FSWatcher extends EventEmitter3 {
+  closed;
+  options;
+  _closers;
+  _ignoredPaths;
+  _throttled;
+  _streams;
+  _symlinkPaths;
+  _watched;
+  _pendingWrites;
+  _pendingUnlinks;
+  _readyCount;
+  _emitReady;
+  _closePromise;
+  _userIgnored;
+  _readyEmitted;
+  _emitRaw;
+  _boundRemove;
+  _nodeFsHandler;
+  constructor(_opts = {}) {
+    super();
+    this.closed = false;
+    this._closers = new Map;
+    this._ignoredPaths = new Set;
+    this._throttled = new Map;
+    this._streams = new Set;
+    this._symlinkPaths = new Map;
+    this._watched = new Map;
+    this._pendingWrites = new Map;
+    this._pendingUnlinks = new Map;
+    this._readyCount = 0;
+    this._readyEmitted = false;
+    const awf = _opts.awaitWriteFinish;
+    const DEF_AWF = { stabilityThreshold: 2000, pollInterval: 100 };
+    const opts = {
+      persistent: true,
+      ignoreInitial: false,
+      ignorePermissionErrors: false,
+      interval: 100,
+      binaryInterval: 300,
+      followSymlinks: true,
+      usePolling: false,
+      atomic: true,
+      ..._opts,
+      ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
+      awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === "object" ? { ...DEF_AWF, ...awf } : false
+    };
+    if (isIBMi)
+      opts.usePolling = true;
+    if (opts.atomic === undefined)
+      opts.atomic = !opts.usePolling;
+    const envPoll = process.env.CHOKIDAR_USEPOLLING;
+    if (envPoll !== undefined) {
+      const envLower = envPoll.toLowerCase();
+      if (envLower === "false" || envLower === "0")
+        opts.usePolling = false;
+      else if (envLower === "true" || envLower === "1")
+        opts.usePolling = true;
+      else
+        opts.usePolling = !!envLower;
+    }
+    const envInterval = process.env.CHOKIDAR_INTERVAL;
+    if (envInterval)
+      opts.interval = Number.parseInt(envInterval, 10);
+    let readyCalls = 0;
+    this._emitReady = () => {
+      readyCalls++;
+      if (readyCalls >= this._readyCount) {
+        this._emitReady = EMPTY_FN;
+        this._readyEmitted = true;
+        process.nextTick(() => this.emit(EVENTS.READY));
+      }
+    };
+    this._emitRaw = (...args) => this.emit(EVENTS.RAW, ...args);
+    this._boundRemove = this._remove.bind(this);
+    this.options = opts;
+    this._nodeFsHandler = new NodeFsHandler(this);
+    Object.freeze(opts);
+  }
+  _addIgnoredPath(matcher) {
+    if (isMatcherObject(matcher)) {
+      for (const ignored of this._ignoredPaths) {
+        if (isMatcherObject(ignored) && ignored.path === matcher.path && ignored.recursive === matcher.recursive) {
+          return;
+        }
+      }
+    }
+    this._ignoredPaths.add(matcher);
+  }
+  _removeIgnoredPath(matcher) {
+    this._ignoredPaths.delete(matcher);
+    if (typeof matcher === "string") {
+      for (const ignored of this._ignoredPaths) {
+        if (isMatcherObject(ignored) && ignored.path === matcher) {
+          this._ignoredPaths.delete(ignored);
+        }
+      }
+    }
+  }
+  add(paths_, _origAdd, _internal) {
+    const { cwd } = this.options;
+    this.closed = false;
+    this._closePromise = undefined;
+    let paths = unifyPaths(paths_);
+    if (cwd) {
+      paths = paths.map((path19) => {
+        const absPath = getAbsolutePath(path19, cwd);
+        return absPath;
+      });
+    }
+    paths.forEach((path19) => {
+      this._removeIgnoredPath(path19);
+    });
+    this._userIgnored = undefined;
+    if (!this._readyCount)
+      this._readyCount = 0;
+    this._readyCount += paths.length;
+    Promise.all(paths.map(async (path19) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path19, !_internal, undefined, 0, _origAdd);
+      if (res)
+        this._emitReady();
+      return res;
+    })).then((results) => {
+      if (this.closed)
+        return;
+      results.forEach((item) => {
+        if (item)
+          this.add(sp3.dirname(item), sp3.basename(_origAdd || item));
+      });
+    });
+    return this;
+  }
+  unwatch(paths_) {
+    if (this.closed)
+      return this;
+    const paths = unifyPaths(paths_);
+    const { cwd } = this.options;
+    paths.forEach((path19) => {
+      if (!sp3.isAbsolute(path19) && !this._closers.has(path19)) {
+        if (cwd)
+          path19 = sp3.join(cwd, path19);
+        path19 = sp3.resolve(path19);
+      }
+      this._closePath(path19);
+      this._addIgnoredPath(path19);
+      if (this._watched.has(path19)) {
+        this._addIgnoredPath({
+          path: path19,
+          recursive: true
+        });
+      }
+      this._userIgnored = undefined;
+    });
+    return this;
+  }
+  close() {
+    if (this._closePromise) {
+      return this._closePromise;
+    }
+    this.closed = true;
+    this.removeAllListeners();
+    const closers = [];
+    this._closers.forEach((closerList) => closerList.forEach((closer) => {
+      const promise2 = closer();
+      if (promise2 instanceof Promise)
+        closers.push(promise2);
+    }));
+    this._streams.forEach((stream) => stream.destroy());
+    this._userIgnored = undefined;
+    this._readyCount = 0;
+    this._readyEmitted = false;
+    this._watched.forEach((dirent) => dirent.dispose());
+    this._closers.clear();
+    this._watched.clear();
+    this._streams.clear();
+    this._symlinkPaths.clear();
+    this._throttled.clear();
+    this._closePromise = closers.length ? Promise.all(closers).then(() => {
+      return;
+    }) : Promise.resolve();
+    return this._closePromise;
+  }
+  getWatched() {
+    const watchList = {};
+    this._watched.forEach((entry, dir) => {
+      const key2 = this.options.cwd ? sp3.relative(this.options.cwd, dir) : dir;
+      const index = key2 || ONE_DOT;
+      watchList[index] = entry.getChildren().sort();
+    });
+    return watchList;
+  }
+  emitWithAll(event, args) {
+    this.emit(event, ...args);
+    if (event !== EVENTS.ERROR)
+      this.emit(EVENTS.ALL, event, ...args);
+  }
+  async _emit(event, path19, stats) {
+    if (this.closed)
+      return;
+    const opts = this.options;
+    if (isWindows4)
+      path19 = sp3.normalize(path19);
+    if (opts.cwd)
+      path19 = sp3.relative(opts.cwd, path19);
+    const args = [path19];
+    if (stats != null)
+      args.push(stats);
+    const awf = opts.awaitWriteFinish;
+    let pw;
+    if (awf && (pw = this._pendingWrites.get(path19))) {
+      pw.lastChange = new Date;
+      return this;
+    }
+    if (opts.atomic) {
+      if (event === EVENTS.UNLINK) {
+        this._pendingUnlinks.set(path19, [event, ...args]);
+        setTimeout(() => {
+          this._pendingUnlinks.forEach((entry, path20) => {
+            this.emit(...entry);
+            this.emit(EVENTS.ALL, ...entry);
+            this._pendingUnlinks.delete(path20);
+          });
+        }, typeof opts.atomic === "number" ? opts.atomic : 100);
+        return this;
+      }
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path19)) {
+        event = EVENTS.CHANGE;
+        this._pendingUnlinks.delete(path19);
+      }
+    }
+    if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
+      const awfEmit = (err, stats2) => {
+        if (err) {
+          event = EVENTS.ERROR;
+          args[0] = err;
+          this.emitWithAll(event, args);
+        } else if (stats2) {
+          if (args.length > 1) {
+            args[1] = stats2;
+          } else {
+            args.push(stats2);
+          }
+          this.emitWithAll(event, args);
+        }
+      };
+      this._awaitWriteFinish(path19, awf.stabilityThreshold, event, awfEmit);
+      return this;
+    }
+    if (event === EVENTS.CHANGE) {
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path19, 50);
+      if (isThrottled)
+        return this;
+    }
+    if (opts.alwaysStat && stats === undefined && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
+      const fullPath = opts.cwd ? sp3.join(opts.cwd, path19) : path19;
+      let stats2;
+      try {
+        stats2 = await stat4(fullPath);
+      } catch (err) {}
+      if (!stats2 || this.closed)
+        return;
+      args.push(stats2);
+    }
+    this.emitWithAll(event, args);
+    return this;
+  }
+  _handleError(error48) {
+    const code2 = error48 && error48.code;
+    if (error48 && code2 !== "ENOENT" && code2 !== "ENOTDIR" && (!this.options.ignorePermissionErrors || code2 !== "EPERM" && code2 !== "EACCES")) {
+      this.emit(EVENTS.ERROR, error48);
+    }
+    return error48 || this.closed;
+  }
+  _throttle(actionType, path19, timeout3) {
+    if (!this._throttled.has(actionType)) {
+      this._throttled.set(actionType, new Map);
+    }
+    const action = this._throttled.get(actionType);
+    if (!action)
+      throw new Error("invalid throttle");
+    const actionPath = action.get(path19);
+    if (actionPath) {
+      actionPath.count++;
+      return false;
+    }
+    let timeoutObject;
+    const clear = () => {
+      const item = action.get(path19);
+      const count2 = item ? item.count : 0;
+      action.delete(path19);
+      clearTimeout(timeoutObject);
+      if (item)
+        clearTimeout(item.timeoutObject);
+      return count2;
+    };
+    timeoutObject = setTimeout(clear, timeout3);
+    const thr = { timeoutObject, clear, count: 0 };
+    action.set(path19, thr);
+    return thr;
+  }
+  _incrReadyCount() {
+    return this._readyCount++;
+  }
+  _awaitWriteFinish(path19, threshold, event, awfEmit) {
+    const awf = this.options.awaitWriteFinish;
+    if (typeof awf !== "object")
+      return;
+    const pollInterval = awf.pollInterval;
+    let timeoutHandler;
+    let fullPath = path19;
+    if (this.options.cwd && !sp3.isAbsolute(path19)) {
+      fullPath = sp3.join(this.options.cwd, path19);
+    }
+    const now = new Date;
+    const writes = this._pendingWrites;
+    function awaitWriteFinishFn(prevStat) {
+      statcb(fullPath, (err, curStat) => {
+        if (err || !writes.has(path19)) {
+          if (err && err.code !== "ENOENT")
+            awfEmit(err);
+          return;
+        }
+        const now2 = Number(new Date);
+        if (prevStat && curStat.size !== prevStat.size) {
+          writes.get(path19).lastChange = now2;
+        }
+        const pw = writes.get(path19);
+        const df3 = now2 - pw.lastChange;
+        if (df3 >= threshold) {
+          writes.delete(path19);
+          awfEmit(undefined, curStat);
+        } else {
+          timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
+        }
+      });
+    }
+    if (!writes.has(path19)) {
+      writes.set(path19, {
+        lastChange: now,
+        cancelWait: () => {
+          writes.delete(path19);
+          clearTimeout(timeoutHandler);
+          return event;
+        }
+      });
+      timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
+    }
+  }
+  _isIgnored(path19, stats) {
+    if (this.options.atomic && DOT_RE.test(path19))
+      return true;
+    if (!this._userIgnored) {
+      const { cwd } = this.options;
+      const ign = this.options.ignored;
+      const ignored = (ign || []).map(normalizeIgnored(cwd));
+      const ignoredPaths = [...this._ignoredPaths];
+      const list3 = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
+      this._userIgnored = anymatch(list3, undefined);
+    }
+    return this._userIgnored(path19, stats);
+  }
+  _isntIgnored(path19, stat5) {
+    return !this._isIgnored(path19, stat5);
+  }
+  _getWatchHelpers(path19) {
+    return new WatchHelper(path19, this.options.followSymlinks, this);
+  }
+  _getWatchedDir(directory) {
+    const dir = sp3.resolve(directory);
+    if (!this._watched.has(dir))
+      this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+    return this._watched.get(dir);
+  }
+  _hasReadPermissions(stats) {
+    if (this.options.ignorePermissionErrors)
+      return true;
+    return Boolean(Number(stats.mode) & 256);
+  }
+  _remove(directory, item, isDirectory3) {
+    const path19 = sp3.join(directory, item);
+    const fullPath = sp3.resolve(path19);
+    isDirectory3 = isDirectory3 != null ? isDirectory3 : this._watched.has(path19) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path19, 100))
+      return;
+    if (!isDirectory3 && this._watched.size === 1) {
+      this.add(directory, item, true);
+    }
+    const wp5 = this._getWatchedDir(path19);
+    const nestedDirectoryChildren = wp5.getChildren();
+    nestedDirectoryChildren.forEach((nested) => this._remove(path19, nested));
+    const parent = this._getWatchedDir(directory);
+    const wasTracked = parent.has(item);
+    parent.remove(item);
+    if (this._symlinkPaths.has(fullPath)) {
+      this._symlinkPaths.delete(fullPath);
+    }
+    let relPath = path19;
+    if (this.options.cwd)
+      relPath = sp3.relative(this.options.cwd, path19);
+    if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+      const event = this._pendingWrites.get(relPath).cancelWait();
+      if (event === EVENTS.ADD)
+        return;
+    }
+    this._watched.delete(path19);
+    this._watched.delete(fullPath);
+    const eventName = isDirectory3 ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
+    if (wasTracked && !this._isIgnored(path19))
+      this._emit(eventName, path19);
+    this._closePath(path19);
+  }
+  _closePath(path19) {
+    this._closeFile(path19);
+    const dir = sp3.dirname(path19);
+    this._getWatchedDir(dir).remove(sp3.basename(path19));
+  }
+  _closeFile(path19) {
+    const closers = this._closers.get(path19);
+    if (!closers)
+      return;
+    closers.forEach((closer) => closer());
+    this._closers.delete(path19);
+  }
+  _addPathCloser(path19, closer) {
+    if (!closer)
+      return;
+    let list3 = this._closers.get(path19);
+    if (!list3) {
+      list3 = [];
+      this._closers.set(path19, list3);
+    }
+    list3.push(closer);
+  }
+  _readdirp(root2, opts) {
+    if (this.closed)
+      return;
+    const options8 = { type: EVENTS.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 };
+    let stream = readdirp(root2, options8);
+    this._streams.add(stream);
+    stream.once(STR_CLOSE, () => {
+      stream = undefined;
+    });
+    stream.once(STR_END, () => {
+      if (stream) {
+        this._streams.delete(stream);
+        stream = undefined;
+      }
+    });
+    return stream;
+  }
+}
+function watch(paths, options8 = {}) {
+  const watcher = new FSWatcher(options8);
+  watcher.add(paths);
+  return watcher;
+}
+
+// src/cli/dev/dev-server/watcher.ts
+var import_debounce = __toESM(require_debounce(), 1);
+var WATCH_DEBOUNCE_MS = 300;
+var WATCH_QUEUE_DELAY_MS = 500;
+
+class WatchBase44 extends EventEmitter4 {
+  itemsToWatch;
+  logger;
+  entryNames;
+  watchers = new Map;
+  queueWaitForCreationTimeout = null;
+  constructor(itemsToWatch, logger) {
+    super();
+    this.itemsToWatch = itemsToWatch;
+    this.logger = logger;
+    this.entryNames = Object.keys(itemsToWatch);
+  }
+  async start() {
+    if (this.watchers.size > 0) {
+      return;
+    }
+    for (const name2 of this.entryNames) {
+      const targetPath = this.itemsToWatch[name2];
+      if (await pathExists(targetPath)) {
+        this.watchers.set(name2, this.watchTarget(name2, targetPath));
+      }
+    }
+    this.watchEntries();
+  }
+  async close() {
+    if (this.queueWaitForCreationTimeout) {
+      clearTimeout(this.queueWaitForCreationTimeout);
+      this.queueWaitForCreationTimeout = null;
+    }
+    for (const watcher of this.watchers.values()) {
+      await watcher.close();
+    }
+    this.watchers.clear();
+  }
+  watchEntries() {
+    if (this.queueWaitForCreationTimeout) {
+      clearTimeout(this.queueWaitForCreationTimeout);
+    }
+    this.queueWaitForCreationTimeout = setTimeout(async () => {
+      for (const name2 of this.entryNames) {
+        const path19 = this.itemsToWatch[name2];
+        const watchItem = this.watchers.get(name2);
+        const exists = await pathExists(path19);
+        if (!watchItem && exists) {
+          this.emit("change", name2, path19);
+          this.watchers.set(name2, this.watchTarget(name2, path19));
+        } else if (watchItem && !exists) {
+          await watchItem.close();
+          this.emit("change", name2, path19);
+          setTimeout(() => {
+            this.watchers.forEach((watcher, watcherName) => {
+              if (watcher.closed) {
+                this.watchers.delete(watcherName);
+              }
+            });
+          });
+        }
+      }
+      this.queueWaitForCreationTimeout = null;
+      this.watchEntries();
+    }, WATCH_QUEUE_DELAY_MS);
+  }
+  watchTarget(name2, targetPath) {
+    const watcher = watch(targetPath, {
+      ignoreInitial: true
+    });
+    watcher.on("all", import_debounce.default(async (_event, path19) => {
+      this.emit("change", name2, relative4(targetPath, path19));
+    }, WATCH_DEBOUNCE_MS));
+    watcher.on("error", (err) => {
+      this.logger.error(`Watch handler failed for ${targetPath}`, err instanceof Error ? err : undefined);
+    });
+    return watcher;
+  }
+}
+
 // src/cli/dev/dev-server/main.ts
 var DEFAULT_PORT = 4400;
 var BASE44_APP_URL = "https://base44.app";
@@ -244265,7 +246321,7 @@ async function createDevServer(options8) {
   const { port: userPort } = options8;
   const port = userPort ?? await getPorts({ port: DEFAULT_PORT });
   const baseUrl = `http://localhost:${port}`;
-  const { functions, entities } = await options8.loadResources();
+  const { functions, entities, project: project2 } = await options8.loadResources();
   const app = import_express4.default();
   const remoteProxy = import_http_proxy_middleware2.createProxyMiddleware({
     target: BASE44_APP_URL,
@@ -244285,12 +246341,13 @@ async function createDevServer(options8) {
   });
   const devLogger = createDevLogger();
   const functionManager = new FunctionManager(functions, devLogger);
+  const functionRoutes = createFunctionRouter(functionManager, devLogger);
+  app.use("/api/apps/:appId/functions", functionRoutes);
   if (functionManager.getFunctionNames().length > 0) {
     R2.info(`Loaded functions: ${functionManager.getFunctionNames().join(", ")}`);
-    const functionRoutes = createFunctionRouter(functionManager, devLogger);
-    app.use("/api/apps/:appId/functions", functionRoutes);
   }
-  const db2 = new Database(entities);
+  const db2 = new Database;
+  db2.load(entities);
   if (db2.getCollectionNames().length > 0) {
     R2.info(`Loaded entities: ${db2.getCollectionNames().join(", ")}`);
   }
@@ -244307,8 +246364,8 @@ async function createDevServer(options8) {
     devLogger.warn(`"${req.originalUrl}" is not supported in local development, passing call to production`);
     remoteProxy(req, res, next);
   });
-  return new Promise((resolve6, reject) => {
-    const server = app.listen(port, "127.0.0.1", (err) => {
+  const server = await new Promise((resolve8, reject) => {
+    const s5 = app.listen(port, "127.0.0.1", (err) => {
       if (err) {
         if ("code" in err && err.code === "EADDRINUSE") {
           reject(new Error(`Port ${port} is already in use. Stop the other process and try again.`));
@@ -244316,24 +246373,57 @@ async function createDevServer(options8) {
           reject(err);
         }
       } else {
-        const io6 = createRealtimeServer(server);
-        emitEntityEvent = (appId, entityName, event) => {
-          broadcastEntityEvent(io6, appId, entityName, event);
-        };
-        const shutdown = () => {
-          io6.close();
-          functionManager.stopAll();
-          server.close();
-        };
-        process.on("SIGINT", shutdown);
-        process.on("SIGTERM", shutdown);
-        resolve6({
-          port,
-          server
-        });
+        resolve8(s5);
       }
     });
   });
+  const io6 = createRealtimeServer(server);
+  emitEntityEvent = (appId, entityName, event) => {
+    broadcastEntityEvent(io6, appId, entityName, event);
+  };
+  const base44ConfigWatcher = new WatchBase44({
+    functions: join18(dirname14(project2.configPath), project2.functionsDir),
+    entities: join18(dirname14(project2.configPath), project2.entitiesDir)
+  }, devLogger);
+  base44ConfigWatcher.on("change", async (name2) => {
+    try {
+      const { functions: functions2, entities: entities2 } = await options8.loadResources();
+      if (name2 === "functions") {
+        const previousFunctionCount = functionManager.getFunctionNames().length;
+        functionManager.reload(functions2);
+        const names = functionManager.getFunctionNames();
+        if (names.length > 0) {
+          devLogger.log(`Reloaded functions: ${names.sort().join(", ")}`);
+        } else if (previousFunctionCount > 0) {
+          devLogger.log("All functions removed");
+        }
+      }
+      if (name2 === "entities") {
+        const previousEntityCount = db2.getCollectionNames().length;
+        db2.dropAll();
+        if (previousEntityCount > 0) {
+          devLogger.log("Entities directory changed, clearing data...");
+        }
+        db2.load(entities2);
+        if (db2.getCollectionNames().length > 0) {
+          devLogger.log(`Loaded entities: ${db2.getCollectionNames().join(", ")}`);
+        }
+      }
+    } catch (error48) {
+      const errorMessage = error48 instanceof Error ? error48.message : String(error48);
+      devLogger.error(errorMessage);
+    }
+  });
+  await base44ConfigWatcher.start();
+  const shutdown = () => {
+    base44ConfigWatcher.close();
+    io6.close();
+    functionManager.stopAll();
+    server.close();
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  return { port, server };
 }
 
 // src/cli/commands/dev.ts
@@ -244357,8 +246447,8 @@ function getDevCommand(context) {
 }
 
 // src/cli/commands/project/eject.ts
-import { resolve as resolve6 } from "node:path";
-var import_lodash2 = __toESM(require_lodash(), 1);
+import { resolve as resolve8 } from "node:path";
+var import_kebabCase2 = __toESM(require_kebabCase(), 1);
 async function eject(options8) {
   const projects = await listProjects();
   const ejectableProjects = projects.filter((p4) => p4.isManagedSourceCode !== false);
@@ -244396,7 +246486,7 @@ async function eject(options8) {
     selectedProject = selected;
   }
   const projectId = selectedProject.id;
-  const suggestedPath = await isDirEmpty() ? `./` : `./${import_lodash2.default(selectedProject.name)}`;
+  const suggestedPath = await isDirEmpty() ? `./` : `./${import_kebabCase2.default(selectedProject.name)}`;
   const selectedPath = options8.path ?? await Ze({
     message: "Where should we create your project?",
     placeholder: suggestedPath,
@@ -244406,7 +246496,7 @@ async function eject(options8) {
     Ne("Operation cancelled.");
     throw new CLIExitError(0);
   }
-  const resolvedPath = resolve6(selectedPath);
+  const resolvedPath = resolve8(selectedPath);
   await runTask("Downloading your project's code...", async (updateMessage) => {
     await createProjectFilesForExistingProject({
       projectId,
@@ -244482,7 +246572,7 @@ var import_detect_agent = __toESM(require_dist5(), 1);
 import { release, type } from "node:os";
 
 // node_modules/posthog-node/dist/extensions/error-tracking/modifiers/module.node.mjs
-import { dirname as dirname12, posix, sep } from "path";
+import { dirname as dirname15, posix, sep } from "path";
 function createModulerModifier() {
   const getModuleFromFileName = createGetModuleFromFilename();
   return async (frames) => {
@@ -244491,12 +246581,12 @@ function createModulerModifier() {
     return frames;
   };
 }
-function createGetModuleFromFilename(basePath = process.argv[1] ? dirname12(process.argv[1]) : process.cwd(), isWindows4 = sep === "\\") {
-  const normalizedBase = isWindows4 ? normalizeWindowsPath2(basePath) : basePath;
+function createGetModuleFromFilename(basePath = process.argv[1] ? dirname15(process.argv[1]) : process.cwd(), isWindows5 = sep === "\\") {
+  const normalizedBase = isWindows5 ? normalizeWindowsPath2(basePath) : basePath;
   return (filename) => {
     if (!filename)
       return;
-    const normalizedFilename = isWindows4 ? normalizeWindowsPath2(filename) : filename;
+    const normalizedFilename = isWindows5 ? normalizeWindowsPath2(filename) : filename;
     let { dir, base: file2, ext } = posix.parse(normalizedFilename);
     if (ext === ".js" || ext === ".mjs" || ext === ".cjs")
       file2 = file2.slice(0, -1 * ext.length);
@@ -246769,14 +248859,14 @@ async function addSourceContext(frames) {
   return frames;
 }
 function getContextLinesFromFile(path19, ranges, output) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve9) => {
     const stream = createReadStream2(path19);
     const lineReaded = createInterface2({
       input: stream
     });
     function destroyStreamAndResolve() {
       stream.destroy();
-      resolve7();
+      resolve9();
     }
     let lineNumber = 0;
     let currentRangeIndex = 0;
@@ -247888,15 +249978,15 @@ class PostHogBackendClient extends PostHogCoreStateless {
       return true;
     if (this.featureFlagsPoller === undefined)
       return false;
-    return new Promise((resolve7) => {
+    return new Promise((resolve9) => {
       const timeout3 = setTimeout(() => {
         cleanup();
-        resolve7(false);
+        resolve9(false);
       }, timeoutMs);
       const cleanup = this._events.on("localEvaluationFlagsLoaded", (count2) => {
         clearTimeout(timeout3);
         cleanup();
-        resolve7(count2 > 0);
+        resolve9(count2 > 0);
       });
     });
   }
@@ -248709,4 +250799,4 @@ export {
   CLIExitError
 };
 
-//# debugId=98008B65F3D086C764756E2164756E21
+//# debugId=1F612090E5DA7F5064756E2164756E21