@xano/developer-mcp 1.0.46 → 1.0.48

package/dist/xanoscript_docs/cheatsheet.md

@@ -33,21 +33,46 @@ conditional {
 
 > **Note:** Use `elseif` (one word), not `else if`.
 
+## Switch
+
+```xs
+switch ($input.status) {
+  case ("active") {
+    var $message { value = "User is active" }
+  } break
+  case ("pending") {
+    var $message { value = "User is pending" }
+  } break
+  default {
+    var $message { value = "Unknown status" }
+  }
+}
+```
+
+> **Note:** `break` goes **after** the closing `}` of each `case` block. The `default` case does not need `break`.
+
 ## Loops
 
 ```xs
 // For each loop
-each ($input.items as $item) {
-  debug.log { value = $item.name }
+foreach ($input.items) {
+  each as $item {
+    debug.log { value = $item.name }
+  }
 }
 
-// While loop (must be inside stack block)
-stack {
-  var $counter { value = 0 }
-  while ($counter < 10) {
-    each {
-      var.update $counter { value = $counter + 1 }
-    }
+// For loop (iterate N times)
+for (10) {
+  each as $index {
+    debug.log { value = $index }
+  }
+}
+
+// While loop
+var $counter { value = 0 }
+while ($counter < 10) {
+  each {
+    var.update $counter { value = $counter + 1 }
   }
 }
 

package/dist/xanoscript_docs/integrations/external-apis.md

@@ -149,25 +149,29 @@ var $content_type { value = $api_result.response.headers|first }
 var $retries { value = 0 }
 var $success { value = false }
 
-while ($retries < 3 && $success == false) {
-  try_catch {
-    try {
-      api.request {
-        url = "https://api.example.com/data"
-        method = "GET"
-        timeout = 10
-      } as $api_result
-
-      conditional {
-        if ($api_result.response.status == 200) {
-          var.update $success { value = true }
+stack {
+  while ($retries < 3 && $success == false) {
+    each {
+      try_catch {
+        try {
+          api.request {
+            url = "https://api.example.com/data"
+            method = "GET"
+            timeout = 10
+          } as $api_result
+
+          conditional {
+            if ($api_result.response.status == 200) {
+              var.update $success { value = true }
+            }
+          }
+        }
+        catch {
+          var.update $retries { value = $retries + 1 }
+          util.sleep { value = 2 }
         }
       }
     }
-    catch {
-      var.update $retries { value = $retries + 1 }
-      util.sleep { value = 2 }
-    }
   }
 }
 ```

package/dist/xanoscript_docs/performance.md

@@ -286,11 +286,14 @@ For basic rate limiting setup, see `xanoscript_docs({ topic: "security" })`. Bel
 
 ```xs
 // Different limits by user tier
-var $limit {
-  value = conditional {
-    if ($auth.tier == "premium") { 1000 }
-    elseif ($auth.tier == "pro") { 500 }
-    else { 100 }
+var $limit { value = 100 }
+
+conditional {
+  if ($auth.tier == "premium") { 
+    var.update $limit { value = 1000 } 
+  }
+  elseif ($auth.tier == "pro") {
+    var.update $limit { value = 500 } 
   }
 }
 

package/dist/xanoscript_docs/quickstart.md

@@ -611,6 +611,28 @@ stack {
 }
 ```
 
+### 13. Multiple constructs in one file
+Each `.xs` file must contain exactly **one** construct. Placing two constructs in the same file causes a parse error.
+
+```xs
+// ❌ Wrong - two constructs in one file
+function "helper_a" {
+  stack { ... }
+  response = $result
+}
+
+function "helper_b" {
+  stack { ... }
+  response = $result
+}
+```
+
+```
+// ✅ Correct - one construct per file
+// function/helper_a.xs  → contains only "helper_a"
+// function/helper_b.xs  → contains only "helper_b"
+```
+
 ---
 
 ## Related Topics

package/dist/xanoscript_docs/syntax.md

@@ -112,22 +112,42 @@ Working with...
 
 > **Note:** There is no `default` filter. Use conditional blocks or `first_notnull`/`first_notempty` instead.
 
-### String Concatenation with Filters
+### Parentheses and Filter Precedence
 
-When concatenating strings that use filters, wrap each filtered expression in parentheses:
+> **Rule:** Filters bind greedily to the left. Without parentheses, the parser extends the filter expression into the operator that follows — producing invalid or unexpected results. **When in doubt, wrap `$var|filter` in parentheses.**
+
+The filter `|` grabs everything to its right until it hits a boundary. This means `$arr|count > 3` is parsed as `$arr | (length > 3)` — treating `count > 3` as the filter argument, which is invalid.
 
 ```xs
-// ✅ Correct - parentheses around filtered expressions
+// ❌ Wrong — parser reads filter argument as "count == 0" (invalid)
+if ($arr|count == 0) { ... }
+
+// ❌ Wrong — parse error in concatenation
 var $message {
-  value = ($status|to_text) ~ ": " ~ ($data|json_encode)
+  value = $status|to_text ~ ": " ~ $data|json_encode
 }
+```
+
+```xs
+// ✅ Correct — evaluate filter first, then apply operator
+
+// ✅ Correct
+if (($arr|count) == 0) { ... }
 
-// ❌ Incorrect - missing parentheses causes parse error
+// ✅ Correct — wrap each filtered expression for concatenation
 var $message {
-  value = $status|to_text ~ ": " ~ $data|json_encode
+  value = ($status|to_text) ~ ": " ~ ($data|json_encode)
 }
+
+// ✅ Correct — filter result used in arithmetic
+var $total { value = ($prices|sum) + $tax }
+
+// ✅ Correct — filter result compared
+var $is_long { value = ($text|strlen) > 100 }
 ```
 
+**Summary:** Any time you apply an operator (`>`, `<`, `==`, `!=`, `~`, `+`, `-`, etc.) to a filtered value, wrap the `$var|filter` portion in its own parentheses.
+
 ---
 
 ## Conditional Blocks
@@ -150,16 +170,19 @@ conditional {
 
 > **Important:** Use `elseif` (one word), not `else if` or `else { if (...) }`. Nested `if` inside `else` blocks is not supported.
 
-### Conditional as Expression
+### Conditional with Variable Updates
 
-Use conditional blocks inline to return values:
+Use conditional blocks to update a variable based on conditions:
 
 ```xs
-var $tier_limit {
-  value = conditional {
-    if ($auth.tier == "premium") { 1000 }
-    elseif ($auth.tier == "pro") { 500 }
-    else { 100 }
+var $tier_limit { value = 100 }
+
+conditional {
+  if ($auth.tier == "premium") { 
+    var.update $tier_limit { value = 1000 }
+  }
+  elseif ($auth.tier == "pro") { 
+    var.update $tier_limit { value = 500 }
   }
 }
 ```
@@ -282,7 +305,7 @@ $db.post.date >=? $input.start_date
 | `unique` | `[1,1,2]\|unique` | `[1,2]` |
 | `flatten` | `[[1,2],[3]]\|flatten` | `[1,2,3]` |
 | `shuffle` | `[1,2,3]\|shuffle` | Random order |
-| `slice` | `[1,2,3,4]\|slice:1:2` | `[2,3]` |
+| `slice` | `[1,2,3,4]\|slice:1:2` | `[2,3]` — offset 1, length 2 |
 | `push` | `[1,2]\|push:3` | `[1,2,3]` |
 | `pop` | `[1,2,3]\|pop` | `3` |
 | `shift` | `[1,2,3]\|shift` | `1` |
@@ -328,6 +351,30 @@ Generate numeric ranges with the `..` operator:
 [1,2,3,4]|reduce:$$+$result:0               // 10
 ```
 
+### Array Element Access: `|get` vs `|slice`
+
+> **`|get:N`** returns a **single element** by zero-based index.
+> **`|slice:offset:length`** returns a **sub-array**, skipping `offset` elements and returning the next `length` elements.
+
+| Method | Use For | Example | Result |
+|--------|---------|---------|--------|
+| `\|get:N` | Single element by index (0-based) | `[10,20,30]\|get:0` | `10` |
+| `\|slice:offset:length` | Sub-array — skip N, take M | `[10,20,30,40]\|slice:1:2` | `[20,30]` |
+| `\|first` | First element | `[10,20,30]\|first` | `10` |
+| `\|last` | Last element | `[10,20,30]\|last` | `30` |
+
+```xs
+// Single element by index
+var $third { value = $items|get:2 }             // 0-based: 3rd element
+
+// Sub-array: skip first 10, return the next 5
+var $page { value = $items|slice:10:5 }
+
+// ⚠️ slice:offset:length — NOT slice:start:end
+// $arr|slice:2:3 → skip 2, return 3 elements (indices 2, 3, 4)
+// NOT "from index 2 to index 3"
+```
+
 ### Grouping & Indexing
 ```xs
 // Group by property

package/dist/xanoscript_docs/unit-testing.md

@@ -35,6 +35,46 @@ function "<name>" {
 
 ---
 
+## Scope Limitations
+
+> **Unit tests can only access `$response`** — the value declared in the construct's `response = ...` field. Tests do **not** have access to intermediate stack variables.
+
+```xs
+function "calculate" {
+  input { int x }
+  stack {
+    var $doubled { value = $input.x * 2 }    // NOT accessible in tests
+    var $result  { value = $doubled + 1 }    // NOT accessible in tests
+  }
+  response = $result                          // This becomes $response in tests
+
+  test "doubles and adds one" {
+    input = { x: 5 }
+    // ✅ Can access $response (the declared response)
+    expect.to_equal ($response) { value = 11 }
+
+    // ❌ Stack variables are not in scope — this will fail
+    // expect.to_equal ($doubled) { value = 10 }
+  }
+}
+```
+
+To assert on intermediate values, expose them through the response:
+
+```xs
+response = { result: $result, doubled: $doubled }
+
+test "intermediate values" {
+  input = { x: 5 }
+  expect.to_equal ($response.doubled) { value = 10 }
+  expect.to_equal ($response.result) { value = 11 }
+}
+```
+
+> **Note:** Function stack variables (variables defined in other functions called via `function.run`) are also not accessible — tests are fully isolated to the construct's own declared response.
+
+---
+
 ## Basic Test
 
 ```xs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xano/developer-mcp",
-  "version": "1.0.46",
+  "version": "1.0.48",
   "description": "MCP server and library for Xano development - XanoScript validation, Meta API, Run API, and CLI documentation",
   "type": "module",
   "main": "dist/lib.js",