@base44-preview/cli 0.1.32-pr.662.e04bb64 → 0.1.32-pr.663.463d401

package/dist/cli/index.js

@@ -31177,7 +31177,7 @@ function cleanDoc(doc) {
   return mapDoc(doc, (currentDoc) => cleanDocFn(currentDoc));
 }
 function replaceEndOfLine(doc, replacement = literalline) {
-  return mapDoc(doc, (currentDoc) => typeof currentDoc === "string" ? join30(replacement, currentDoc.split(`
+  return mapDoc(doc, (currentDoc) => typeof currentDoc === "string" ? join31(replacement, currentDoc.split(`
 `)) : currentDoc);
 }
 function canBreakFn(doc) {
@@ -31257,7 +31257,7 @@ function indentIfBreak(contents, options) {
     negate: options.negate
   };
 }
-function join30(separator, docs) {
+function join31(separator, docs) {
   assertDoc(separator);
   assertDocArray(docs);
   const parts = [];
@@ -31968,7 +31968,7 @@ var init_doc = __esm(() => {
   MODE_FLAT = Symbol("MODE_FLAT");
   DOC_FILL_PRINTED_LENGTH = Symbol("DOC_FILL_PRINTED_LENGTH");
   builders = {
-    join: join30,
+    join: join31,
     line,
     softline,
     hardline,
@@ -119123,7 +119123,7 @@ import url22 from "url";
 function diffLines(oldStr, newStr, options8) {
   return lineDiff.diff(oldStr, newStr, options8);
 }
-function tokenize(value, options8) {
+function tokenize2(value, options8) {
   if (options8.stripTrailingCr) {
     value = value.replace(/\r\n/g, `
 `);
@@ -120053,7 +120053,7 @@ function highlight(text) {
   for (const {
     type,
     value
-  } of tokenize2(text)) {
+  } of tokenize22(text)) {
     if (type in defs) {
       highlighted += value.split(NEWLINE$1).map((str) => defs[type](str)).join(`
 `);
@@ -124581,7 +124581,7 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc2,
     return internalize({ "": root }, "", reviver);
   }
   return root;
-}, lexState, buffer, doubleQuote, sign, c7, lexStates, parseStates, dist_default, import_picocolors4, import_js_tokens, nonASCIIidentifierStartChars = "ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙՠ-ֈא-תׯ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࡠ-ࡪࡰ-ࢇࢉ-࢏ࢠ-ࣉऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱৼਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡૹଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘ-ౚ౜ౝౠౡಀಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽ೜-ೞೠೡೱೲഄ-ഌഎ-ഐഒ-ഺഽൎൔ-ൖൟ-ൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄຆ-ຊຌ-ຣລວ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜑᜟ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡸᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭌᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᲀ-ᲊᲐ-ᲺᲽ-Ჿᳩ-ᳬᳮ-ᳳᳵᳶᳺᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄯㄱ-ㆎㆠ-ㆿㇰ-ㇿ㐀-䶿一-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-Ƛ꟱-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꣽꣾꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭩꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ", nonASCIIidentifierChars = "·̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄؐ-ًؚ-٩ٰۖ-ۜ۟-۪ۤۧۨ-ۭ۰-۹ܑܰ-݊ަ-ް߀-߉߫-߽߳ࠖ-࠙ࠛ-ࠣࠥ-ࠧࠩ-࡙࠭-࡛ࢗ-࢟࣊-ࣣ࣡-ःऺ-़ा-ॏ॑-ॗॢॣ०-९ঁ-ঃ়া-ৄেৈো-্ৗৢৣ০-৯৾ਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑ੦-ੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢૣ૦-૯ૺ-૿ଁ-ଃ଼ା-ୄେୈୋ-୍୕-ୗୢୣ୦-୯ஂா-ூெ-ைொ-்ௗ௦-௯ఀ-ఄ఼ా-ౄె-ైొ-్ౕౖౢౣ౦-౯ಁ-ಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢೣ೦-೯ೳഀ-ഃ഻഼ാ-ൄെ-ൈൊ-്ൗൢൣ൦-൯ඁ-ඃ්ා-ුූෘ-ෟ෦-෯ෲෳัิ-ฺ็-๎๐-๙ັິ-ຼ່-໎໐-໙༘༙༠-༩༹༵༷༾༿ཱ-྄྆྇ྍ-ྗྙ-ྼ࿆ါ-ှ၀-၉ၖ-ၙၞ-ၠၢ-ၤၧ-ၭၱ-ၴႂ-ႍႏ-ႝ፝-፟፩-፱ᜒ-᜕ᜲ-᜴ᝒᝓᝲᝳ឴-៓៝០-៩᠋-᠍᠏-᠙ᢩᤠ-ᤫᤰ-᤻᥆-᥏᧐-᧚ᨗ-ᨛᩕ-ᩞ᩠-᩿᩼-᪉᪐-᪙᪰-᪽ᪿ-᫝᫠-᫫ᬀ-ᬄ᬴-᭄᭐-᭙᭫-᭳ᮀ-ᮂᮡ-ᮭ᮰-᮹᯦-᯳ᰤ-᰷᱀-᱉᱐-᱙᳐-᳔᳒-᳨᳭᳴᳷-᳹᷀-᷿‌‍‿⁀⁔⃐-⃥⃜⃡-⃰⳯-⵿⳱ⷠ-〪ⷿ-゙゚〯・꘠-꘩꙯ꙴ-꙽ꚞꚟ꛰꛱ꠂ꠆ꠋꠣ-ꠧ꠬ꢀꢁꢴ-ꣅ꣐-꣙꣠-꣱ꣿ-꤉ꤦ-꤭ꥇ-꥓ꦀ-ꦃ꦳-꧀꧐-꧙ꧥ꧰-꧹ꨩ-ꨶꩃꩌꩍ꩐-꩙ꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿꫁ꫫ-ꫯꫵ꫶ꯣ-ꯪ꯬꯭꯰-꯹ﬞ︀-️︠-︯︳︴﹍-﹏０-９＿･", nonASCIIidentifierStart, nonASCIIidentifier, reservedWords, keywords, reservedWordsStrictSet, reservedWordsStrictBindSet, compose = (f, g) => (v) => f(g(v)), defsOn, defsOff, sometimesKeywords, NEWLINE$1, BRACKET, tokenize2, NEWLINE, getOffsets = ({
+}, lexState, buffer, doubleQuote, sign, c7, lexStates, parseStates, dist_default, import_picocolors4, import_js_tokens, nonASCIIidentifierStartChars = "ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙՠ-ֈא-תׯ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࡠ-ࡪࡰ-ࢇࢉ-࢏ࢠ-ࣉऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱৼਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡૹଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘ-ౚ౜ౝౠౡಀಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽ೜-ೞೠೡೱೲഄ-ഌഎ-ഐഒ-ഺഽൎൔ-ൖൟ-ൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄຆ-ຊຌ-ຣລວ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜑᜟ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡸᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭌᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᲀ-ᲊᲐ-ᲺᲽ-Ჿᳩ-ᳬᳮ-ᳳᳵᳶᳺᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄯㄱ-ㆎㆠ-ㆿㇰ-ㇿ㐀-䶿一-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-Ƛ꟱-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꣽꣾꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭩꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ", nonASCIIidentifierChars = "·̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄؐ-ًؚ-٩ٰۖ-ۜ۟-۪ۤۧۨ-ۭ۰-۹ܑܰ-݊ަ-ް߀-߉߫-߽߳ࠖ-࠙ࠛ-ࠣࠥ-ࠧࠩ-࡙࠭-࡛ࢗ-࢟࣊-ࣣ࣡-ःऺ-़ा-ॏ॑-ॗॢॣ०-९ঁ-ঃ়া-ৄেৈো-্ৗৢৣ০-৯৾ਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑ੦-ੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢૣ૦-૯ૺ-૿ଁ-ଃ଼ା-ୄେୈୋ-୍୕-ୗୢୣ୦-୯ஂா-ூெ-ைொ-்ௗ௦-௯ఀ-ఄ఼ా-ౄె-ైొ-్ౕౖౢౣ౦-౯ಁ-ಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢೣ೦-೯ೳഀ-ഃ഻഼ാ-ൄെ-ൈൊ-്ൗൢൣ൦-൯ඁ-ඃ්ා-ුූෘ-ෟ෦-෯ෲෳัิ-ฺ็-๎๐-๙ັິ-ຼ່-໎໐-໙༘༙༠-༩༹༵༷༾༿ཱ-྄྆྇ྍ-ྗྙ-ྼ࿆ါ-ှ၀-၉ၖ-ၙၞ-ၠၢ-ၤၧ-ၭၱ-ၴႂ-ႍႏ-ႝ፝-፟፩-፱ᜒ-᜕ᜲ-᜴ᝒᝓᝲᝳ឴-៓៝០-៩᠋-᠍᠏-᠙ᢩᤠ-ᤫᤰ-᤻᥆-᥏᧐-᧚ᨗ-ᨛᩕ-ᩞ᩠-᩿᩼-᪉᪐-᪙᪰-᪽ᪿ-᫝᫠-᫫ᬀ-ᬄ᬴-᭄᭐-᭙᭫-᭳ᮀ-ᮂᮡ-ᮭ᮰-᮹᯦-᯳ᰤ-᰷᱀-᱉᱐-᱙᳐-᳔᳒-᳨᳭᳴᳷-᳹᷀-᷿‌‍‿⁀⁔⃐-⃥⃜⃡-⃰⳯-⵿⳱ⷠ-〪ⷿ-゙゚〯・꘠-꘩꙯ꙴ-꙽ꚞꚟ꛰꛱ꠂ꠆ꠋꠣ-ꠧ꠬ꢀꢁꢴ-ꣅ꣐-꣙꣠-꣱ꣿ-꤉ꤦ-꤭ꥇ-꥓ꦀ-ꦃ꦳-꧀꧐-꧙ꧥ꧰-꧹ꨩ-ꨶꩃꩌꩍ꩐-꩙ꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿꫁ꫫ-ꫯꫵ꫶ꯣ-ꯪ꯬꯭꯰-꯹ﬞ︀-️︠-︯︳︴﹍-﹏０-９＿･", nonASCIIidentifierStart, nonASCIIidentifier, reservedWords, keywords, reservedWordsStrictSet, reservedWordsStrictBindSet, compose = (f, g) => (v) => f(g(v)), defsOn, defsOff, sometimesKeywords, NEWLINE$1, BRACKET, tokenize22, NEWLINE, getOffsets = ({
   oneBased,
   oneBasedLine = oneBased,
   oneBasedColumn = oneBased
@@ -124807,7 +124807,7 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc2,
     }
   }
 }, ast_path_default, is_object_default, skipWhitespace, skipSpaces, skipToLineEnd, skipEverythingButNewLine, isNewlineCharacter = (character) => character === `
-` || character === "\r" || character === "\u2028" || character === "\u2029", skip_newline_default, has_newline_default, is_non_empty_array_default, get_sorted_child_nodes_default, childNodesCache, returnFalse = () => false, isAllEmptyAndNoLineBreak = (text) => !/[\S\n\u2028\u2029]/u.test(text), is_previous_line_empty_default, breakParent2, hardline2, indent2, join32, line22, lineSuffix2, create_print_pre_check_function_default = () => noop_default2, core_options_evaluate_default, arrayToReversed, toReversed, method_to_reversed_default, import_n_readlines, get_interpreter_default, getFileBasename = (file) => {
+` || character === "\r" || character === "\u2028" || character === "\u2029", skip_newline_default, has_newline_default, is_non_empty_array_default, get_sorted_child_nodes_default, childNodesCache, returnFalse = () => false, isAllEmptyAndNoLineBreak = (text) => !/[\S\n\u2028\u2029]/u.test(text), is_previous_line_empty_default, breakParent2, hardline2, indent2, join33, line22, lineSuffix2, create_print_pre_check_function_default = () => noop_default2, core_options_evaluate_default, arrayToReversed, toReversed, method_to_reversed_default, import_n_readlines, get_interpreter_default, getFileBasename = (file) => {
   try {
     return path112.basename(toPath3(file));
   } catch {
@@ -133471,7 +133471,7 @@ globstar while`, file, fr, pattern, pr, swallowee);
   LineDiff = class extends Diff {
     constructor() {
       super(...arguments);
-      this.tokenize = tokenize;
+      this.tokenize = tokenize2;
     }
     equals(left, right, options8) {
       if (options8.ignoreWhitespace) {
@@ -134348,7 +134348,7 @@ globstar while`, file, fr, pattern, pr, swallowee);
           return "uncolored";
       }
     };
-    tokenize2 = function* (text) {
+    tokenize22 = function* (text) {
       for (const token2 of (0, import_js_tokens.default)(text, {
         jsx: true
       })) {
@@ -134836,7 +134836,7 @@ ${codeblock}`, options8);
     breakParent: breakParent2,
     hardline: hardline2,
     indent: indent2,
-    join: join32,
+    join: join33,
     line: line22,
     lineSuffix: lineSuffix2
   } = builders);
@@ -228838,7 +228838,7 @@ function normalizeBase44Env() {
 loadProjectEnvFiles();
 
 // src/cli/index.ts
-import { dirname as dirname29, join as join40 } from "node:path";
+import { dirname as dirname29, join as join41 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 
 // ../../node_modules/@clack/core/dist/index.mjs
@@ -239451,6 +239451,7 @@ var package_default = {
     jsonwebtoken: "^9.0.3",
     ky: "^1.14.2",
     lodash: "^4.17.23",
+    minisearch: "7.1.2",
     ms: "^2.1.3",
     multer: "^2.0.0",
     nanoid: "^5.1.6",
@@ -247586,8 +247587,8 @@ function normalizeDatetime(value) {
   return `${value}Z`;
 }
 // src/cli/utils/json.ts
-function toJsonStdout(result) {
-  return `${JSON.stringify(result, null, 2)}
+function toJsonStdout(result, options = {}) {
+  return `${JSON.stringify(result, null, options.compact ? undefined : 2)}
 `;
 }
 // src/cli/errors.ts
@@ -248041,13 +248042,1767 @@ function getAgentsCommand() {
   return new Command2("agents").description("Manage project agents").addCommand(getAgentsPushCommand()).addCommand(getAgentsPullCommand());
 }
 
+// ../../node_modules/minisearch/dist/es/index.js
+var ENTRIES = "ENTRIES";
+var KEYS = "KEYS";
+var VALUES = "VALUES";
+var LEAF = "";
+
+class TreeIterator {
+  constructor(set, type) {
+    const node = set._tree;
+    const keys = Array.from(node.keys());
+    this.set = set;
+    this._type = type;
+    this._path = keys.length > 0 ? [{ node, keys }] : [];
+  }
+  next() {
+    const value = this.dive();
+    this.backtrack();
+    return value;
+  }
+  dive() {
+    if (this._path.length === 0) {
+      return { done: true, value: undefined };
+    }
+    const { node, keys } = last$1(this._path);
+    if (last$1(keys) === LEAF) {
+      return { done: false, value: this.result() };
+    }
+    const child = node.get(last$1(keys));
+    this._path.push({ node: child, keys: Array.from(child.keys()) });
+    return this.dive();
+  }
+  backtrack() {
+    if (this._path.length === 0) {
+      return;
+    }
+    const keys = last$1(this._path).keys;
+    keys.pop();
+    if (keys.length > 0) {
+      return;
+    }
+    this._path.pop();
+    this.backtrack();
+  }
+  key() {
+    return this.set._prefix + this._path.map(({ keys }) => last$1(keys)).filter((key) => key !== LEAF).join("");
+  }
+  value() {
+    return last$1(this._path).node.get(LEAF);
+  }
+  result() {
+    switch (this._type) {
+      case VALUES:
+        return this.value();
+      case KEYS:
+        return this.key();
+      default:
+        return [this.key(), this.value()];
+    }
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+}
+var last$1 = (array) => {
+  return array[array.length - 1];
+};
+var fuzzySearch = (node, query, maxDistance) => {
+  const results = new Map;
+  if (query === undefined)
+    return results;
+  const n = query.length + 1;
+  const m = n + maxDistance;
+  const matrix = new Uint8Array(m * n).fill(maxDistance + 1);
+  for (let j = 0;j < n; ++j)
+    matrix[j] = j;
+  for (let i = 1;i < m; ++i)
+    matrix[i * n] = i;
+  recurse(node, query, maxDistance, results, matrix, 1, n, "");
+  return results;
+};
+var recurse = (node, query, maxDistance, results, matrix, m, n, prefix) => {
+  const offset = m * n;
+  key:
+    for (const key of node.keys()) {
+      if (key === LEAF) {
+        const distance = matrix[offset - 1];
+        if (distance <= maxDistance) {
+          results.set(prefix, [node.get(key), distance]);
+        }
+      } else {
+        let i = m;
+        for (let pos = 0;pos < key.length; ++pos, ++i) {
+          const char = key[pos];
+          const thisRowOffset = n * i;
+          const prevRowOffset = thisRowOffset - n;
+          let minDistance = matrix[thisRowOffset];
+          const jmin = Math.max(0, i - maxDistance - 1);
+          const jmax = Math.min(n - 1, i + maxDistance);
+          for (let j = jmin;j < jmax; ++j) {
+            const different = char !== query[j];
+            const rpl = matrix[prevRowOffset + j] + +different;
+            const del = matrix[prevRowOffset + j + 1] + 1;
+            const ins = matrix[thisRowOffset + j] + 1;
+            const dist = matrix[thisRowOffset + j + 1] = Math.min(rpl, del, ins);
+            if (dist < minDistance)
+              minDistance = dist;
+          }
+          if (minDistance > maxDistance) {
+            continue key;
+          }
+        }
+        recurse(node.get(key), query, maxDistance, results, matrix, i, n, prefix + key);
+      }
+    }
+};
+
+class SearchableMap {
+  constructor(tree = new Map, prefix = "") {
+    this._size = undefined;
+    this._tree = tree;
+    this._prefix = prefix;
+  }
+  atPrefix(prefix) {
+    if (!prefix.startsWith(this._prefix)) {
+      throw new Error("Mismatched prefix");
+    }
+    const [node, path] = trackDown(this._tree, prefix.slice(this._prefix.length));
+    if (node === undefined) {
+      const [parentNode, key] = last(path);
+      for (const k of parentNode.keys()) {
+        if (k !== LEAF && k.startsWith(key)) {
+          const node = new Map;
+          node.set(k.slice(key.length), parentNode.get(k));
+          return new SearchableMap(node, prefix);
+        }
+      }
+    }
+    return new SearchableMap(node, prefix);
+  }
+  clear() {
+    this._size = undefined;
+    this._tree.clear();
+  }
+  delete(key) {
+    this._size = undefined;
+    return remove(this._tree, key);
+  }
+  entries() {
+    return new TreeIterator(this, ENTRIES);
+  }
+  forEach(fn) {
+    for (const [key, value] of this) {
+      fn(key, value, this);
+    }
+  }
+  fuzzyGet(key, maxEditDistance) {
+    return fuzzySearch(this._tree, key, maxEditDistance);
+  }
+  get(key) {
+    const node = lookup(this._tree, key);
+    return node !== undefined ? node.get(LEAF) : undefined;
+  }
+  has(key) {
+    const node = lookup(this._tree, key);
+    return node !== undefined && node.has(LEAF);
+  }
+  keys() {
+    return new TreeIterator(this, KEYS);
+  }
+  set(key, value) {
+    if (typeof key !== "string") {
+      throw new Error("key must be a string");
+    }
+    this._size = undefined;
+    const node = createPath(this._tree, key);
+    node.set(LEAF, value);
+    return this;
+  }
+  get size() {
+    if (this._size) {
+      return this._size;
+    }
+    this._size = 0;
+    const iter = this.entries();
+    while (!iter.next().done)
+      this._size += 1;
+    return this._size;
+  }
+  update(key, fn) {
+    if (typeof key !== "string") {
+      throw new Error("key must be a string");
+    }
+    this._size = undefined;
+    const node = createPath(this._tree, key);
+    node.set(LEAF, fn(node.get(LEAF)));
+    return this;
+  }
+  fetch(key, initial) {
+    if (typeof key !== "string") {
+      throw new Error("key must be a string");
+    }
+    this._size = undefined;
+    const node = createPath(this._tree, key);
+    let value = node.get(LEAF);
+    if (value === undefined) {
+      node.set(LEAF, value = initial());
+    }
+    return value;
+  }
+  values() {
+    return new TreeIterator(this, VALUES);
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  static from(entries) {
+    const tree = new SearchableMap;
+    for (const [key, value] of entries) {
+      tree.set(key, value);
+    }
+    return tree;
+  }
+  static fromObject(object) {
+    return SearchableMap.from(Object.entries(object));
+  }
+}
+var trackDown = (tree, key, path = []) => {
+  if (key.length === 0 || tree == null) {
+    return [tree, path];
+  }
+  for (const k of tree.keys()) {
+    if (k !== LEAF && key.startsWith(k)) {
+      path.push([tree, k]);
+      return trackDown(tree.get(k), key.slice(k.length), path);
+    }
+  }
+  path.push([tree, key]);
+  return trackDown(undefined, "", path);
+};
+var lookup = (tree, key) => {
+  if (key.length === 0 || tree == null) {
+    return tree;
+  }
+  for (const k of tree.keys()) {
+    if (k !== LEAF && key.startsWith(k)) {
+      return lookup(tree.get(k), key.slice(k.length));
+    }
+  }
+};
+var createPath = (node, key) => {
+  const keyLength = key.length;
+  outer:
+    for (let pos = 0;node && pos < keyLength; ) {
+      for (const k of node.keys()) {
+        if (k !== LEAF && key[pos] === k[0]) {
+          const len = Math.min(keyLength - pos, k.length);
+          let offset = 1;
+          while (offset < len && key[pos + offset] === k[offset])
+            ++offset;
+          const child = node.get(k);
+          if (offset === k.length) {
+            node = child;
+          } else {
+            const intermediate = new Map;
+            intermediate.set(k.slice(offset), child);
+            node.set(key.slice(pos, pos + offset), intermediate);
+            node.delete(k);
+            node = intermediate;
+          }
+          pos += offset;
+          continue outer;
+        }
+      }
+      const child = new Map;
+      node.set(key.slice(pos), child);
+      return child;
+    }
+  return node;
+};
+var remove = (tree, key) => {
+  const [node, path] = trackDown(tree, key);
+  if (node === undefined) {
+    return;
+  }
+  node.delete(LEAF);
+  if (node.size === 0) {
+    cleanup(path);
+  } else if (node.size === 1) {
+    const [key, value] = node.entries().next().value;
+    merge3(path, key, value);
+  }
+};
+var cleanup = (path) => {
+  if (path.length === 0) {
+    return;
+  }
+  const [node, key] = last(path);
+  node.delete(key);
+  if (node.size === 0) {
+    cleanup(path.slice(0, -1));
+  } else if (node.size === 1) {
+    const [key, value] = node.entries().next().value;
+    if (key !== LEAF) {
+      merge3(path.slice(0, -1), key, value);
+    }
+  }
+};
+var merge3 = (path, key, value) => {
+  if (path.length === 0) {
+    return;
+  }
+  const [node, nodeKey] = last(path);
+  node.set(nodeKey + key, value);
+  node.delete(nodeKey);
+};
+var last = (array) => {
+  return array[array.length - 1];
+};
+var OR = "or";
+var AND = "and";
+var AND_NOT = "and_not";
+
+class MiniSearch {
+  constructor(options) {
+    if ((options === null || options === undefined ? undefined : options.fields) == null) {
+      throw new Error('MiniSearch: option "fields" must be provided');
+    }
+    const autoVacuum = options.autoVacuum == null || options.autoVacuum === true ? defaultAutoVacuumOptions : options.autoVacuum;
+    this._options = {
+      ...defaultOptions,
+      ...options,
+      autoVacuum,
+      searchOptions: { ...defaultSearchOptions, ...options.searchOptions || {} },
+      autoSuggestOptions: { ...defaultAutoSuggestOptions, ...options.autoSuggestOptions || {} }
+    };
+    this._index = new SearchableMap;
+    this._documentCount = 0;
+    this._documentIds = new Map;
+    this._idToShortId = new Map;
+    this._fieldIds = {};
+    this._fieldLength = new Map;
+    this._avgFieldLength = [];
+    this._nextId = 0;
+    this._storedFields = new Map;
+    this._dirtCount = 0;
+    this._currentVacuum = null;
+    this._enqueuedVacuum = null;
+    this._enqueuedVacuumConditions = defaultVacuumConditions;
+    this.addFields(this._options.fields);
+  }
+  add(document2) {
+    const { extractField, tokenize, processTerm, fields, idField } = this._options;
+    const id = extractField(document2, idField);
+    if (id == null) {
+      throw new Error(`MiniSearch: document does not have ID field "${idField}"`);
+    }
+    if (this._idToShortId.has(id)) {
+      throw new Error(`MiniSearch: duplicate ID ${id}`);
+    }
+    const shortDocumentId = this.addDocumentId(id);
+    this.saveStoredFields(shortDocumentId, document2);
+    for (const field of fields) {
+      const fieldValue = extractField(document2, field);
+      if (fieldValue == null)
+        continue;
+      const tokens = tokenize(fieldValue.toString(), field);
+      const fieldId = this._fieldIds[field];
+      const uniqueTerms = new Set(tokens).size;
+      this.addFieldLength(shortDocumentId, fieldId, this._documentCount - 1, uniqueTerms);
+      for (const term of tokens) {
+        const processedTerm = processTerm(term, field);
+        if (Array.isArray(processedTerm)) {
+          for (const t of processedTerm) {
+            this.addTerm(fieldId, shortDocumentId, t);
+          }
+        } else if (processedTerm) {
+          this.addTerm(fieldId, shortDocumentId, processedTerm);
+        }
+      }
+    }
+  }
+  addAll(documents) {
+    for (const document2 of documents)
+      this.add(document2);
+  }
+  addAllAsync(documents, options = {}) {
+    const { chunkSize = 10 } = options;
+    const acc = { chunk: [], promise: Promise.resolve() };
+    const { chunk, promise } = documents.reduce(({ chunk, promise }, document2, i) => {
+      chunk.push(document2);
+      if ((i + 1) % chunkSize === 0) {
+        return {
+          chunk: [],
+          promise: promise.then(() => new Promise((resolve) => setTimeout(resolve, 0))).then(() => this.addAll(chunk))
+        };
+      } else {
+        return { chunk, promise };
+      }
+    }, acc);
+    return promise.then(() => this.addAll(chunk));
+  }
+  remove(document2) {
+    const { tokenize, processTerm, extractField, fields, idField } = this._options;
+    const id = extractField(document2, idField);
+    if (id == null) {
+      throw new Error(`MiniSearch: document does not have ID field "${idField}"`);
+    }
+    const shortId = this._idToShortId.get(id);
+    if (shortId == null) {
+      throw new Error(`MiniSearch: cannot remove document with ID ${id}: it is not in the index`);
+    }
+    for (const field of fields) {
+      const fieldValue = extractField(document2, field);
+      if (fieldValue == null)
+        continue;
+      const tokens = tokenize(fieldValue.toString(), field);
+      const fieldId = this._fieldIds[field];
+      const uniqueTerms = new Set(tokens).size;
+      this.removeFieldLength(shortId, fieldId, this._documentCount, uniqueTerms);
+      for (const term of tokens) {
+        const processedTerm = processTerm(term, field);
+        if (Array.isArray(processedTerm)) {
+          for (const t of processedTerm) {
+            this.removeTerm(fieldId, shortId, t);
+          }
+        } else if (processedTerm) {
+          this.removeTerm(fieldId, shortId, processedTerm);
+        }
+      }
+    }
+    this._storedFields.delete(shortId);
+    this._documentIds.delete(shortId);
+    this._idToShortId.delete(id);
+    this._fieldLength.delete(shortId);
+    this._documentCount -= 1;
+  }
+  removeAll(documents) {
+    if (documents) {
+      for (const document2 of documents)
+        this.remove(document2);
+    } else if (arguments.length > 0) {
+      throw new Error("Expected documents to be present. Omit the argument to remove all documents.");
+    } else {
+      this._index = new SearchableMap;
+      this._documentCount = 0;
+      this._documentIds = new Map;
+      this._idToShortId = new Map;
+      this._fieldLength = new Map;
+      this._avgFieldLength = [];
+      this._storedFields = new Map;
+      this._nextId = 0;
+    }
+  }
+  discard(id) {
+    const shortId = this._idToShortId.get(id);
+    if (shortId == null) {
+      throw new Error(`MiniSearch: cannot discard document with ID ${id}: it is not in the index`);
+    }
+    this._idToShortId.delete(id);
+    this._documentIds.delete(shortId);
+    this._storedFields.delete(shortId);
+    (this._fieldLength.get(shortId) || []).forEach((fieldLength, fieldId) => {
+      this.removeFieldLength(shortId, fieldId, this._documentCount, fieldLength);
+    });
+    this._fieldLength.delete(shortId);
+    this._documentCount -= 1;
+    this._dirtCount += 1;
+    this.maybeAutoVacuum();
+  }
+  maybeAutoVacuum() {
+    if (this._options.autoVacuum === false) {
+      return;
+    }
+    const { minDirtFactor, minDirtCount, batchSize, batchWait } = this._options.autoVacuum;
+    this.conditionalVacuum({ batchSize, batchWait }, { minDirtCount, minDirtFactor });
+  }
+  discardAll(ids) {
+    const autoVacuum = this._options.autoVacuum;
+    try {
+      this._options.autoVacuum = false;
+      for (const id of ids) {
+        this.discard(id);
+      }
+    } finally {
+      this._options.autoVacuum = autoVacuum;
+    }
+    this.maybeAutoVacuum();
+  }
+  replace(updatedDocument) {
+    const { idField, extractField } = this._options;
+    const id = extractField(updatedDocument, idField);
+    this.discard(id);
+    this.add(updatedDocument);
+  }
+  vacuum(options = {}) {
+    return this.conditionalVacuum(options);
+  }
+  conditionalVacuum(options, conditions) {
+    if (this._currentVacuum) {
+      this._enqueuedVacuumConditions = this._enqueuedVacuumConditions && conditions;
+      if (this._enqueuedVacuum != null) {
+        return this._enqueuedVacuum;
+      }
+      this._enqueuedVacuum = this._currentVacuum.then(() => {
+        const conditions = this._enqueuedVacuumConditions;
+        this._enqueuedVacuumConditions = defaultVacuumConditions;
+        return this.performVacuuming(options, conditions);
+      });
+      return this._enqueuedVacuum;
+    }
+    if (this.vacuumConditionsMet(conditions) === false) {
+      return Promise.resolve();
+    }
+    this._currentVacuum = this.performVacuuming(options);
+    return this._currentVacuum;
+  }
+  async performVacuuming(options, conditions) {
+    const initialDirtCount = this._dirtCount;
+    if (this.vacuumConditionsMet(conditions)) {
+      const batchSize = options.batchSize || defaultVacuumOptions.batchSize;
+      const batchWait = options.batchWait || defaultVacuumOptions.batchWait;
+      let i = 1;
+      for (const [term, fieldsData] of this._index) {
+        for (const [fieldId, fieldIndex] of fieldsData) {
+          for (const [shortId] of fieldIndex) {
+            if (this._documentIds.has(shortId)) {
+              continue;
+            }
+            if (fieldIndex.size <= 1) {
+              fieldsData.delete(fieldId);
+            } else {
+              fieldIndex.delete(shortId);
+            }
+          }
+        }
+        if (this._index.get(term).size === 0) {
+          this._index.delete(term);
+        }
+        if (i % batchSize === 0) {
+          await new Promise((resolve) => setTimeout(resolve, batchWait));
+        }
+        i += 1;
+      }
+      this._dirtCount -= initialDirtCount;
+    }
+    await null;
+    this._currentVacuum = this._enqueuedVacuum;
+    this._enqueuedVacuum = null;
+  }
+  vacuumConditionsMet(conditions) {
+    if (conditions == null) {
+      return true;
+    }
+    let { minDirtCount, minDirtFactor } = conditions;
+    minDirtCount = minDirtCount || defaultAutoVacuumOptions.minDirtCount;
+    minDirtFactor = minDirtFactor || defaultAutoVacuumOptions.minDirtFactor;
+    return this.dirtCount >= minDirtCount && this.dirtFactor >= minDirtFactor;
+  }
+  get isVacuuming() {
+    return this._currentVacuum != null;
+  }
+  get dirtCount() {
+    return this._dirtCount;
+  }
+  get dirtFactor() {
+    return this._dirtCount / (1 + this._documentCount + this._dirtCount);
+  }
+  has(id) {
+    return this._idToShortId.has(id);
+  }
+  getStoredFields(id) {
+    const shortId = this._idToShortId.get(id);
+    if (shortId == null) {
+      return;
+    }
+    return this._storedFields.get(shortId);
+  }
+  search(query, searchOptions = {}) {
+    const { searchOptions: globalSearchOptions } = this._options;
+    const searchOptionsWithDefaults = { ...globalSearchOptions, ...searchOptions };
+    const rawResults = this.executeQuery(query, searchOptions);
+    const results = [];
+    for (const [docId, { score, terms, match }] of rawResults) {
+      const quality = terms.length || 1;
+      const result = {
+        id: this._documentIds.get(docId),
+        score: score * quality,
+        terms: Object.keys(match),
+        queryTerms: terms,
+        match
+      };
+      Object.assign(result, this._storedFields.get(docId));
+      if (searchOptionsWithDefaults.filter == null || searchOptionsWithDefaults.filter(result)) {
+        results.push(result);
+      }
+    }
+    if (query === MiniSearch.wildcard && searchOptionsWithDefaults.boostDocument == null) {
+      return results;
+    }
+    results.sort(byScore);
+    return results;
+  }
+  autoSuggest(queryString, options = {}) {
+    options = { ...this._options.autoSuggestOptions, ...options };
+    const suggestions = new Map;
+    for (const { score, terms } of this.search(queryString, options)) {
+      const phrase = terms.join(" ");
+      const suggestion = suggestions.get(phrase);
+      if (suggestion != null) {
+        suggestion.score += score;
+        suggestion.count += 1;
+      } else {
+        suggestions.set(phrase, { score, terms, count: 1 });
+      }
+    }
+    const results = [];
+    for (const [suggestion, { score, terms, count }] of suggestions) {
+      results.push({ suggestion, terms, score: score / count });
+    }
+    results.sort(byScore);
+    return results;
+  }
+  get documentCount() {
+    return this._documentCount;
+  }
+  get termCount() {
+    return this._index.size;
+  }
+  static loadJSON(json, options) {
+    if (options == null) {
+      throw new Error("MiniSearch: loadJSON should be given the same options used when serializing the index");
+    }
+    return this.loadJS(JSON.parse(json), options);
+  }
+  static async loadJSONAsync(json, options) {
+    if (options == null) {
+      throw new Error("MiniSearch: loadJSON should be given the same options used when serializing the index");
+    }
+    return this.loadJSAsync(JSON.parse(json), options);
+  }
+  static getDefault(optionName) {
+    if (defaultOptions.hasOwnProperty(optionName)) {
+      return getOwnProperty(defaultOptions, optionName);
+    } else {
+      throw new Error(`MiniSearch: unknown option "${optionName}"`);
+    }
+  }
+  static loadJS(js, options) {
+    const { index, documentIds, fieldLength, storedFields, serializationVersion } = js;
+    const miniSearch = this.instantiateMiniSearch(js, options);
+    miniSearch._documentIds = objectToNumericMap(documentIds);
+    miniSearch._fieldLength = objectToNumericMap(fieldLength);
+    miniSearch._storedFields = objectToNumericMap(storedFields);
+    for (const [shortId, id] of miniSearch._documentIds) {
+      miniSearch._idToShortId.set(id, shortId);
+    }
+    for (const [term, data] of index) {
+      const dataMap = new Map;
+      for (const fieldId of Object.keys(data)) {
+        let indexEntry = data[fieldId];
+        if (serializationVersion === 1) {
+          indexEntry = indexEntry.ds;
+        }
+        dataMap.set(parseInt(fieldId, 10), objectToNumericMap(indexEntry));
+      }
+      miniSearch._index.set(term, dataMap);
+    }
+    return miniSearch;
+  }
+  static async loadJSAsync(js, options) {
+    const { index, documentIds, fieldLength, storedFields, serializationVersion } = js;
+    const miniSearch = this.instantiateMiniSearch(js, options);
+    miniSearch._documentIds = await objectToNumericMapAsync(documentIds);
+    miniSearch._fieldLength = await objectToNumericMapAsync(fieldLength);
+    miniSearch._storedFields = await objectToNumericMapAsync(storedFields);
+    for (const [shortId, id] of miniSearch._documentIds) {
+      miniSearch._idToShortId.set(id, shortId);
+    }
+    let count = 0;
+    for (const [term, data] of index) {
+      const dataMap = new Map;
+      for (const fieldId of Object.keys(data)) {
+        let indexEntry = data[fieldId];
+        if (serializationVersion === 1) {
+          indexEntry = indexEntry.ds;
+        }
+        dataMap.set(parseInt(fieldId, 10), await objectToNumericMapAsync(indexEntry));
+      }
+      if (++count % 1000 === 0)
+        await wait(0);
+      miniSearch._index.set(term, dataMap);
+    }
+    return miniSearch;
+  }
+  static instantiateMiniSearch(js, options) {
+    const { documentCount, nextId, fieldIds, averageFieldLength, dirtCount, serializationVersion } = js;
+    if (serializationVersion !== 1 && serializationVersion !== 2) {
+      throw new Error("MiniSearch: cannot deserialize an index created with an incompatible version");
+    }
+    const miniSearch = new MiniSearch(options);
+    miniSearch._documentCount = documentCount;
+    miniSearch._nextId = nextId;
+    miniSearch._idToShortId = new Map;
+    miniSearch._fieldIds = fieldIds;
+    miniSearch._avgFieldLength = averageFieldLength;
+    miniSearch._dirtCount = dirtCount || 0;
+    miniSearch._index = new SearchableMap;
+    return miniSearch;
+  }
+  executeQuery(query, searchOptions = {}) {
+    if (query === MiniSearch.wildcard) {
+      return this.executeWildcardQuery(searchOptions);
+    }
+    if (typeof query !== "string") {
+      const options = { ...searchOptions, ...query, queries: undefined };
+      const results = query.queries.map((subquery) => this.executeQuery(subquery, options));
+      return this.combineResults(results, options.combineWith);
+    }
+    const { tokenize, processTerm, searchOptions: globalSearchOptions } = this._options;
+    const options = { tokenize, processTerm, ...globalSearchOptions, ...searchOptions };
+    const { tokenize: searchTokenize, processTerm: searchProcessTerm } = options;
+    const terms = searchTokenize(query).flatMap((term) => searchProcessTerm(term)).filter((term) => !!term);
+    const queries = terms.map(termToQuerySpec(options));
+    const results = queries.map((query) => this.executeQuerySpec(query, options));
+    return this.combineResults(results, options.combineWith);
+  }
+  executeQuerySpec(query, searchOptions) {
+    const options = { ...this._options.searchOptions, ...searchOptions };
+    const boosts = (options.fields || this._options.fields).reduce((boosts, field) => ({ ...boosts, [field]: getOwnProperty(options.boost, field) || 1 }), {});
+    const { boostDocument, weights, maxFuzzy, bm25: bm25params } = options;
+    const { fuzzy: fuzzyWeight, prefix: prefixWeight } = { ...defaultSearchOptions.weights, ...weights };
+    const data = this._index.get(query.term);
+    const results = this.termResults(query.term, query.term, 1, query.termBoost, data, boosts, boostDocument, bm25params);
+    let prefixMatches;
+    let fuzzyMatches;
+    if (query.prefix) {
+      prefixMatches = this._index.atPrefix(query.term);
+    }
+    if (query.fuzzy) {
+      const fuzzy = query.fuzzy === true ? 0.2 : query.fuzzy;
+      const maxDistance = fuzzy < 1 ? Math.min(maxFuzzy, Math.round(query.term.length * fuzzy)) : fuzzy;
+      if (maxDistance)
+        fuzzyMatches = this._index.fuzzyGet(query.term, maxDistance);
+    }
+    if (prefixMatches) {
+      for (const [term, data] of prefixMatches) {
+        const distance = term.length - query.term.length;
+        if (!distance) {
+          continue;
+        }
+        fuzzyMatches === null || fuzzyMatches === undefined || fuzzyMatches.delete(term);
+        const weight = prefixWeight * term.length / (term.length + 0.3 * distance);
+        this.termResults(query.term, term, weight, query.termBoost, data, boosts, boostDocument, bm25params, results);
+      }
+    }
+    if (fuzzyMatches) {
+      for (const term of fuzzyMatches.keys()) {
+        const [data, distance] = fuzzyMatches.get(term);
+        if (!distance) {
+          continue;
+        }
+        const weight = fuzzyWeight * term.length / (term.length + distance);
+        this.termResults(query.term, term, weight, query.termBoost, data, boosts, boostDocument, bm25params, results);
+      }
+    }
+    return results;
+  }
+  executeWildcardQuery(searchOptions) {
+    const results = new Map;
+    const options = { ...this._options.searchOptions, ...searchOptions };
+    for (const [shortId, id] of this._documentIds) {
+      const score = options.boostDocument ? options.boostDocument(id, "", this._storedFields.get(shortId)) : 1;
+      results.set(shortId, {
+        score,
+        terms: [],
+        match: {}
+      });
+    }
+    return results;
+  }
+  combineResults(results, combineWith = OR) {
+    if (results.length === 0) {
+      return new Map;
+    }
+    const operator = combineWith.toLowerCase();
+    const combinator = combinators[operator];
+    if (!combinator) {
+      throw new Error(`Invalid combination operator: ${combineWith}`);
+    }
+    return results.reduce(combinator) || new Map;
+  }
+  toJSON() {
+    const index = [];
+    for (const [term, fieldIndex] of this._index) {
+      const data = {};
+      for (const [fieldId, freqs] of fieldIndex) {
+        data[fieldId] = Object.fromEntries(freqs);
+      }
+      index.push([term, data]);
+    }
+    return {
+      documentCount: this._documentCount,
+      nextId: this._nextId,
+      documentIds: Object.fromEntries(this._documentIds),
+      fieldIds: this._fieldIds,
+      fieldLength: Object.fromEntries(this._fieldLength),
+      averageFieldLength: this._avgFieldLength,
+      storedFields: Object.fromEntries(this._storedFields),
+      dirtCount: this._dirtCount,
+      index,
+      serializationVersion: 2
+    };
+  }
+  termResults(sourceTerm, derivedTerm, termWeight, termBoost, fieldTermData, fieldBoosts, boostDocumentFn, bm25params, results = new Map) {
+    if (fieldTermData == null)
+      return results;
+    for (const field of Object.keys(fieldBoosts)) {
+      const fieldBoost = fieldBoosts[field];
+      const fieldId = this._fieldIds[field];
+      const fieldTermFreqs = fieldTermData.get(fieldId);
+      if (fieldTermFreqs == null)
+        continue;
+      let matchingFields = fieldTermFreqs.size;
+      const avgFieldLength = this._avgFieldLength[fieldId];
+      for (const docId of fieldTermFreqs.keys()) {
+        if (!this._documentIds.has(docId)) {
+          this.removeTerm(fieldId, docId, derivedTerm);
+          matchingFields -= 1;
+          continue;
+        }
+        const docBoost = boostDocumentFn ? boostDocumentFn(this._documentIds.get(docId), derivedTerm, this._storedFields.get(docId)) : 1;
+        if (!docBoost)
+          continue;
+        const termFreq = fieldTermFreqs.get(docId);
+        const fieldLength = this._fieldLength.get(docId)[fieldId];
+        const rawScore = calcBM25Score(termFreq, matchingFields, this._documentCount, fieldLength, avgFieldLength, bm25params);
+        const weightedScore = termWeight * termBoost * fieldBoost * docBoost * rawScore;
+        const result = results.get(docId);
+        if (result) {
+          result.score += weightedScore;
+          assignUniqueTerm(result.terms, sourceTerm);
+          const match = getOwnProperty(result.match, derivedTerm);
+          if (match) {
+            match.push(field);
+          } else {
+            result.match[derivedTerm] = [field];
+          }
+        } else {
+          results.set(docId, {
+            score: weightedScore,
+            terms: [sourceTerm],
+            match: { [derivedTerm]: [field] }
+          });
+        }
+      }
+    }
+    return results;
+  }
+  addTerm(fieldId, documentId, term) {
+    const indexData = this._index.fetch(term, createMap);
+    let fieldIndex = indexData.get(fieldId);
+    if (fieldIndex == null) {
+      fieldIndex = new Map;
+      fieldIndex.set(documentId, 1);
+      indexData.set(fieldId, fieldIndex);
+    } else {
+      const docs = fieldIndex.get(documentId);
+      fieldIndex.set(documentId, (docs || 0) + 1);
+    }
+  }
+  removeTerm(fieldId, documentId, term) {
+    if (!this._index.has(term)) {
+      this.warnDocumentChanged(documentId, fieldId, term);
+      return;
+    }
+    const indexData = this._index.fetch(term, createMap);
+    const fieldIndex = indexData.get(fieldId);
+    if (fieldIndex == null || fieldIndex.get(documentId) == null) {
+      this.warnDocumentChanged(documentId, fieldId, term);
+    } else if (fieldIndex.get(documentId) <= 1) {
+      if (fieldIndex.size <= 1) {
+        indexData.delete(fieldId);
+      } else {
+        fieldIndex.delete(documentId);
+      }
+    } else {
+      fieldIndex.set(documentId, fieldIndex.get(documentId) - 1);
+    }
+    if (this._index.get(term).size === 0) {
+      this._index.delete(term);
+    }
+  }
+  warnDocumentChanged(shortDocumentId, fieldId, term) {
+    for (const fieldName of Object.keys(this._fieldIds)) {
+      if (this._fieldIds[fieldName] === fieldId) {
+        this._options.logger("warn", `MiniSearch: document with ID ${this._documentIds.get(shortDocumentId)} has changed before removal: term "${term}" was not present in field "${fieldName}". Removing a document after it has changed can corrupt the index!`, "version_conflict");
+        return;
+      }
+    }
+  }
+  addDocumentId(documentId) {
+    const shortDocumentId = this._nextId;
+    this._idToShortId.set(documentId, shortDocumentId);
+    this._documentIds.set(shortDocumentId, documentId);
+    this._documentCount += 1;
+    this._nextId += 1;
+    return shortDocumentId;
+  }
+  addFields(fields) {
+    for (let i = 0;i < fields.length; i++) {
+      this._fieldIds[fields[i]] = i;
+    }
+  }
+  addFieldLength(documentId, fieldId, count, length) {
+    let fieldLengths = this._fieldLength.get(documentId);
+    if (fieldLengths == null)
+      this._fieldLength.set(documentId, fieldLengths = []);
+    fieldLengths[fieldId] = length;
+    const averageFieldLength = this._avgFieldLength[fieldId] || 0;
+    const totalFieldLength = averageFieldLength * count + length;
+    this._avgFieldLength[fieldId] = totalFieldLength / (count + 1);
+  }
+  removeFieldLength(documentId, fieldId, count, length) {
+    if (count === 1) {
+      this._avgFieldLength[fieldId] = 0;
+      return;
+    }
+    const totalFieldLength = this._avgFieldLength[fieldId] * count - length;
+    this._avgFieldLength[fieldId] = totalFieldLength / (count - 1);
+  }
+  saveStoredFields(documentId, doc) {
+    const { storeFields, extractField } = this._options;
+    if (storeFields == null || storeFields.length === 0) {
+      return;
+    }
+    let documentFields = this._storedFields.get(documentId);
+    if (documentFields == null)
+      this._storedFields.set(documentId, documentFields = {});
+    for (const fieldName of storeFields) {
+      const fieldValue = extractField(doc, fieldName);
+      if (fieldValue !== undefined)
+        documentFields[fieldName] = fieldValue;
+    }
+  }
+}
+MiniSearch.wildcard = Symbol("*");
+var getOwnProperty = (object, property) => Object.prototype.hasOwnProperty.call(object, property) ? object[property] : undefined;
+var combinators = {
+  [OR]: (a, b) => {
+    for (const docId of b.keys()) {
+      const existing = a.get(docId);
+      if (existing == null) {
+        a.set(docId, b.get(docId));
+      } else {
+        const { score, terms, match } = b.get(docId);
+        existing.score = existing.score + score;
+        existing.match = Object.assign(existing.match, match);
+        assignUniqueTerms(existing.terms, terms);
+      }
+    }
+    return a;
+  },
+  [AND]: (a, b) => {
+    const combined = new Map;
+    for (const docId of b.keys()) {
+      const existing = a.get(docId);
+      if (existing == null)
+        continue;
+      const { score, terms, match } = b.get(docId);
+      assignUniqueTerms(existing.terms, terms);
+      combined.set(docId, {
+        score: existing.score + score,
+        terms: existing.terms,
+        match: Object.assign(existing.match, match)
+      });
+    }
+    return combined;
+  },
+  [AND_NOT]: (a, b) => {
+    for (const docId of b.keys())
+      a.delete(docId);
+    return a;
+  }
+};
+var defaultBM25params = { k: 1.2, b: 0.7, d: 0.5 };
+var calcBM25Score = (termFreq, matchingCount, totalCount, fieldLength, avgFieldLength, bm25params) => {
+  const { k, b, d } = bm25params;
+  const invDocFreq = Math.log(1 + (totalCount - matchingCount + 0.5) / (matchingCount + 0.5));
+  return invDocFreq * (d + termFreq * (k + 1) / (termFreq + k * (1 - b + b * fieldLength / avgFieldLength)));
+};
+var termToQuerySpec = (options) => (term, i, terms) => {
+  const fuzzy = typeof options.fuzzy === "function" ? options.fuzzy(term, i, terms) : options.fuzzy || false;
+  const prefix = typeof options.prefix === "function" ? options.prefix(term, i, terms) : options.prefix === true;
+  const termBoost = typeof options.boostTerm === "function" ? options.boostTerm(term, i, terms) : 1;
+  return { term, fuzzy, prefix, termBoost };
+};
+var defaultOptions = {
+  idField: "id",
+  extractField: (document2, fieldName) => document2[fieldName],
+  tokenize: (text) => text.split(SPACE_OR_PUNCTUATION),
+  processTerm: (term) => term.toLowerCase(),
+  fields: undefined,
+  searchOptions: undefined,
+  storeFields: [],
+  logger: (level, message) => {
+    if (typeof (console === null || console === undefined ? undefined : console[level]) === "function")
+      console[level](message);
+  },
+  autoVacuum: true
+};
+var defaultSearchOptions = {
+  combineWith: OR,
+  prefix: false,
+  fuzzy: false,
+  maxFuzzy: 6,
+  boost: {},
+  weights: { fuzzy: 0.45, prefix: 0.375 },
+  bm25: defaultBM25params
+};
+var defaultAutoSuggestOptions = {
+  combineWith: AND,
+  prefix: (term, i, terms) => i === terms.length - 1
+};
+var defaultVacuumOptions = { batchSize: 1000, batchWait: 10 };
+var defaultVacuumConditions = { minDirtFactor: 0.1, minDirtCount: 20 };
+var defaultAutoVacuumOptions = { ...defaultVacuumOptions, ...defaultVacuumConditions };
+var assignUniqueTerm = (target, term) => {
+  if (!target.includes(term))
+    target.push(term);
+};
+var assignUniqueTerms = (target, source) => {
+  for (const term of source) {
+    if (!target.includes(term))
+      target.push(term);
+  }
+};
+var byScore = ({ score: a }, { score: b }) => b - a;
+var createMap = () => new Map;
+var objectToNumericMap = (object) => {
+  const map = new Map;
+  for (const key of Object.keys(object)) {
+    map.set(parseInt(key, 10), object[key]);
+  }
+  return map;
+};
+var objectToNumericMapAsync = async (object) => {
+  const map = new Map;
+  let count = 0;
+  for (const key of Object.keys(object)) {
+    map.set(parseInt(key, 10), object[key]);
+    if (++count % 1000 === 0) {
+      await wait(0);
+    }
+  }
+  return map;
+};
+var wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var SPACE_OR_PUNCTUATION = /[\n\r\p{Z}\p{P}]+/u;
+
+// src/core/api-spec/search.ts
+var BOOST = { path: 8, summary: 5, description: 2, parameters: 0.5 };
+var MIN_RELATIVE_SCORE = 0.2;
+var TOKEN_SEPARATOR = /[\n\r\p{Z}\p{P}\p{S}]+/u;
+var STOPWORDS = new Set("a an and are at be by do does for from how i in is it its me my of on or our that the this to we what who with you your".split(" "));
+function tokenize(text) {
+  return text.split(TOKEN_SEPARATOR).filter((word) => word && !STOPWORDS.has(word.toLowerCase()));
+}
+function toOperationSummary(op) {
+  return { endpoint: op.endpoint, summary: op.summary };
+}
+function buildSearchIndex(operations) {
+  const index = new MiniSearch({
+    fields: ["path", "summary", "description", "parameters"],
+    tokenize
+  });
+  index.addAll(operations.map((op, id) => ({
+    id,
+    path: op.path.replace(/\{[^}]*\}/g, ""),
+    summary: op.summary,
+    description: op.description,
+    parameters: op.parameterText
+  })));
+  return index;
+}
+function summaryCoverage(query, op) {
+  const terms = tokenize(query.toLowerCase());
+  if (!op || terms.length === 0) {
+    return 0;
+  }
+  const words = tokenize(op.summary.toLowerCase());
+  return terms.filter((term) => words.some((word) => word.startsWith(term))).length / terms.length;
+}
+function searchOperations(operations, query, options = {}) {
+  const index = buildSearchIndex(operations);
+  const hits = index.search(query, {
+    prefix: (term) => term.length >= 3,
+    fuzzy: (term) => term.length >= 4 ? 0.2 : false,
+    boost: BOOST,
+    filter: options.readOnly ? (hit) => operations[hit.id]?.readOnly === true : undefined
+  }).map((hit) => ({
+    ...hit,
+    score: hit.score * (1 + summaryCoverage(query, operations[hit.id]))
+  })).sort((a, b) => b.score - a.score);
+  const baseline = (hits[0]?.score ?? 0) * MIN_RELATIVE_SCORE;
+  return hits.filter((hit) => hit.score >= baseline).slice(0, options.limit ?? 5).flatMap((hit) => {
+    const op = operations[hit.id];
+    return op ? [toOperationSummary(op)] : [];
+  });
+}
+
+// src/core/api-spec/catalog.ts
+var INLINE_AREA_MAX = 2;
+var AREA_SAMPLE_MAX = 3;
+var AREA_OPERATIONS_MAX = 200;
+var byCodePoint = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+function areaOf(path) {
+  const parts = path.split("/").filter(Boolean);
+  const appIdIndex = parts.indexOf("{app_id}");
+  if (appIdIndex !== -1 && appIdIndex + 1 < parts.length) {
+    return parts[appIdIndex + 1] ?? "other";
+  }
+  if (parts[0] === "api" && parts.length > 1) {
+    return parts[1] ?? "other";
+  }
+  return parts[0] ?? "other";
+}
+function groupByArea(operations) {
+  const sorted = [...operations].sort((a, b) => byCodePoint(`${a.method} ${a.path}`, `${b.method} ${b.path}`));
+  const areas = new Map;
+  for (const op of sorted) {
+    const area = areaOf(op.path);
+    areas.set(area, [...areas.get(area) ?? [], op]);
+  }
+  return new Map([...areas].sort(([a], [b]) => byCodePoint(a, b)));
+}
+function readsFirst(ops) {
+  const isRead = (op) => op.method === "GET" ? 0 : 1;
+  return [...ops].sort((a, b) => isRead(a) - isRead(b));
+}
+function catalogIndex(operations) {
+  const areas = [...groupByArea(operations)].map(([area, ops]) => ops.length <= INLINE_AREA_MAX ? { area, operations: ops.map(toOperationSummary) } : {
+    area,
+    operationCount: ops.length,
+    sample: readsFirst(ops).slice(0, AREA_SAMPLE_MAX).map((op) => op.summary)
+  });
+  return { areas, total: operations.length };
+}
+function areaListing(area, operations, max = AREA_OPERATIONS_MAX) {
+  return {
+    area,
+    operations: operations.slice(0, max).map(toOperationSummary),
+    total: operations.length,
+    truncated: operations.length > max
+  };
+}
+// src/core/api-spec/grep.ts
+var CONTEXT_CHARS = 40;
+var MAX_SNIPPETS = 3;
+var MAX_SNIPPET_CHARS = 200;
+function unescapeJson(snippet) {
+  return snippet.replace(/\\[nrt]/g, " ").replace(/\\"/g, '"');
+}
+function snippets(text, pattern) {
+  const found = [];
+  for (const match of text.matchAll(pattern)) {
+    const start = Math.max(0, match.index - CONTEXT_CHARS);
+    const end = match.index + match[0].length + CONTEXT_CHARS;
+    found.push(unescapeJson(text.slice(start, Math.min(end, start + MAX_SNIPPET_CHARS))));
+    if (found.length === MAX_SNIPPETS || match[0].length === 0) {
+      break;
+    }
+  }
+  return found;
+}
+function grepSpec(spec, operations, pattern, options = {}) {
+  const regex = new RegExp(pattern, options.ignoreCase ? "gi" : "g");
+  const hits = [];
+  for (const op of operations) {
+    const { summary, description, parameters, requestBody, responses } = op.operation;
+    const matches = snippets(`${op.endpoint} ${JSON.stringify({ summary, description, parameters, requestBody, responses })}`, regex);
+    if (matches.length > 0) {
+      hits.push({ ...toOperationSummary(op), matches });
+    }
+  }
+  const schemas = options.schemas === false ? {} : spec.components?.schemas;
+  for (const [schema, definition] of Object.entries(schemas ?? {})) {
+    const matches = snippets(JSON.stringify(definition), regex);
+    if (matches.length > 0) {
+      hits.push({ schema, matches });
+    }
+  }
+  return hits.slice(0, options.limit ?? 20);
+}
+// src/core/api-spec/schema.ts
+var HTTP_METHODS = [
+  "get",
+  "put",
+  "post",
+  "delete",
+  "patch",
+  "head",
+  "options",
+  "trace"
+];
+var ParameterSchema = looseObject({
+  name: string2(),
+  in: string2(),
+  required: boolean2().optional(),
+  description: string2().optional(),
+  schema: unknown().optional(),
+  example: unknown().optional()
+});
+var MediaTypesSchema = record(string2(), looseObject({ schema: unknown().optional() }));
+var RequestBodySchema = looseObject({
+  content: MediaTypesSchema.optional()
+});
+var ResponseObjectSchema = looseObject({
+  description: string2().optional(),
+  content: MediaTypesSchema.optional()
+});
+var SecurityRequirementSchema = record(string2(), array(string2()));
+var OperationSchema = looseObject({
+  summary: string2().optional(),
+  description: string2().optional(),
+  operationId: string2().optional(),
+  parameters: array(unknown()).optional(),
+  requestBody: unknown().optional(),
+  responses: record(string2(), unknown()).optional(),
+  security: array(SecurityRequirementSchema).optional()
+});
+var PathItemSchema = looseObject({
+  ...Object.fromEntries(HTTP_METHODS.map((method) => [method, OperationSchema.optional()])),
+  parameters: array(unknown()).optional()
+});
+var OpenApiSpecSchema = looseObject({
+  openapi: string2(),
+  paths: record(string2(), PathItemSchema),
+  components: looseObject({
+    schemas: record(string2(), unknown()).optional()
+  }).optional(),
+  security: array(SecurityRequirementSchema).optional()
+});
+
+// src/core/api-spec/operations.ts
+var PERSONAL_ACCESS_TOKEN_SCHEME = "PersonalAccessTokenAuth";
+var READ_ONLY_SCOPE = "read_only";
+function isReadOnly(operation, spec) {
+  const security = operation.security ?? spec.security ?? [];
+  return security.some((requirement) => requirement[PERSONAL_ACCESS_TOKEN_SCHEME]?.includes(READ_ONLY_SCOPE));
+}
+function parameterText(operation) {
+  return (operation.parameters ?? []).flatMap((parameter) => {
+    const parsed = ParameterSchema.safeParse(parameter);
+    return parsed.success ? [parsed.data.name, parsed.data.description ?? ""] : [];
+  }).join(" ");
+}
+function mergeParameters(shared, own) {
+  if (!shared?.length) {
+    return own;
+  }
+  const key = (parameter) => {
+    const parsed = ParameterSchema.safeParse(parameter);
+    return parsed.success ? `${parsed.data.in}:${parsed.data.name}` : undefined;
+  };
+  const ownKeys = new Set((own ?? []).map(key));
+  return [
+    ...shared.filter((parameter) => !ownKeys.has(key(parameter))),
+    ...own ?? []
+  ];
+}
+function listOperations(spec) {
+  return Object.entries(spec.paths).flatMap(([path, item]) => HTTP_METHODS.flatMap((method) => {
+    const declared = item[method];
+    if (!declared) {
+      return [];
+    }
+    const operation = {
+      ...declared,
+      parameters: mergeParameters(item.parameters, declared.parameters)
+    };
+    return [
+      {
+        endpoint: `${method.toUpperCase()} ${path}`,
+        method: method.toUpperCase(),
+        path,
+        summary: operation.summary ?? "",
+        description: operation.description ?? "",
+        parameterText: parameterText(operation),
+        readOnly: isReadOnly(operation, spec),
+        operation
+      }
+    ];
+  }));
+}
+function pathSegments(path) {
+  const pathname = path.split(/[?#]/, 1)[0] ?? "";
+  return pathname.split("/").filter(Boolean);
+}
+function segmentPattern(segment) {
+  const source = segment.split(/(\{[^}]+\})/).map((part) => part.startsWith("{") ? "[^/]+" : part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("");
+  return new RegExp(`^${source}$`);
+}
+function specificity(templateSegments) {
+  return templateSegments.map((segment) => segment.includes("{") ? 0 : 1);
+}
+function compareSpecificity(a, b) {
+  for (let i = 0;i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      return (b[i] ?? 0) - (a[i] ?? 0);
+    }
+  }
+  return 0;
+}
+function matchOperation(operations, method, concretePath) {
+  const upperMethod = method.toUpperCase();
+  const segments = pathSegments(concretePath);
+  const candidates = operations.filter((op) => {
+    if (op.method !== upperMethod) {
+      return false;
+    }
+    const template = pathSegments(op.path);
+    return template.length === segments.length && template.every((part, i) => segmentPattern(part).test(segments[i] ?? ""));
+  });
+  return candidates.sort((a, b) => compareSpecificity(specificity(pathSegments(a.path)), specificity(pathSegments(b.path))))[0];
+}
+var SCHEMA_REF_PREFIX = "#/components/schemas/";
+var MAX_REF_DEPTH = 4;
+var FRAMEWORK_VALIDATION_ERROR = "Validation Error";
+function inlineRefs(node, schemas, seen = new Set, depth = 0) {
+  if (depth > MAX_REF_DEPTH) {
+    return node;
+  }
+  if (Array.isArray(node)) {
+    return node.map((item) => inlineRefs(item, schemas, seen, depth));
+  }
+  if (node === null || typeof node !== "object") {
+    return node;
+  }
+  const { $ref, ...siblings } = node;
+  if (typeof $ref === "string" && $ref.startsWith(SCHEMA_REF_PREFIX)) {
+    const name = $ref.slice(SCHEMA_REF_PREFIX.length);
+    if (seen.has(name) || !(name in schemas)) {
+      return node;
+    }
+    const resolved = inlineRefs(schemas[name], schemas, new Set([...seen, name]), depth + 1);
+    return resolved !== null && typeof resolved === "object" ? { ...resolved, ...siblings } : resolved;
+  }
+  return Object.fromEntries(Object.entries(node).map(([key, value]) => [
+    key,
+    inlineRefs(value, schemas, seen, depth)
+  ]));
+}
+function jsonSchemaOf(value) {
+  const parsed = RequestBodySchema.safeParse(value);
+  return parsed.success ? parsed.data.content?.["application/json"]?.schema : undefined;
+}
+function requestBodyOf(value) {
+  const parsed = RequestBodySchema.safeParse(value);
+  const content = parsed.success ? parsed.data.content ?? {} : {};
+  const contentType = "application/json" in content ? "application/json" : Object.keys(content)[0];
+  return contentType ? { contentType, schema: content[contentType]?.schema } : {};
+}
+function leftoverRefs(node, schemas, found = new Map) {
+  if (Array.isArray(node)) {
+    for (const item of node) {
+      leftoverRefs(item, schemas, found);
+    }
+  } else if (node !== null && typeof node === "object") {
+    for (const [key, value] of Object.entries(node)) {
+      if (key === "$ref" && typeof value === "string" && value.startsWith(SCHEMA_REF_PREFIX) && !found.has(value)) {
+        const schema = schemas[value.slice(SCHEMA_REF_PREFIX.length)];
+        found.set(value, schema);
+        leftoverRefs(schema, schemas, found);
+      } else {
+        leftoverRefs(value, schemas, found);
+      }
+    }
+  }
+  return found;
+}
+function getOperationContract(spec, op) {
+  const schemas = spec.components?.schemas ?? {};
+  const inline = (node) => node === undefined ? null : inlineRefs(node, schemas);
+  const responses = Object.entries(op.operation.responses ?? {}).flatMap(([status, response]) => {
+    const parsed = ResponseObjectSchema.safeParse(response);
+    return parsed.success ? [[status, parsed.data]] : [];
+  });
+  const success = responses.filter(([status]) => status.startsWith("2")).sort(([a], [b]) => a.localeCompare(b)).map(([, response]) => jsonSchemaOf(response)).find(Boolean);
+  const errors = responses.filter(([status, response]) => !status.startsWith("2") && response.description !== FRAMEWORK_VALIDATION_ERROR);
+  const requestBody = requestBodyOf(op.operation.requestBody);
+  const contract = {
+    endpoint: op.endpoint,
+    method: op.method,
+    path: op.path,
+    summary: op.summary,
+    description: op.description,
+    parameters: (op.operation.parameters ?? []).flatMap((parameter) => {
+      const parsed = ParameterSchema.safeParse(parameter);
+      if (!parsed.success) {
+        return [];
+      }
+      const { name, in: location2, required, schema, description } = parsed.data;
+      const inSchema = schema !== null && typeof schema === "object" && "description" in schema;
+      return [
+        {
+          name,
+          in: location2,
+          required: required ?? false,
+          schema: inline(schema ?? {}),
+          ...description && !inSchema ? { description } : {},
+          ..."example" in parsed.data ? { example: parsed.data.example } : {}
+        }
+      ];
+    }),
+    ...requestBody.contentType && requestBody.contentType !== "application/json" ? { requestBodyContentType: requestBody.contentType } : {},
+    requestBodySchema: inline(requestBody.schema),
+    responseSchema: inline(success),
+    errors: Object.fromEntries(errors.map(([status, response]) => [status, response.description ?? ""]))
+  };
+  const refs = leftoverRefs(contract, schemas);
+  return {
+    ...contract,
+    ...refs.size > 0 ? { refs: Object.fromEntries(refs) } : {}
+  };
+}
+// src/core/api-spec/request.ts
+var MAX_ERROR_BODY_CHARS = 4000;
+async function readBody(response) {
+  try {
+    const text = (await response.clone().text()).trim();
+    return text.length > MAX_ERROR_BODY_CHARS ? `${text.slice(0, MAX_ERROR_BODY_CHARS)}…` : text || undefined;
+  } catch {
+    return;
+  }
+}
+async function sendApiRequest(method, path, body) {
+  try {
+    const response = await base44Client(path.replace(/^\/+/, ""), {
+      method,
+      body,
+      headers: body === undefined ? {} : { "Content-Type": "application/json" },
+      timeout: false
+    });
+    return {
+      status: response.status,
+      contentType: response.headers.get("content-type") ?? "",
+      body: new Uint8Array(await response.arrayBuffer())
+    };
+  } catch (error) {
+    const apiError = await ApiError.fromHttpError(error, `calling ${method} ${path}`);
+    const raw = error instanceof HTTPError ? await readBody(error.response) : undefined;
+    throw new ApiError(apiError.message, {
+      statusCode: apiError.statusCode,
+      requestUrl: apiError.requestUrl,
+      requestMethod: apiError.requestMethod,
+      requestId: apiError.requestId,
+      hints: apiError.hints,
+      details: raw ? [`Response body: ${raw}`] : apiError.details
+    });
+  }
+}
+// src/core/api-spec/spec.ts
+import { rename, stat as stat3 } from "node:fs/promises";
+import { join as join22 } from "node:path";
+var SPEC_CACHE_TTL_MS = 60 * 60 * 1000;
+function getSpecCachePath(apiUrl = getBase44ApiUrl()) {
+  const server = new URL(apiUrl).host.replace(/[^a-zA-Z0-9.-]/g, "_");
+  return join22(getBase44GlobalDir(), "cache", server, "openapi.json");
+}
+function isSpecCacheFresh(mtimeMs, now = Date.now()) {
+  return now - mtimeMs < SPEC_CACHE_TTL_MS;
+}
+function parseSpec(text) {
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch {
+    throw new ApiError("The API spec from the server is not valid JSON");
+  }
+  const result = OpenApiSpecSchema.safeParse(json);
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid API spec", result.error);
+  }
+  return result.data;
+}
+var SPEC_DOWNLOAD_TIMEOUT_MS = 60000;
+async function readFreshCache(path) {
+  try {
+    const { mtimeMs } = await stat3(path);
+    if (!isSpecCacheFresh(mtimeMs)) {
+      return null;
+    }
+    const text = await readTextFile(path);
+    return { text, spec: parseSpec(text) };
+  } catch {
+    return null;
+  }
+}
+async function downloadSpec() {
+  try {
+    const response = await base44Client.get("api/openapi.json", {
+      timeout: SPEC_DOWNLOAD_TIMEOUT_MS
+    });
+    return await response.text();
+  } catch (error) {
+    throw await ApiError.fromHttpError(error, "fetching the API spec");
+  }
+}
+async function loadSpec(options = {}) {
+  const path = getSpecCachePath();
+  const cached = options.refresh ? null : await readFreshCache(path);
+  if (cached !== null) {
+    return cached;
+  }
+  const text = await downloadSpec();
+  const spec = parseSpec(text);
+  const partial = `${path}.${process.pid}.tmp`;
+  await writeFile(partial, text);
+  await rename(partial, path);
+  return { text, spec };
+}
+// src/cli/commands/api/shared.ts
+import { fstatSync } from "node:fs";
+function formatJson(value) {
+  return toJsonStdout(value, { compact: !process.stdout.isTTY });
+}
+function parseLimit(value) {
+  if (value === undefined) {
+    return;
+  }
+  const n = Number.parseInt(value, 10);
+  if (!Number.isInteger(n) || n < 1) {
+    throw new InvalidInputError("--limit must be a positive integer.");
+  }
+  return n;
+}
+var READ_ONLY_FILTER_HELP = "Only read-only operations";
+var REFRESH_OPTION_HELP = "Fetch the API spec again instead of using the cached copy (kept 1 hour)";
+function loadSpecTask({ runTask }, refresh) {
+  return runTask("Loading the API spec", () => loadSpec({ refresh }), {
+    successMessage: "Loaded the API spec"
+  });
+}
+function operationsInArea(operations, area) {
+  const areas = groupByArea(operations);
+  const inArea = areas.get(area);
+  if (!inArea) {
+    throw new InvalidInputError(`Unknown API area: ${area}`, {
+      details: [`Areas: ${[...areas.keys()].join(", ")}`],
+      hints: [{ message: "List the areas", command: "base44 api catalog" }]
+    });
+  }
+  return inArea;
+}
+function isPipedStdin() {
+  try {
+    const stats = fstatSync(0);
+    return stats.isFIFO() || stats.isFile();
+  } catch {
+    return false;
+  }
+}
+async function readRequestBody(method, flag) {
+  if (flag === "@-") {
+    return readStdin("--body @-", { trim: false });
+  }
+  if (flag?.startsWith("@")) {
+    return readTextFile(flag.slice(1));
+  }
+  if (flag !== undefined) {
+    return flag;
+  }
+  if (method === "GET" || method === "HEAD" || !isPipedStdin()) {
+    return;
+  }
+  const piped = await readStdin("--body", { trim: false });
+  return piped.trim() ? piped : undefined;
+}
+
+// src/cli/commands/api/catalog.ts
+async function catalogAction(ctx, area, options) {
+  const { spec } = await loadSpecTask(ctx, options.refresh);
+  const operations = listOperations(spec);
+  const readOnly = (ops) => options.readOnly ? ops.filter((op) => op.readOnly) : ops;
+  if (area === undefined) {
+    return { stdout: formatJson(catalogIndex(readOnly(operations))) };
+  }
+  const inArea = readOnly(operationsInArea(operations, area));
+  return { stdout: formatJson(areaListing(area, inArea)) };
+}
+function getApiCatalogCommand() {
+  return new Base44Command("catalog", {
+    requireAuth: false,
+    requireAppContext: false
+  }).description("List the API's areas, or every operation in one area").argument("[area]", 'An area from the list, e.g. "workflows"').option("--read-only", READ_ONLY_FILTER_HELP).option("--refresh", REFRESH_OPTION_HELP).action(catalogAction);
+}
+
+// src/cli/commands/api/fetch.ts
+async function findOperation(ctx, method, path, refresh) {
+  const { spec } = await loadSpecTask(ctx, refresh);
+  const op = matchOperation(listOperations(spec), method, path);
+  if (!op) {
+    throw new InvalidInputError(`No operation in the API spec matches ${method} ${path}.`, {
+      hints: [
+        {
+          message: "The cached spec may predate this route; fetch it again",
+          command: "base44 api fetch <METHOD> <path> --help --refresh"
+        },
+        {
+          message: "Find the operation and its path template",
+          command: 'base44 api search "<what you want to do>"'
+        }
+      ]
+    });
+  }
+  return { spec, op };
+}
+var TEXT_CONTENT_TYPES = [
+  "json",
+  "text/",
+  "xml",
+  "javascript",
+  "x-www-form-urlencoded"
+];
+function isText(contentType) {
+  return !contentType || TEXT_CONTENT_TYPES.some((hint) => contentType.toLowerCase().includes(hint));
+}
+async function formatResponse({ status, contentType, body }, output, jsonMode) {
+  if (output !== undefined) {
+    await writeFile(output, body);
+    return formatJson({ status, contentType, bytes: body.length, output });
+  }
+  if (body.length === 0) {
+    return formatJson({ status });
+  }
+  if (!isText(contentType)) {
+    return formatJson({
+      status,
+      contentType,
+      bytes: body.length,
+      note: "Binary body not printed; add --output <file> to save it."
+    });
+  }
+  const text = new TextDecoder().decode(body);
+  try {
+    return formatJson(JSON.parse(text));
+  } catch {
+    if (jsonMode) {
+      return formatJson({ status, contentType, body: text });
+    }
+    return text.endsWith(`
+`) ? text : `${text}
+`;
+  }
+}
+async function fetchAction(ctx, methodArg, path, options, command) {
+  if (!methodArg || !path) {
+    if (options.help) {
+      const usage = command.helpInformation();
+      return { stdout: ctx.jsonMode ? formatJson({ usage }) : usage };
+    }
+    throw new InvalidInputError("Provide a method and a path, e.g. GET /api/apps.");
+  }
+  const method = methodArg.toUpperCase();
+  if (options.help) {
+    const { spec, op } = await findOperation(ctx, method, path, options.refresh);
+    return { stdout: formatJson(getOperationContract(spec, op)) };
+  }
+  if (options.readOnly) {
+    const { op } = await findOperation(ctx, method, path, options.refresh);
+    if (!op.readOnly) {
+      throw new InvalidInputError(`Refused under --read-only: ${op.method} ${op.path} is not a read-only operation. Nothing was sent.`);
+    }
+  }
+  ctx.errorReporter.setContext({
+    command: {
+      name: "api fetch",
+      args: [method, path.split("?", 1)[0] ?? ""],
+      options: { ...options, body: options.body && "[not reported]" }
+    }
+  });
+  await ensureAuth(ctx);
+  const body = await readRequestBody(method, options.body);
+  const response = await ctx.runTask(`Calling ${method} ${path}`, () => sendApiRequest(method, path, body), {
+    successMessage: `Called ${method} ${path}`,
+    errorMessage: "Request failed"
+  });
+  return {
+    stdout: await formatResponse(response, options.output, ctx.jsonMode)
+  };
+}
+function getApiFetchCommand() {
+  return new Base44Command("fetch", {
+    requireAuth: false,
+    requireAppContext: false
+  }).description("Call a Base44 API operation, like curl; add --help after a path for its contract").helpOption(false).argument("[method]", "HTTP method, e.g. GET or POST").argument("[path]", 'Concrete path with any query string, e.g. "/api/apps/<app-id>/workflows/runs?status=failed"').option("--body <json>", "Request body: JSON, @file.json, or @- for stdin (piped stdin is read too)").option("--output <file>", "Save the response body to a file").option("--read-only", "Refuse, before sending, any operation the spec does not mark read-only").option("--refresh", REFRESH_OPTION_HELP).option("-h, --help", "With a method and path, print that operation's contract; otherwise this help").action(fetchAction);
+}
+
+// src/cli/commands/api/grep.ts
+function assertValidRegex(pattern) {
+  try {
+    new RegExp(pattern);
+  } catch (error) {
+    throw new InvalidInputError(`Invalid regular expression: ${error instanceof Error ? error.message : pattern}`);
+  }
+}
+async function grepAction(ctx, pattern, options) {
+  const limit = parseLimit(options.limit);
+  assertValidRegex(pattern);
+  const { spec } = await loadSpecTask(ctx, options.refresh);
+  let operations = listOperations(spec);
+  if (options.area !== undefined) {
+    operations = operationsInArea(operations, options.area);
+  }
+  if (options.readOnly) {
+    operations = operations.filter((op) => op.readOnly);
+  }
+  const narrowed = options.area !== undefined || options.readOnly === true;
+  const hits = grepSpec(spec, operations, pattern, {
+    ignoreCase: options.ignoreCase,
+    limit,
+    schemas: !narrowed
+  });
+  return { stdout: formatJson(hits) };
+}
+function getApiGrepCommand() {
+  return new Base44Command("grep", {
+    requireAuth: false,
+    requireAppContext: false
+  }).description("Search the raw API spec with a regular expression, for when search misses").argument("<pattern>", 'Regular expression, e.g. "runs.*status"').option("--area <area>", "Search only one area's operations (see base44 api catalog)").option("-i, --ignore-case", "Case-insensitive match").option("--limit <n>", "Most operations or schemas to return (default 20)").option("--read-only", READ_ONLY_FILTER_HELP).option("--refresh", REFRESH_OPTION_HELP).action(grepAction);
+}
+
+// src/cli/commands/api/search.ts
+async function searchAction(ctx, words, options) {
+  const limit = parseLimit(options.limit);
+  const { spec } = await loadSpecTask(ctx, options.refresh);
+  const results = searchOperations(listOperations(spec), words.join(" "), {
+    limit,
+    readOnly: options.readOnly
+  });
+  return { stdout: formatJson(results) };
+}
+function getApiSearchCommand() {
+  return new Base44Command("search", {
+    requireAuth: false,
+    requireAppContext: false
+  }).description("Search every Base44 API operation by what it does").argument("<text...>", 'What you are looking for, e.g. "failed workflow runs"').option("--limit <n>", "Most results to return (default 5)").option("--read-only", READ_ONLY_FILTER_HELP).option("--refresh", REFRESH_OPTION_HELP).action(searchAction);
+}
+
+// src/cli/commands/api/index.ts
+function getApiCommand() {
+  return new Command2("api").description("Search and call any public Base44 API operation").addCommand(getApiCatalogCommand()).addCommand(getApiSearchCommand()).addCommand(getApiGrepCommand()).addCommand(getApiFetchCommand());
+}
+
 // src/cli/commands/auth/password-login.ts
-import { dirname as dirname16, join as join22 } from "node:path";
+import { dirname as dirname16, join as join23 } from "node:path";
 async function passwordLoginAction({ log, runTask }, action) {
   const shouldEnable = action === "enable";
   const { project } = await readProjectConfig();
   const configDir = dirname16(project.configPath);
-  const authDir = join22(configDir, project.authDir);
+  const authDir = join23(configDir, project.authDir);
   const updated = await runTask("Updating local auth config", async () => {
     const current = await readAuthConfig(authDir) ?? DEFAULT_AUTH_CONFIG;
     const merged = { ...current, enableUsernamePassword: shouldEnable };
@@ -248067,14 +249822,14 @@ function getPasswordLoginCommand() {
 }
 
 // src/cli/commands/auth/pull.ts
-import { dirname as dirname17, join as join23 } from "node:path";
+import { dirname as dirname17, join as join24 } from "node:path";
 async function pullAuthAction({
   log,
   runTask
 }) {
   const { project } = await readProjectConfig();
   const configDir = dirname17(project.configPath);
-  const authDir = join23(configDir, project.authDir);
+  const authDir = join24(configDir, project.authDir);
   const remoteConfig = await runTask("Fetching auth config from Base44", async () => {
     return await pullAuthConfig();
   }, {
@@ -248138,7 +249893,7 @@ function getAuthPushCommand() {
 }
 
 // src/cli/commands/auth/social-login.ts
-import { dirname as dirname18, join as join24, resolve as resolve7 } from "node:path";
+import { dirname as dirname18, join as join25, resolve as resolve7 } from "node:path";
 var PROVIDER_LABELS = {
   google: "Google",
   microsoft: "Microsoft",
@@ -248209,7 +249964,7 @@ async function socialLoginAction({ log, isNonInteractive, runTask }, provider, a
   }
   const { project } = await readProjectConfig();
   const configDir = dirname18(project.configPath);
-  const authDir = join24(configDir, project.authDir);
+  const authDir = join25(configDir, project.authDir);
   const { config: updated } = await runTask("Updating local auth config", async () => updateSocialLoginConfig(authDir, provider, shouldEnable, useCustomOAuth && options.clientId ? { clientId: options.clientId } : undefined));
   if (clientSecret) {
     await runTask("Saving client secret", async () => pushCustomOAuthSecret(provider, clientSecret));
@@ -248234,7 +249989,7 @@ function getSocialLoginCommand() {
 }
 
 // src/cli/commands/auth/sso.ts
-import { dirname as dirname19, join as join25, resolve as resolve8 } from "node:path";
+import { dirname as dirname19, join as join26, resolve as resolve8 } from "node:path";
 var SSOConfigFileSchema = object({
   provider: _enum(Object.values(KNOWN_SSO_PROVIDERS)),
   clientId: string2(),
@@ -248398,7 +250153,7 @@ async function ssoEnableAction({ isNonInteractive, runTask }, options) {
   }
   const { project } = await readProjectConfig();
   const configDir = dirname19(project.configPath);
-  const authDir = join25(configDir, project.authDir);
+  const authDir = join26(configDir, project.authDir);
   await runTask("Updating local auth config", async () => updateSSOConfig(authDir, provider, true));
   await runTask("Saving SSO credentials", async () => pushSSOSecrets(secrets));
   return {
@@ -248414,7 +250169,7 @@ async function ssoDisableAction({ log, runTask }, options) {
   }
   const { project } = await readProjectConfig();
   const configDir = dirname19(project.configPath);
-  const authDir = join25(configDir, project.authDir);
+  const authDir = join26(configDir, project.authDir);
   const updated = await runTask("Updating local auth config", async () => updateSSOConfig(authDir, null, false));
   await runTask("Removing SSO credentials", async () => deleteSSOSecrets());
   if (!hasAnyLoginMethod(updated)) {
@@ -249296,13 +251051,13 @@ function getConnectorsListAvailableCommand() {
 }
 
 // src/cli/commands/connectors/pull.ts
-import { dirname as dirname20, join as join26, resolve as resolve9 } from "node:path";
+import { dirname as dirname20, join as join27, resolve as resolve9 } from "node:path";
 async function resolveConnectorsDir(options) {
   if (!getAppContext().projectRoot) {
     return resolve9(options.dir ?? "connectors");
   }
   const { project } = await readProjectConfig();
-  return join26(dirname20(project.configPath), project.connectorsDir);
+  return join27(dirname20(project.configPath), project.connectorsDir);
 }
 async function pullConnectorsAction({ log, runTask, jsonMode }, options) {
   const connectorsDir = await resolveConnectorsDir(options);
@@ -249689,11 +251444,11 @@ function getListCommand() {
 }
 
 // src/cli/commands/functions/pull.ts
-import { dirname as dirname21, join as join27 } from "node:path";
+import { dirname as dirname21, join as join28 } from "node:path";
 async function pullFunctionsAction({ log, runTask }, name) {
   const { project, functions } = await readProjectConfig();
   const configDir = dirname21(project.configPath);
-  const functionsDir = join27(configDir, project.functionsDir);
+  const functionsDir = join28(configDir, project.functionsDir);
   const pluginFunctionNames = new Set(functions.filter((fn) => fn.source.type === "plugin").map((fn) => fn.name));
   const remoteFunctions = await runTask("Fetching functions from Base44", async () => {
     const { functions } = await listDeployedFunctions();
@@ -249807,7 +251562,7 @@ import { basename as basename6, resolve as resolve11 } from "node:path";
 var import_kebabCase = __toESM(require_kebabCase(), 1);
 
 // src/cli/commands/project/scaffold-shared.ts
-import { join as join28 } from "node:path";
+import { join as join29 } from "node:path";
 var DEFAULT_TEMPLATE_ID = "backend-only";
 async function getTemplateById(templateId) {
   const templates = await listTemplates();
@@ -249870,7 +251625,7 @@ async function completeProjectSetup({
           env: { VITE_BASE44_APP_ID: projectId }
         })`${buildCommand}`;
         updateMessage("Deploying site...");
-        return await deploySite(join28(resolvedPath, outputDirectory));
+        return await deploySite(join29(resolvedPath, outputDirectory));
       }, {
         successMessage: theme.colors.base44Orange("Site deployed successfully"),
         errorMessage: "Failed to deploy site"
@@ -250886,7 +252641,7 @@ async function setEnvironmentVersion(environment, versionId, options = {}) {
 }
 // src/core/version/artifacts.ts
 import { createHash as createHash3 } from "node:crypto";
-import { join as join29, resolve as resolve13 } from "node:path";
+import { join as join30, resolve as resolve13 } from "node:path";
 
 // src/core/version/functions.ts
 import { createHash as createHash2 } from "node:crypto";
@@ -253161,10 +254916,6 @@ var STATIC_EGRESS_ENABLED_ENV = "BASE44_STATIC_EGRESS_ENABLED";
 var STATIC_EGRESS_DIAGNOSTIC_LIMIT = 5;
 var staticEgressFetchInstalled = false;
 var staticEgressDiagnosticCount = 0;
-var dedicatedEgressResponses = /* @__PURE__ */ new WeakSet();
-function isDedicatedEgressResponse(response) {
-  return dedicatedEgressResponses.has(response);
-}
 function inputKind(input) {
   if (typeof input === "string") return "string";
   return input instanceof URL ? "url" : "request";
@@ -253266,10 +255017,7 @@ function createRequestScopedStaticEgressFetch(originalFetch, readEnvironment) {
       return originalFetch(input, init);
     }
     logStaticEgressDecision("dedicated", input, binding, enableSecret);
-    return binding.fetch(input, init).then((response) => {
-      dedicatedEgressResponses.add(response);
-      return response;
-    });
+    return binding.fetch(input, init);
   };
 }
 function installStaticEgressFetch() {
@@ -253281,128 +255029,6 @@ function installStaticEgressFetch() {
   staticEgressFetchInstalled = true;
 }
 
-// src/edge-errors.ts
-var EDGE_ERRORS_HEADER = "X-B44-Edge-Errors";
-var MAX_EDGE_ERRORS = 5;
-var MAX_INSPECTED_BODY_BYTES = 8192;
-var BODY_READ_TIMEOUT_MS = 500;
-var PLAIN_TEXT_EDGE_ERROR = /^error code: (\\d{3,4})\\s*$/;
-var UNBRANDED_5XX_PAGE = /<center>cloudflare<\\/center>/i;
-var SAFE_VALUE = /^[\\x20-\\x7e]{1,253}$/;
-function safe(value) {
-  return typeof value === "string" && SAFE_VALUE.test(value) ? value : void 0;
-}
-function parseEdgeErrorBody(body, status) {
-  const plain = PLAIN_TEXT_EDGE_ERROR.exec(body);
-  if (plain) return { code: Number(plain[1]) };
-  if (status >= 500 && UNBRANDED_5XX_PAGE.test(body)) return { code: status };
-  try {
-    const json = JSON.parse(body);
-    if (json === null || typeof json !== "object") return null;
-    const fields = json;
-    if (fields.cloudflare_error !== true || !Number.isInteger(fields.error_code)) return null;
-    return {
-      code: fields.error_code,
-      name: safe(fields.error_name),
-      category: safe(fields.error_category),
-      zone: safe(fields.zone)
-    };
-  } catch {
-    return null;
-  }
-}
-async function readBodyPrefix(response) {
-  if (Number(response.headers.get("content-length")) > MAX_INSPECTED_BODY_BYTES) return null;
-  const reader = response.clone().body?.getReader();
-  if (!reader) return "";
-  const timer = setTimeout(() => reader.cancel().catch(() => {
-  }), BODY_READ_TIMEOUT_MS);
-  const decoder = new TextDecoder();
-  let text = "";
-  let size = 0;
-  try {
-    for (; ; ) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      size += value.byteLength;
-      if (size > MAX_INSPECTED_BODY_BYTES) return null;
-      text += decoder.decode(value, { stream: true });
-    }
-  } catch {
-    return null;
-  } finally {
-    clearTimeout(timer);
-    reader.cancel().catch(() => {
-    });
-  }
-  return text + decoder.decode();
-}
-async function readEdgeError(response) {
-  if (response.status < 400 || !response.headers.get("cf-ray")) return null;
-  if (response.headers.get("cf-mitigated") === "challenge") {
-    return { code: response.status, name: "challenge" };
-  }
-  const body = await readBodyPrefix(response);
-  return body === null ? null : parseEdgeErrorBody(body, response.status);
-}
-function targetOrigin(input) {
-  try {
-    const raw = input instanceof URL ? input.href : typeof input === "string" ? input : input.url;
-    return new URL(raw).origin;
-  } catch {
-    return null;
-  }
-}
-async function recordEdgeError(input, response, startedAt) {
-  const store = currentWorkerRuntimeContext();
-  if (!store) return;
-  const body = await readEdgeError(response);
-  const target = targetOrigin(input);
-  if (!body || !target) return;
-  const record = store.edgeErrors ??= { errors: [], dropped: 0 };
-  if (record.errors.length >= MAX_EDGE_ERRORS) {
-    record.dropped += 1;
-    return;
-  }
-  record.errors.push({
-    ...body,
-    target,
-    status: response.status,
-    ray: safe(response.headers.get("cf-ray")) ?? "",
-    egress: isDedicatedEgressResponse(response) ? "dedicated" : "shared",
-    elapsed_ms: Date.now() - startedAt
-  });
-}
-function createEdgeErrorFetch(innerFetch) {
-  return async (input, init) => {
-    const startedAt = Date.now();
-    const response = await innerFetch(input, init);
-    try {
-      await recordEdgeError(input, response, startedAt);
-    } catch {
-    }
-    return response;
-  };
-}
-var edgeErrorFetchInstalled = false;
-function installEdgeErrorFetch() {
-  if (edgeErrorFetchInstalled) return;
-  globalThis.fetch = createEdgeErrorFetch(globalThis.fetch.bind(globalThis));
-  edgeErrorFetchInstalled = true;
-}
-function attachEdgeErrors(response) {
-  const record = currentWorkerRuntimeContext()?.edgeErrors;
-  if (!record || !(response instanceof Response)) return response;
-  if (response.status === 101 || response.webSocket) return response;
-  try {
-    const wrapped = new Response(response.body, response);
-    wrapped.headers.set(EDGE_ERRORS_HEADER, JSON.stringify(record));
-    return wrapped;
-  } catch {
-    return response;
-  }
-}
-
 // src/static-egress-tcp-core.mjs
 function normalizeHost(host) {
   return host.toLowerCase().replace(/^\\[(.*)\\]$/, "$1").replace(/\\.$/, "");
@@ -253531,6 +255157,12 @@ var deno2 = Object.freeze({
 });
 globalThis.Deno = deno2;
 globalThis.Buffer = Buffer2;
+try {
+  new AsyncLocalStorage().enterWith(void 0);
+} catch {
+  AsyncLocalStorage.prototype.enterWith = () => {
+  };
+}
 function getRegisteredHandler() {
   return registeredHandler;
 }
@@ -253556,9 +255188,7 @@ function resolveHandler(functionName) {
   return handler;
 }
 export {
-  attachEdgeErrors,
   getRegisteredHandler,
-  installEdgeErrorFetch,
   installStaticEgressFetch,
   registerLazy,
   resolveHandler
@@ -256498,7 +258128,7 @@ var TELEMETRY_PATCH = [
 var TELEMETRY_STORE_FIELDS = "reqId: crypto.randomUUID(), respondedAt: null, inflight: new Map(), inflightTotal: 0, hadRejection: false, hadNonOk: false, logBudget: 5";
 
 // ../functions-compiler/src/version.ts
-var COMPILER_VERSION = "0.1.7";
+var COMPILER_VERSION = "0.1.8";
 
 // ../functions-compiler/src/worker-entry.ts
 function denoShimSource() {
@@ -256603,22 +258233,20 @@ registerLazy(${JSON.stringify(functionName)}, () => import(${JSON.stringify(user
 function buildAppEntrySource(functionModules, telemetry, runtimeSecrets = false) {
   const moduleImports = functionModules.map((file) => `import "./${file}";`).join(`
 `);
-  const handlerExpr = `_b44AttachInvocationLogs(_b44AttachEdgeErrors(${telemetry ? "_b44AttachTelemetry(await handler(request, info))" : "await handler(request, info)"}))`;
+  const handlerExpr = `_b44AttachInvocationLogs(${telemetry ? "_b44AttachTelemetry(await handler(request, info))" : "await handler(request, info)"})`;
   const guard = activationGuard(runtimeSecrets);
   const returnExpr = guard(handlerExpr);
   return `// Auto-generated by the base44 bundler. Do not edit.
 
 import { currentWorkerRuntimeContext as _b44Context, runWithWorkerEnvironment as _b44Run } from ${JSON.stringify(RUNTIME_CONTEXT_SPECIFIER)};
-import { attachEdgeErrors as _b44AttachEdgeErrors, installEdgeErrorFetch, installStaticEgressFetch, resolveHandler } from "./${SHIM_FILENAME}";${activationImport(runtimeSecrets)}
+import { installStaticEgressFetch, resolveHandler } from "./${SHIM_FILENAME}";${activationImport(runtimeSecrets)}
 ${moduleImports}
 
 ${consolePatch(runtimeSecrets)}
 ${INVOCATION_LOGS_PATCH}
-// Static egress reads workerEnv from the active request store. Install it and
-// the edge-error recorder before telemetry so telemetry remains the outermost
-// fetch wrapper.
+// Static egress reads workerEnv from the active request store. Install it
+// before telemetry so telemetry remains the outermost fetch wrapper.
 installStaticEgressFetch();
-installEdgeErrorFetch();
 ${telemetry ? TELEMETRY_PATCH : ""}
 
 export default {
@@ -261124,6 +262752,174 @@ function runtimeVirtualPlugin() {
   };
 }
 
+// ../functions-compiler/src/esbuild/ws-native-virtual.ts
+var NAMESPACE4 = "base44-ws-native";
+var WS_SPECIFIER = /^(npm:)?ws(@[^/]+)?$/;
+var ADAPTER = `"use strict";
+const toBuffer = (value) => (globalThis.Buffer ? globalThis.Buffer.from(value) : value);
+const READY_STATES = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
+const later = (fn, ...args) => queueMicrotask(() => fn(...args));
+const upgradeHeaders = (options) => {
+  const headers = new Headers(options?.headers);
+  for (const name of headers.keys()) if (name !== "user-agent") return headers;
+  return null;
+};
+class WebSocket {
+  static CONNECTING = 0;
+  static OPEN = 1;
+  static CLOSING = 2;
+  static CLOSED = 3;
+  #socket = null;
+  #state = 0;
+  #url;
+  #closeRequested = null;
+  #terminated = false;
+  #listeners = new Map();
+  constructor(address, protocols, options) {
+    if (protocols && typeof protocols === "object" && !Array.isArray(protocols)) {
+      options = protocols;
+      protocols = undefined;
+    }
+    this.#url = String(address);
+    const headers = upgradeHeaders(options);
+    if (headers) {
+      this.#upgrade(headers, protocols);
+    } else {
+      this.#attach(new globalThis.WebSocket(this.#url, protocols));
+    }
+  }
+  get readyState() {
+    if (this.#terminated) return 3;
+    return this.#socket ? this.#socket.readyState : this.#state;
+  }
+  get url() { return this.#url; }
+  get protocol() { return this.#socket ? this.#socket.protocol ?? "" : ""; }
+  on(name, listener) { return this.#add(name, listener, false); }
+  addListener(name, listener) { return this.#add(name, listener, false); }
+  once(name, listener) { return this.#add(name, listener, true); }
+  off(name, listener) { return this.removeListener(name, listener); }
+  removeListener(name, listener) {
+    const listeners = this.#listeners.get(name);
+    if (listeners) this.#listeners.set(name, listeners.filter((entry) => entry.listener !== listener));
+    return this;
+  }
+  removeAllListeners(name) {
+    if (name === undefined) this.#listeners.clear();
+    else this.#listeners.delete(name);
+    return this;
+  }
+  emit(name, ...args) {
+    const listeners = this.#listeners.get(name) ?? [];
+    this.#listeners.set(name, listeners.filter((entry) => !entry.once));
+    for (const entry of listeners) entry.listener.apply(this, args);
+    return listeners.length > 0;
+  }
+  send(data, options, callback) {
+    const done = typeof options === "function" ? options : callback;
+    try {
+      if (!this.#socket) {
+        throw new Error("WebSocket is not open: readyState " + this.#state + " (" + READY_STATES[this.#state] + ")");
+      }
+      this.#socket.send(data);
+      done?.();
+    } catch (error) {
+      if (!done) throw error;
+      done(error);
+    }
+  }
+  close(code, reason) {
+    if (this.#socket) this.#socket.close(code, reason);
+    else if (this.#state === 0) {
+      // Upgrade still in flight: close as soon as it lands.
+      this.#closeRequested = [code, reason];
+      this.#state = 2;
+    }
+  }
+  // \`ws\` tears the connection down at once. workerd has no abrupt close, so the
+  // socket is closed normally and "close" is reported now, not on the reply.
+  terminate() {
+    if (this.#terminated || this.readyState === 3) return;
+    this.#terminated = true;
+    if (this.#socket) {
+      try { this.#socket.close(); } catch {}
+    } else {
+      // Upgrade still in flight: close it on arrival, without an "open".
+      this.#closeRequested = [];
+      this.#state = 3;
+    }
+    later(() => this.emit("close", 1006, toBuffer("")));
+  }
+  #attach(socket) {
+    this.#socket = socket;
+    try { socket.binaryType = "arraybuffer"; } catch {}
+    socket.addEventListener("open", () => this.emit("open"));
+    socket.addEventListener("message", (event) => {
+      const isBinary = typeof event.data !== "string";
+      this.emit("message", toBuffer(isBinary ? new Uint8Array(event.data) : event.data), isBinary);
+    });
+    socket.addEventListener("error", (event) => this.emit("error", event.error ?? new Error(event.message || "WebSocket error")));
+    socket.addEventListener("close", (event) => {
+      if (!this.#terminated) this.emit("close", event.code, toBuffer(event.reason ?? ""));
+    });
+  }
+  #upgrade(headers, protocols) {
+    headers.set("Upgrade", "websocket");
+    if (protocols) headers.set("Sec-WebSocket-Protocol", [].concat(protocols).join(", "));
+    const httpUrl = this.#url.replace(/^ws(s?):/i, "http$1:");
+    const fail = (error) => {
+      this.#state = 3;
+      if (this.#terminated) return;
+      this.emit("error", error);
+      this.emit("close", 1006, toBuffer(""));
+    };
+    // Two-argument then(): an exception from an "open" listener must not be
+    // reported as a failed upgrade.
+    fetch(httpUrl, { headers }).then((response) => {
+      const socket = response.webSocket;
+      if (!socket) {
+        response.body?.cancel();
+        return fail(new Error("Unexpected server response: " + response.status));
+      }
+      socket.accept();
+      this.#attach(socket);
+      if (this.#closeRequested) return socket.close(...this.#closeRequested);
+      // accept() opens the socket without dispatching an "open" event.
+      this.emit("open");
+    }, fail);
+  }
+  #add(name, listener, once) {
+    const listeners = this.#listeners.get(name) ?? [];
+    listeners.push({ listener, once });
+    this.#listeners.set(name, listeners);
+    return this;
+  }
+}
+class WebSocketServer {
+  constructor() {
+    throw new Error("ws WebSocketServer is not available in Base44 functions: a function can open WebSocket connections but cannot listen for them.");
+  }
+}
+module.exports = WebSocket;
+module.exports.WebSocket = WebSocket;
+module.exports.WebSocketServer = WebSocketServer;
+module.exports.default = WebSocket;
+`;
+function wsNativeVirtualPlugin() {
+  return {
+    name: "base44-ws-native",
+    setup(build) {
+      build.onResolve({ filter: WS_SPECIFIER }, () => ({
+        path: "ws",
+        namespace: NAMESPACE4
+      }));
+      build.onLoad({ filter: /.*/, namespace: NAMESPACE4 }, () => ({
+        contents: ADAPTER,
+        loader: "js"
+      }));
+    }
+  };
+}
+
 // ../functions-compiler/src/deno-bundle.ts
 async function bundleToModule(prepared, nodeModulesDir = "none") {
   const dir = await mkdtemp(path21.join(tmpdir2(), "b44-bundle-"));
@@ -261147,6 +262943,7 @@ async function bundleToModule(prepared, nodeModulesDir = "none") {
         sourcemap: false,
         logLevel: "silent",
         plugins: [
+          wsNativeVirtualPlugin(),
           nodeBuiltinRequirePlugin(),
           userFilesPlugin(prepared.files, prepared.entry),
           privateDataSourcesVirtualPlugin(),
@@ -261771,14 +263568,14 @@ async function readRawResources(dir) {
   const payloads = {};
   for (const relativePath of files.sort()) {
     const name = relativePath.replace(/\.jsonc?$/, "");
-    payloads[name] = await readJsonFile(join29(dir, ...relativePath.split("/")));
+    payloads[name] = await readJsonFile(join30(dir, ...relativePath.split("/")));
   }
   return payloads;
 }
 async function collectResources(configDir, dirs) {
   const [entities, agents] = await Promise.all([
-    readRawResources(join29(configDir, dirs.entitiesDir)),
-    readRawResources(join29(configDir, dirs.agentsDir))
+    readRawResources(join30(configDir, dirs.entitiesDir)),
+    readRawResources(join30(configDir, dirs.agentsDir))
   ]);
   return { entities, agents };
 }
@@ -261790,7 +263587,7 @@ async function collectArtifacts(target) {
       entryFile: ENTRY2
     }),
     ...siteWorker ? { siteWorker } : {},
-    backendBundles: await tagStep2("build", () => compileBackendBundles(target.root, join29(target.configDir, target.functionsDir))),
+    backendBundles: await tagStep2("build", () => compileBackendBundles(target.root, join30(target.configDir, target.functionsDir))),
     ...await collectResources(target.configDir, target)
   };
 }
@@ -262007,7 +263804,7 @@ function writeFile3(appId, params) {
 function editFile(appId, params) {
   return callTool(appId, "edit_file", { ...params }, EditFileResponseSchema, `editing file "${params.path}"`);
 }
-function grep(appId, params) {
+function grep2(appId, params) {
   return callTool(appId, "grep", { ...params }, GrepResponseSchema, "searching files");
 }
 function runCommand(appId, params) {
@@ -262111,10 +263908,10 @@ Examples:
 }
 
 // src/cli/commands/sandbox/grep.ts
-async function grepAction({ runTask, branchId }, pattern, options) {
+async function grepAction2({ runTask, branchId }, pattern, options) {
   const { id: appId } = getAppContext();
   const maxResults = parsePositiveInt(options.maxResults, "--max-results");
-  const result = await runTask("Searching files", () => grep(appId, {
+  const result = await runTask("Searching files", () => grep2(appId, {
     pattern,
     path: options.path,
     is_regex: options.regex,
@@ -262126,7 +263923,7 @@ async function grepAction({ runTask, branchId }, pattern, options) {
   return { outroMessage: "Searched files", stdout: toJsonStdout(result) };
 }
 function getSandboxGrepCommand() {
-  return new Base44Command("grep", { supportsBranch: true }).description("Search files for a pattern in an app's remote sandbox").argument("<pattern>", "Search pattern").option("--path <path>", "Subtree to search, relative to the app root").option("--no-regex", "Treat the pattern as a literal string, not a regex").option("--case-sensitive", "Case-sensitive match").option("--glob <glob>", 'File glob filter, e.g. "*.tsx"').option("--max-results <n>", "Maximum number of match lines to return").action(grepAction);
+  return new Base44Command("grep", { supportsBranch: true }).description("Search files for a pattern in an app's remote sandbox").argument("<pattern>", "Search pattern").option("--path <path>", "Subtree to search, relative to the app root").option("--no-regex", "Treat the pattern as a literal string, not a regex").option("--case-sensitive", "Case-sensitive match").option("--glob <glob>", 'File glob filter, e.g. "*.tsx"').option("--max-results <n>", "Maximum number of match lines to return").action(grepAction2);
 }
 
 // src/cli/commands/sandbox/list-directory.ts
@@ -262721,10 +264518,10 @@ function toPascalCase(name) {
   return name.split(/[-_\s]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
 }
 // src/core/types/update-project.ts
-import { join as join33 } from "node:path";
+import { join as join34 } from "node:path";
 var TYPES_INCLUDE_PATH = `${PROJECT_SUBDIR}/${TYPES_OUTPUT_SUBDIR}/*.d.ts`;
 async function updateProjectConfig(projectRoot) {
-  const tsconfigPath = join33(projectRoot, "tsconfig.json");
+  const tsconfigPath = join34(projectRoot, "tsconfig.json");
   if (!await pathExists(tsconfigPath)) {
     return false;
   }
@@ -262943,7 +264740,7 @@ function rethrowLegacyAppAsExplanation(error) {
 
 // src/cli/commands/workflows/limit.ts
 var MAX_LIMIT = 200;
-function parseLimit(limit) {
+function parseLimit2(limit) {
   if (limit === undefined)
     return;
   const parsed = Number.parseInt(limit, 10);
@@ -262960,7 +264757,7 @@ function formatWorkflowLine(workflow) {
   return `${workflow.name}  [${workflow.status}]  runs: ${workflow.totalRuns}, ${lastRun}${failures}`;
 }
 async function listAction({ log, runTask, jsonMode }, options) {
-  const limit = parseLimit(options.limit);
+  const limit = parseLimit2(options.limit);
   const workflows = await runTask("Fetching workflows from Base44", async () => listWorkflows(limit).catch(rethrowLegacyAppAsExplanation), {
     successMessage: "Workflows fetched successfully",
     errorMessage: "Failed to fetch workflows"
@@ -263019,7 +264816,7 @@ async function describeEmptyResult(hasFilters) {
   return hasFilters ? `No runs match your filters. Workflows in this app: ${names}.` : `No runs yet. Workflows in this app: ${names}.`;
 }
 async function runsAction(ctx, options) {
-  const limit = parseLimit(options.limit);
+  const limit = parseLimit2(options.limit);
   const runs = await ctx.runTask("Fetching workflow runs from Base44", async () => listWorkflowRuns({
     status: options.status,
     since: options.since,
@@ -263205,7 +265002,7 @@ function getWorkspaceCommand() {
 // src/cli/dev/dev-server/main.ts
 var import_cors = __toESM(require_lib4(), 1);
 var import_express6 = __toESM(require_express(), 1);
-import { dirname as dirname27, join as join38 } from "node:path";
+import { dirname as dirname27, join as join39 } from "node:path";
 
 // ../../node_modules/get-port/index.js
 import net from "node:net";
@@ -263335,7 +265132,7 @@ var $tmpName = promisify12(tmp.tmpName);
 
 // src/cli/dev/dev-server/function-manager.ts
 import { spawn as spawn3 } from "node:child_process";
-import { dirname as dirname24, join as join34 } from "node:path";
+import { dirname as dirname24, join as join35 } from "node:path";
 import { pathToFileURL as pathToFileURL6 } from "node:url";
 
 // src/cli/dev/dev-server/base-function-manager.ts
@@ -263440,7 +265237,7 @@ class FunctionManager extends BaseFunctionManager {
   }
   spawnFunction(func, port) {
     this.logger.log(`Spawning function "${func.name}" on port ${port}`);
-    const importMapPath = join34(dirname24(this.wrapperPath), "import-map.json");
+    const importMapPath = join35(dirname24(this.wrapperPath), "import-map.json");
     const process2 = spawn3("deno", ["run", "--allow-all", "--import-map", importMapPath, this.wrapperPath], {
       env: {
         ...globalThis.process.env,
@@ -263514,7 +265311,7 @@ class FunctionManager extends BaseFunctionManager {
 import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { isBuiltin as isBuiltin3 } from "node:module";
 import { homedir as homedir4 } from "node:os";
-import { join as join35 } from "node:path";
+import { join as join36 } from "node:path";
 import { pathToFileURL as pathToFileURL7 } from "node:url";
 var depsPromise;
 function loadDeps() {
@@ -263635,9 +265432,9 @@ export default {
 };
 `;
 function ensureBundlerConfig() {
-  const dir = join35(homedir4(), ".base44", "function-bundler");
+  const dir = join36(homedir4(), ".base44", "function-bundler");
   mkdirSync2(dir, { recursive: true });
-  const configPath = join35(dir, "deno.json");
+  const configPath = join36(dir, "deno.json");
   writeFileSync2(configPath, `${JSON.stringify({ nodeModulesDir: "auto" }, null, 2)}
 `);
   return configPath;
@@ -265174,11 +266971,11 @@ import { relative as relative10 } 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 stat6 } from "node:fs/promises";
+import { readdir as readdir3, stat as stat7 } 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 stat4 } from "node:fs/promises";
+import { lstat as lstat2, readdir as readdir2, realpath, stat as stat5 } 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 = {
@@ -265187,7 +266984,7 @@ var EntryTypes = {
   FILE_DIR_TYPE: "files_directories",
   EVERYTHING_TYPE: "all"
 };
-var defaultOptions = {
+var defaultOptions2 = {
   root: ".",
   fileFilter: (_entryInfo) => true,
   directoryFilter: (_entryInfo) => true,
@@ -265197,7 +266994,7 @@ var defaultOptions = {
   alwaysStat: false,
   highWaterMark: 4096
 };
-Object.freeze(defaultOptions);
+Object.freeze(defaultOptions2);
 var RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
 var NORMAL_FLOW_ERRORS = new Set(["ENOENT", "EPERM", "EACCES", "ELOOP", RECURSIVE_ERROR_CODE]);
 var ALL_TYPES = [
@@ -265256,17 +267053,17 @@ class ReaddirpStream extends Readable6 {
       autoDestroy: true,
       highWaterMark: options.highWaterMark
     });
-    const opts = { ...defaultOptions, ...options };
+    const opts = { ...defaultOptions2, ...options };
     const { root, type } = opts;
     this._fileFilter = normalizeFilter(opts.fileFilter);
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
-    const statMethod = opts.lstat ? lstat2 : stat4;
+    const statMethod = opts.lstat ? lstat2 : stat5;
     if (wantBigintFsStats) {
       this._stat = (path) => statMethod(path, { bigint: true });
     } else {
       this._stat = statMethod;
     }
-    this._maxDepth = opts.depth != null && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions.depth;
+    this._maxDepth = opts.depth != null && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions2.depth;
     this._wantsDir = type ? DIR_TYPES.has(type) : false;
     this._wantsFile = type ? FILE_TYPES2.has(type) : false;
     this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
@@ -265413,7 +267210,7 @@ function readdirp(root, options = {}) {
 
 // ../../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 stat5 } from "node:fs/promises";
+import { realpath as fsrealpath, lstat as lstat3, open as open2, stat as stat6 } from "node:fs/promises";
 import { type as osType } from "node:os";
 import * as sp2 from "node:path";
 var STR_DATA = "data";
@@ -265439,7 +267236,7 @@ var EVENTS = {
 };
 var EV = EVENTS;
 var THROTTLE_MODE_WATCH = "watch";
-var statMethods = { lstat: lstat3, stat: stat5 };
+var statMethods = { lstat: lstat3, stat: stat6 };
 var KEY_LISTENERS = "listeners";
 var KEY_ERR = "errHandlers";
 var KEY_RAW = "rawEmitters";
@@ -265910,7 +267707,7 @@ class NodeFsHandler {
         return;
       if (!newStats || newStats.mtimeMs === 0) {
         try {
-          const newStats = await stat5(file);
+          const newStats = await stat6(file);
           if (this.fsw.closed)
             return;
           const at = newStats.atimeMs;
@@ -266582,7 +268379,7 @@ class FSWatcher extends EventEmitter3 {
       const fullPath = opts.cwd ? sp3.join(opts.cwd, path) : path;
       let stats;
       try {
-        stats = await stat6(fullPath);
+        stats = await stat7(fullPath);
       } catch (err) {}
       if (!stats || this.closed)
         return;
@@ -266966,8 +268763,8 @@ async function createDevServer(options) {
     broadcastEntityEvent(io, appId, entityName, event);
   };
   const base44ConfigWatcher = new WatchBase44({
-    functions: join38(dirname27(project.configPath), project.functionsDir),
-    entities: join38(dirname27(project.configPath), project.entitiesDir)
+    functions: join39(dirname27(project.configPath), project.functionsDir),
+    entities: join39(dirname27(project.configPath), project.entitiesDir)
   }, devLogger);
   base44ConfigWatcher.on("change", async (name) => {
     try {
@@ -267170,7 +268967,7 @@ function readExecEnvTarget(env = process.env) {
 // src/core/exec/run-script.ts
 import { spawn as spawn4 } from "node:child_process";
 import { readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join39 } from "node:path";
+import { join as join40 } from "node:path";
 var SDK_SPECIFIER = '"npm:@base44/sdk"';
 function wrapperSource(sdkVersion) {
   const source = readFileSync4(getExecWrapperPath(), "utf-8");
@@ -267206,7 +269003,7 @@ async function runScript(options) {
   writeFileSync3(tempWrapper.path, wrapperSource(sdkVersion), "utf-8");
   const configDir = await $dir({ unsafeCleanup: true });
   cleanupFns.push(configDir.cleanup);
-  const configPath = join39(configDir.path, "deno.json");
+  const configPath = join40(configDir.path, "deno.json");
   writeFileSync3(configPath, JSON.stringify(DENO_CONFIG), "utf-8");
   try {
     const exitCode = await new Promise((resolvePromise) => {
@@ -267478,6 +269275,7 @@ function createProgram(context) {
   program.addCommand(getSecretsCommand());
   program.addCommand(getSandboxCommand());
   program.addCommand(getBranchesCommand());
+  program.addCommand(getApiCommand());
   program.addCommand(getAuthCommand());
   program.addCommand(getSiteCommand());
   if (versionsApiEnabled()) {
@@ -271496,7 +273294,7 @@ function addCommandInfoToErrorReporter(program, errorReporter) {
 // src/cli/index.ts
 var __dirname4 = dirname29(fileURLToPath7(import.meta.url));
 async function runCLI(options) {
-  ensureNpmAssets(join40(__dirname4, "../assets"));
+  ensureNpmAssets(join41(__dirname4, "../assets"));
   const errorReporter = new ErrorReporter;
   errorReporter.registerProcessErrorHandlers();
   const jsonMode = process.argv.includes("--json");
@@ -271535,4 +273333,4 @@ export {
   runCLI
 };
 
-//# debugId=45318CD4F94D8EF364756E2164756E21
+//# debugId=CD2605865A84BE8564756E2164756E21