@base44-preview/cli 0.1.32-pr.663.d960536 → 0.1.32-pr.663.dc1ede1

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
@@ -249102,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,
@@ -249127,16 +249133,37 @@ 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)] : [];
   });
@@ -249145,6 +249172,7 @@ function searchOperations(operations, query, options = {}) {
 // 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);
@@ -249166,48 +249194,25 @@ function groupByArea(operations) {
   }
   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: ops.slice(0, AREA_SAMPLE_MAX).map((op) => op.summary)
+    sample: readsFirst2(ops).slice(0, AREA_SAMPLE_MAX).map((op) => op.summary)
   });
   return { areas, total: operations.length };
 }
-// 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;
-    }
-  }
-  return found;
-}
-function grepSpec(spec, operations, pattern, options = {}) {
-  const regex = new RegExp(pattern, options.ignoreCase ? "gi" : "g");
-  const hits = [];
-  const inArea = (op) => options.area === undefined || areaOf(op.path) === options.area;
-  for (const op of operations.filter(inArea)) {
-    const matches = snippets(`${op.method} ${op.path} ${JSON.stringify(op.operation)}`, regex);
-    if (matches.length > 0) {
-      hits.push({ ...toOperationSummary(op), matches });
-    }
-  }
-  const schemas = options.area === undefined ? 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);
+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 = [
@@ -249225,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({
@@ -249237,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),
@@ -249260,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 ?? "",
@@ -249310,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()) {
@@ -249389,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");
@@ -249409,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) {
@@ -249443,9 +249610,13 @@ 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 }), {
+function quietTask({ runTask, isNonInteractive }, label, operation, messages) {
+  return isNonInteractive ? operation() : runTask(label, operation, messages);
+}
+function loadSpecTask(ctx, refresh) {
+  return quietTask(ctx, "Loading the API spec", () => loadSpec({ refresh }), {
     successMessage: "Loaded the API spec"
   });
 }
@@ -249460,53 +249631,56 @@ function operationsInArea(operations, area) {
   }
   return inArea;
 }
-async function readRequestBody(method, flag) {
+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) {
-    return flag;
-  }
-  if (method === "GET" || method === "HEAD" || process.stdin.isTTY) {
-    return;
+  if (flag === undefined && isPipedStdin()) {
+    log.warn("stdin is ignored; pass --body @- to send it as the body.");
   }
-  const piped = await readStdin("--body", { trim: false });
-  return piped.trim() ? piped : undefined;
+  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(operations)) };
+    return { stdout: formatJson(catalogIndex(readOnly(operations))) };
   }
-  const inArea = operationsInArea(operations, area);
-  return {
-    stdout: formatJson({
-      area,
-      operations: inArea.map(toOperationSummary),
-      total: inArea.length
-    })
-  };
+  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("--refresh", REFRESH_OPTION_HELP).action(catalogAction);
+  }).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>"'
@@ -249516,34 +249690,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 (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.`);
     }
   }
+  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 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 quietTask(ctx, `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
@@ -249558,12 +249789,14 @@ async function grepAction(ctx, pattern, options) {
   const limit = parseLimit(options.limit);
   assertValidRegex(pattern);
   const { spec } = await loadSpecTask(ctx, options.refresh);
-  const operations = listOperations(spec);
+  let operations = listOperations(spec);
   if (options.area !== undefined) {
-    operationsInArea(operations, options.area);
+    operations = operationsInArea(operations, options.area);
+  }
+  if (options.readOnly) {
+    operations = operations.filter((op) => op.readOnly);
   }
-  const hits = grepSpec(spec, operations, pattern, {
-    area: options.area,
+  const hits = grepOperations(spec, operations, pattern, {
     ignoreCase: options.ignoreCase,
     limit
   });
@@ -249573,7 +249806,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("--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("--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
@@ -249590,7 +249823,7 @@ 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
@@ -262133,7 +262366,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
@@ -273135,4 +273368,4 @@ export {
   runCLI
 };
 
-//# debugId=6956BED77F56E7A964756E2164756E21
+//# debugId=426C741A046A975D64756E2164756E21