@base44-preview/cli 0.1.32-pr.663.57b7b28 → 0.1.32-pr.663.60cadbf

package/dist/cli/index.js

@@ -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
@@ -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
       })) {
@@ -247587,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
@@ -248042,28 +248042,6 @@ function getAgentsCommand() {
   return new Command2("agents").description("Manage project agents").addCommand(getAgentsPushCommand()).addCommand(getAgentsPullCommand());
 }
 
-// src/core/api-spec/body.ts
-var METHODS_WITHOUT_BODY = new Set(["GET", "HEAD"]);
-async function resolveRequestBody(method, flag, source) {
-  const takesBody = !METHODS_WITHOUT_BODY.has(method.toUpperCase());
-  if (flag !== undefined && !takesBody) {
-    throw new InvalidInputError(`${method.toUpperCase()} requests cannot have a body.`);
-  }
-  if (flag === "@-") {
-    return source.readStdin();
-  }
-  if (flag?.startsWith("@")) {
-    return readTextFile(flag.slice(1));
-  }
-  if (flag !== undefined) {
-    return flag;
-  }
-  if (!takesBody || source.stdinIsTTY) {
-    return;
-  }
-  const piped = await source.readStdin();
-  return piped.trim() ? piped : undefined;
-}
 // ../../node_modules/minisearch/dist/es/index.js
 var ENTRIES = "ENTRIES";
 var KEYS = "KEYS";
@@ -249124,24 +249102,30 @@ 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 BOOST = {
+  method: 1,
+  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 id 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.length >= 2 && !STOPWORDS.has(word.toLowerCase()));
+}
 function toOperationSummary(op) {
-  return {
-    method: op.method,
-    path: op.path,
-    summary: op.summary,
-    readOnly: op.readOnly
-  };
+  return { endpoint: op.endpoint, summary: op.summary };
 }
 function buildSearchIndex(operations) {
   const index = new MiniSearch({
-    fields: ["path", "summary", "description", "parameters"],
-    tokenize: (text) => text.split(TOKEN_SEPARATOR).filter(Boolean)
+    fields: ["method", "path", "summary", "description", "parameters"],
+    tokenize
   });
   index.addAll(operations.map((op, id) => ({
     id,
+    method: op.method,
     path: op.path.replace(/\{[^}]*\}/g, ""),
     summary: op.summary,
     description: op.description,
@@ -249149,53 +249133,86 @@ function buildSearchIndex(operations) {
   })));
   return index;
 }
+function summaryMatch(terms, op) {
+  const words = tokenize(op?.summary.toLowerCase() ?? "");
+  const named = (word) => terms.some((term) => word.startsWith(term));
+  return {
+    coverage: terms.filter((term) => words.some((word) => word.startsWith(term))).length / terms.length,
+    precision: words.length ? words.filter(named).length / words.length : 0
+  };
+}
+var readsFirst = (op) => op?.method === "GET" ? 0 : 1;
 function searchOperations(operations, query, options = {}) {
+  const terms = tokenize(query.toLowerCase());
+  if (terms.length === 0) {
+    return [];
+  }
   const index = buildSearchIndex(operations);
   const hits = index.search(query, {
-    prefix: true,
-    fuzzy: 0.2,
+    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
-  });
-  const baseline = (hits[0]?.score ?? 0) * MIN_RELATIVE_SCORE;
-  return hits.filter((hit) => hit.score >= baseline).slice(0, options.limit ?? 5).flatMap((hit) => {
+  }).map((hit) => {
+    const match = summaryMatch(terms, operations[hit.id]);
+    return {
+      ...hit,
+      ...match,
+      full: match.coverage === 1,
+      score: hit.score * (1 + match.coverage)
+    };
+  }).sort((a, b) => Number(b.full) - Number(a.full) || (a.full ? b.precision - a.precision || readsFirst(operations[a.id]) - readsFirst(operations[b.id]) : 0) || b.score - a.score);
+  const baseline = Math.max(0, ...hits.map((hit) => hit.score)) * MIN_RELATIVE_SCORE;
+  return hits.filter((hit) => hit.full || hit.score >= baseline).slice(0, options.limit ?? 5).flatMap((hit) => {
     const op = operations[hit.id];
     return op ? [toOperationSummary(op)] : [];
   });
 }
 
-// src/core/api-spec/grep.ts
-var CONTEXT_CHARS = 40;
-var MAX_SNIPPETS = 3;
-var MAX_SNIPPET_CHARS = 200;
-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(text.slice(start, Math.min(end, start + MAX_SNIPPET_CHARS)));
-    if (found.length === MAX_SNIPPETS || match[0].length === 0) {
-      break;
-    }
+// 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";
   }
-  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 matches = snippets(`${op.method} ${op.path} ${JSON.stringify(op.operation)}`, regex);
-    if (matches.length > 0) {
-      hits.push({ ...toOperationSummary(op), matches });
-    }
+  if (parts[0] === "api" && parts.length > 1) {
+    return parts[1] ?? "other";
   }
-  for (const [schema, definition] of Object.entries(spec.components?.schemas ?? {})) {
-    const matches = snippets(JSON.stringify(definition), regex);
-    if (matches.length > 0) {
-      hits.push({ schema, matches });
-    }
+  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 hits.slice(0, options.limit ?? 20);
+  return new Map([...areas].sort(([a], [b]) => byCodePoint(a, b)));
+}
+function readsFirst2(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: readsFirst2(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/schema.ts
 var HTTP_METHODS = [
@@ -249213,7 +249230,16 @@ var ParameterSchema = looseObject({
   in: string2(),
   required: boolean2().optional(),
   description: string2().optional(),
-  schema: unknown().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({
@@ -249225,7 +249251,10 @@ var OperationSchema = looseObject({
   responses: record(string2(), unknown()).optional(),
   security: array(SecurityRequirementSchema).optional()
 });
-var PathItemSchema = looseObject(Object.fromEntries(HTTP_METHODS.map((method) => [method, OperationSchema.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),
@@ -249248,14 +249277,33 @@ function parameterText(operation) {
     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 operation = item[method];
-    if (!operation) {
+    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 ?? "",
@@ -249298,63 +249346,197 @@ function matchOperation(operations, method, concretePath) {
   });
   return candidates.sort((a, b) => compareSpecificity(specificity(pathSegments(a.path)), specificity(pathSegments(b.path))))[0];
 }
-function collectRefs(value, spec, found) {
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      collectRefs(item, spec, found);
+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;
     }
-    return;
+    const resolved = inlineRefs(schemas[name], schemas, new Set([...seen, name]), depth + 1);
+    return resolved !== null && typeof resolved === "object" ? { ...resolved, ...siblings } : resolved;
   }
-  if (value === null || typeof value !== "object") {
-    return;
+  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);
+      }
+    }
   }
-  for (const [key, child] of Object.entries(value)) {
-    if (key === "$ref" && typeof child === "string" && !found.has(child)) {
-      const target = resolvePointer(spec, child);
-      found.set(child, target);
-      collectRefs(target, spec, found);
-    } else {
-      collectRefs(child, spec, found);
+  return found;
+}
+var SCHEMA_DATA_KEYS = new Set([
+  "example",
+  "examples",
+  "default",
+  "enum",
+  "const"
+]);
+var DOCS_CALLOUT = /<(Info|Note|Tip|Check|Warning)>([\s\S]*?)<\/\1>/g;
+var RELATIVE_LINK = /\[([^\]]+)\]\(\/[^)]*\)/g;
+function cleanText(text) {
+  return text.replace(DOCS_CALLOUT, (_, kind, body) => kind === "Warning" ? `Warning: ${body}` : body).replace(RELATIVE_LINK, "$1");
+}
+function slimSchema(node, isPropertyMap = false) {
+  if (Array.isArray(node)) {
+    return node.map((item) => slimSchema(item));
+  }
+  if (node === null || typeof node !== "object") {
+    return node;
+  }
+  const entries = Object.entries(node);
+  if (isPropertyMap) {
+    return Object.fromEntries(entries.map(([name, value]) => [name, slimSchema(value)]));
+  }
+  const slim = {};
+  for (const [key, value] of entries) {
+    if (key === "title" && typeof value === "string") {
+      continue;
     }
+    slim[key] = SCHEMA_DATA_KEYS.has(key) ? value : key === "properties" ? slimSchema(value, true) : key === "description" && typeof value === "string" ? cleanText(value) : slimSchema(value);
   }
+  const { anyOf, ...rest } = slim;
+  const nullable = Array.isArray(anyOf) && anyOf.length === 2 ? nullableType(anyOf) : undefined;
+  return nullable ? { type: [nullable, "null"], ...rest } : slim;
 }
-function resolvePointer(spec, ref) {
-  if (!ref.startsWith("#/")) {
+function nullableType(variants) {
+  const types = variants.map((variant) => variant !== null && typeof variant === "object" && Object.keys(variant).length === 1 && typeof variant.type === "string" ? variant.type : undefined);
+  if (types.includes(undefined) || !types.includes("null")) {
     return;
   }
-  return ref.slice(2).split("/").map((part) => part.replace(/~1/g, "/").replace(/~0/g, "~")).reduce((node, part) => node !== null && typeof node === "object" ? node[part] : undefined, spec);
+  return types.find((type) => type !== "null");
 }
 function getOperationContract(spec, op) {
-  const { parameters, requestBody, responses } = op.operation;
-  const refs = new Map;
-  collectRefs({ parameters, requestBody, responses }, spec, refs);
-  return {
+  const schemas = spec.components?.schemas ?? {};
+  const inline = (node) => node === undefined ? null : slimSchema(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,
-    readOnly: op.readOnly,
-    parameters: parameters ?? [],
-    requestBody: requestBody ?? null,
-    responses: responses ?? {},
-    refs: Object.fromEntries(refs)
+    description: cleanText(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: cleanText(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,
+      cleanText(response.description ?? "")
+    ]))
+  };
+  const refs = leftoverRefs(contract, schemas);
+  return {
+    ...contract,
+    ...refs.size > 0 ? {
+      refs: Object.fromEntries([...refs].map(([ref, schema]) => [ref, slimSchema(schema)]))
+    } : {}
   };
 }
+
+// src/core/api-spec/grep.ts
+function grepOperations(spec, operations, pattern, options = {}) {
+  const regex = new RegExp(pattern, options.ignoreCase ? "i" : "");
+  return operations.filter((op) => regex.test(JSON.stringify(getOperationContract(spec, op)))).slice(0, options.limit ?? 20).map(toOperationSummary);
+}
 // 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" }
+      headers: body === undefined ? {} : { "Content-Type": "application/json" },
+      timeout: false
     });
-    return await response.text();
+    return {
+      status: response.status,
+      contentType: response.headers.get("content-type") ?? "",
+      body: new Uint8Array(await response.arrayBuffer())
+    };
   } catch (error) {
-    throw await ApiError.fromHttpError(error, `calling ${method} ${path}`);
+    const apiError = await ApiError.fromHttpError(error, `calling ${method} ${path}`);
+    const raw = error instanceof HTTPError ? await readBody(error.response) : undefined;
+    const message = raw && apiError.statusCode !== undefined ? `Error calling ${method} ${path}: HTTP ${apiError.statusCode}` : apiError.message;
+    throw new 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 { stat as stat3 } from "node:fs/promises";
+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()) {
@@ -249377,17 +249559,24 @@ function parseSpec(text) {
   }
   return result.data;
 }
+var SPEC_DOWNLOAD_TIMEOUT_MS = 60000;
 async function readFreshCache(path) {
   try {
     const { mtimeMs } = await stat3(path);
-    return isSpecCacheFresh(mtimeMs) ? await readTextFile(path) : null;
+    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");
+    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");
@@ -249397,29 +249586,19 @@ async function loadSpec(options = {}) {
   const path = getSpecCachePath();
   const cached = options.refresh ? null : await readFreshCache(path);
   if (cached !== null) {
-    return { text: cached, spec: parseSpec(cached) };
+    return cached;
   }
   const text = await downloadSpec();
   const spec = parseSpec(text);
-  await writeFile(path, 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 `${JSON.stringify(value, null, process.stdout.isTTY ? 2 : undefined)}
-`;
-}
-function formatResponseBody(text) {
-  if (!text) {
-    return "";
-  }
-  try {
-    return formatJson(JSON.parse(text));
-  } catch {
-    return text.endsWith(`
-`) ? text : `${text}
-`;
-  }
+  return toJsonStdout(value, { compact: !process.stdout.isTTY });
 }
 function parseLimit(value) {
   if (value === undefined) {
@@ -249431,20 +249610,74 @@ function parseLimit(value) {
   }
   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(flag, log) {
+  if (flag === "@-") {
+    return readStdin("--body @-", { trim: false });
+  }
+  if (flag?.startsWith("@")) {
+    return readTextFile(flag.slice(1));
+  }
+  if (flag === undefined && isPipedStdin()) {
+    log.warn("stdin is ignored; pass --body @- to send it as the body.");
+  }
+  return flag;
+}
+
+// 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) {
+async function findOperation(ctx, method, path, { refresh, flag }) {
   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} ${flag} --refresh`
+        },
         {
           message: "Find the operation and its path template",
           command: 'base44 api search "<what you want to do>"'
@@ -249454,43 +249687,91 @@ async function findOperation(ctx, method, path, refresh) {
   }
   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) {
-      return { stdout: command.helpInformation() };
+      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 (!HTTP_METHODS.some((m) => m.toUpperCase() === method)) {
-    throw new InvalidInputError(`Unknown HTTP method: ${methodArg}`);
-  }
-  if (!path.startsWith("/")) {
-    throw new InvalidInputError(`The path must start with "/", got ${path}.`);
-  }
   if (options.help) {
-    const { spec, op } = await findOperation(ctx, method, path, options.refresh);
+    const { spec, op } = await findOperation(ctx, method, path, {
+      refresh: options.refresh,
+      flag: "--help"
+    });
     return { stdout: formatJson(getOperationContract(spec, op)) };
   }
   if (options.readOnly) {
-    const { op } = await findOperation(ctx, method, path, options.refresh);
+    const { op } = await findOperation(ctx, method, path, {
+      refresh: options.refresh,
+      flag: "--read-only"
+    });
     if (!op.readOnly) {
       throw new InvalidInputError(`Refused under --read-only: ${op.method} ${op.path} is not a read-only operation. Nothing was sent.`);
     }
   }
-  const body = await resolveRequestBody(method, options.body, {
-    stdinIsTTY: Boolean(process.stdin.isTTY),
-    readStdin: () => readStdin("--body @-", { trim: false })
+  ctx.errorReporter.setContext({
+    command: {
+      name: "api fetch",
+      args: [method, path.split("?", 1)[0] ?? ""],
+      options: { ...options, body: options.body && "[not reported]" }
+    }
   });
   await ensureAuth(ctx);
-  const text = await ctx.runTask(`Calling ${method} ${path}`, () => sendApiRequest(method, path, body), { successMessage: `Called ${method} ${path}` });
-  return { stdout: formatResponseBody(text) };
+  const body = await readRequestBody(options.body, ctx.log);
+  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("--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);
+  }).description("Call a Base44 API operation; 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 @- to read it from stdin").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
@@ -249505,7 +249786,14 @@ async function grepAction(ctx, pattern, options) {
   const limit = parseLimit(options.limit);
   assertValidRegex(pattern);
   const { spec } = await loadSpecTask(ctx, options.refresh);
-  const hits = grepSpec(spec, listOperations(spec), pattern, {
+  let operations = listOperations(spec);
+  if (options.area !== undefined) {
+    operations = operationsInArea(operations, options.area);
+  }
+  if (options.readOnly) {
+    operations = operations.filter((op) => op.readOnly);
+  }
+  const hits = grepOperations(spec, operations, pattern, {
     ignoreCase: options.ignoreCase,
     limit
   });
@@ -249515,7 +249803,7 @@ 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("-i, --ignore-case", "Case-insensitive match").option("--limit <n>", "Most operations or schemas to return (default 20)").option("--refresh", REFRESH_OPTION_HELP).action(grepAction);
+  }).description("Search the 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 to return (default 20)").option("--read-only", READ_ONLY_FILTER_HELP).option("--refresh", REFRESH_OPTION_HELP).action(grepAction);
 }
 
 // src/cli/commands/api/search.ts
@@ -249532,12 +249820,12 @@ 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", "Return only read-only operations").option("--refresh", REFRESH_OPTION_HELP).action(searchAction);
+  }).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(getApiSearchCommand()).addCommand(getApiGrepCommand()).addCommand(getApiFetchCommand());
+  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
@@ -254901,6 +255189,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;
 }
@@ -257866,7 +258160,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() {
@@ -262069,7 +262363,7 @@ var nativeEnumType = ZodNativeEnum.create;
 var promiseType = ZodPromise.create;
 var effectsType = ZodEffects.create;
 var optionalType = ZodOptional2.create;
-var nullableType = ZodNullable2.create;
+var nullableType2 = ZodNullable2.create;
 var preprocessType = ZodEffects.createWithPreprocess;
 var pipelineType = ZodPipeline.create;
 // ../functions-compiler/src/contracts.ts
@@ -262490,6 +262784,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-"));
@@ -262513,6 +262975,7 @@ async function bundleToModule(prepared, nodeModulesDir = "none") {
         sourcemap: false,
         logLevel: "silent",
         plugins: [
+          wsNativeVirtualPlugin(),
           nodeBuiltinRequirePlugin(),
           userFilesPlugin(prepared.files, prepared.entry),
           privateDataSourcesVirtualPlugin(),
@@ -272902,4 +273365,4 @@ export {
   runCLI
 };
 
-//# debugId=FA1E97B3DE15B20C64756E2164756E21
+//# debugId=34B2FE9173AAC44664756E2164756E21