@rcrsr/rill 0.8.6 → 0.10.0

package/dist/generated/introspection-data.js

@@ -4,27 +4,6 @@ export const LANGUAGE_REFERENCE = `# rill
 
 > Scripting language designed for machine-generated code. LLMs generate rill scripts; humans review and debug. Data flows through pipes (\`->\`), not assignment. Variables use \`\$\` prefix. No null, no exceptions, no truthiness.
 
-## Documentation
-
-- [Getting Started](https://rill.run/docs/guide/getting-started/): Beginner-friendly introduction to rill
-- [Language Reference](https://rill.run/docs/reference/language/): Core language specification
-- [Examples](https://rill.run/docs/guide/examples/): Workflow patterns and use cases
-- [Cookbook](https://rill.run/docs/guide/cookbook/): Advanced agent scripting patterns
-- [Types](https://rill.run/docs/language/types/): Primitives, tuples, dicts, type assertions
-- [Variables](https://rill.run/docs/language/variables/): Declaration, scope rules, \`\$\` binding
-- [Control Flow](https://rill.run/docs/language/control-flow/): Conditionals, loops, break/return
-- [Operators](https://rill.run/docs/language/operators/): Arithmetic, comparison, spread, extraction
-- [Closures](https://rill.run/docs/language/closures/): Late binding, dict-bound closures
-- [Collections](https://rill.run/docs/data/collections/): \`each\`, \`map\`, \`filter\`, \`fold\` operators
-- [Iterators](https://rill.run/docs/data/iterators/): Lazy sequences with \`range\`, \`repeat\`, \`.first()\`
-- [Strings](https://rill.run/docs/data/strings/): String methods for text manipulation
-- [Host Integration](https://rill.run/docs/integration/host/): Embedding rill in applications
-- [Host API Reference](https://rill.run/docs/reference/host-api/): Complete TypeScript API exports
-- [Developing Extensions](https://rill.run/docs/integration/extensions/): Writing reusable host function packages
-- [Modules](https://rill.run/docs/integration/modules/): Convention for host-provided module systems
-- [CLI Tools](https://rill.run/docs/integration/cli/): \`rill-exec\`, \`rill-eval\`, \`rill-check\` commands
-- [Error Reference](https://rill.run/docs/reference/errors/): Error codes and resolution
-
 ## Essentials
 
 1. Variables use \`\$\` prefix ALWAYS: \`5 => \$x\` (no assignment operator \`=\`)
@@ -33,77 +12,6 @@ export const LANGUAGE_REFERENCE = `# rill
 4. Variables lock to first type: \`"hi" => \$x; 42 => \$x\` is an ERROR
 5. Loops cannot modify outer vars: use \`fold\`, \`each(init)\`, or \`\$\` as state dict
 
-## Strengths and Use Cases
-
-Strengths:
-- Unambiguous syntax: \`\$\` prefix, explicit operators, no implicit coercion
-- Single-pass parseable: LLMs generate correct code without symbol tables
-- Readable by humans: pipe chains show data flow left-to-right
-- Safe defaults: immutable values, type locking, no null/undefined
-
-Use cases:
-- Workflow orchestration: chain LLM calls, API requests, transformations
-- State machines: \`(cond) @ { }\` loops with \`\$\` as state dict
-- Data pipelines: \`each\`/\`map\`/\`filter\`/\`fold\` process collections declaratively
-
-State machine pattern (\`\$\` carries state through iterations):
-
-    [state: "init", data: \$input]
-      -> (\$.state != "done") @ {
-        \$.state -> [
-          init: { [state: "process", data: transform(\$.data)] },
-          process: { [state: "done", data: finalize(\$.data)] }
-        ]
-      }
-
-## Naming Convention: snake_case
-
-Use snake_case for all identifiers:
-
-    \$user_name, \$item_list, \$is_valid    # variables
-    \$double_value, \$cleanup_text         # closures
-    [first_name: "x", last_name: "y"]    # dict keys
-
-## Why Variables Use \$ Prefix
-
-The \`\$\` prefix enables single-pass parsing without a symbol table:
-
-    name()    -> host function call
-    \$name()   -> closure invocation
-    \$name     -> variable reference
-    name      -> dict key literal
-
-Without \`\$\`, \`process(data)\` is ambiguous: is \`process\` a host function or stored closure? Is \`data\` a variable or key? This would require tracking all declarations.
-
-## Spacing Rules
-
-    Operators:     space both sides       5 + 3, \$x -> .upper, "a" => \$b
-    Parentheses:   no inner space         (\$x + 1), (\$ > 3) ? "yes"
-    Braces:        space inside           { \$x + 1 }, each { \$ * 2 }
-    Brackets:      no inner space         \$list[0], \$dict.items[1]
-    Literals:      space after , and :    [1, 2, 3], [name: "x", age: 30]
-    Closures:      space after params     |x| (\$x * 2), |a, b| { \$a + \$b }
-    Methods:       no space before . or ( \$str.upper(), \$list.join(", ")
-    Pipes:         space both sides       "x" -> .upper -> .len
-    Continuations: indent 2 spaces        \$data
-                                            -> .filter { \$.active }
-                                            -> map { \$.name }
-
-## Implicit \$ Shorthand (Always Prefer)
-
-    \$.method()  ->  .method            "x" -> .upper  (not \$.upper())
-    func(\$)     ->  func               "x" -> log     (not log(\$))
-    \$fn(\$)      ->  \$fn                5 -> \$double   (not \$double(\$))
-
-Don't capture just to continue — use line continuation instead:
-
-    # avoid                          # good
-    "x" => \$a                        "x"
-    \$a -> .upper => \$b                 -> .upper
-    \$b -> .len                         -> .len
-
-Only capture when the variable is reused later in the code.
-
 ## Critical Differences from Mainstream Languages
 
 ### 1. No Assignment Operator
@@ -117,7 +25,7 @@ Example: \`"hello" => \$x -> .upper => \$y\` — \`\$x="hello"\`, \`\$y="HELLO"\
 
 ### 2. No Null/Undefined
 
-Empty values (\`""\`, \`[]\`, \`[:]\`) exist. "No value" cannot be represented.
+Empty values (\`""\`, \`list[]\`, \`dict[]\`) exist. "No value" cannot be represented.
 Use \`??\` for defaults: \`\$dict.field ?? "default"\`.
 Use \`.empty\` to check: \`\$str -> .empty ? "was empty"\`.
 
@@ -144,28 +52,27 @@ Negation (\`!\`) also requires boolean:
 Child scopes can READ parent variables but cannot WRITE or redeclare them.
 Variables created inside blocks/loops do NOT leak out.
 
-WRONG — outer variable modification (NEVER works):
+WRONG — outer variable modification (runtime error):
 
     0 => \$count
-    [1, 2, 3] -> each { \$count + 1 => \$count }  # creates LOCAL \$count
-    \$count                                       # still 0!
+    list[1, 2, 3] -> each { \$count + 1 => \$count }  # ERROR: Cannot reassign outer variable
 
 RIGHT — use \`fold\` for reduction:
 
-    [1, 2, 3] -> fold(0) { \$@ + \$ }             # 6 (\$@ is accumulator)
+    list[1, 2, 3] -> fold(0) { \$@ + \$ }             # 6 (\$@ is accumulator)
 
 RIGHT — use \`each(init)\` for results AND accumulator:
 
-    [1, 2, 3] -> each(0) { \$@ + \$ }             # [1, 3, 6] (running totals)
+    list[1, 2, 3] -> each(0) { \$@ + \$ }             # list[1, 3, 6] (running totals)
 
 RIGHT — use \`(cond) @ { }\` with \`\$\` as state dict for multiple values:
 
-    [iter: 0, max: 3, text: \$input, done: false]
+    dict[iter: 0, max: 3, text: \$input, done: false]
       -> (!\$.done && \$.iter < \$.max) @ {
         \$.iter + 1 => \$i
         process(\$.text) => \$result
-        \$result.finished ? [iter: \$i, max: \$.max, text: \$.text, done: true]
-                         ! [iter: \$i, max: \$.max, text: \$result.text, done: false]
+        \$result.finished ? dict[iter: \$i, max: \$.max, text: \$.text, done: true]
+                         ! dict[iter: \$i, max: \$.max, text: \$result.text, done: false]
       }
 
 Pattern summary:
@@ -184,28 +91,68 @@ Built-in: \`assert\` (validate condition), \`error\` (halt with message).
 
 All copies are deep. All comparisons are by value. No object identity.
 
-    [1, 2, 3] == [1, 2, 3]   # true (content equality)
-    [1, 2] => \$a
-    \$a => \$b                  # \$b is an independent deep copy
+    list[1, 2, 3] == list[1, 2, 3]   # true (content equality)
+    list[1, 2] => \$a
+    \$a => \$b                          # \$b is an independent deep copy
+
+## Grammar Patterns
+
+rill uses two bracket forms as grammar constructs (not function calls):
+
+**\`keyword[...]\`** — collection literals. Keyword and \`[\` must be adjacent (no space):
+
+    list[1, 2, 3]                       # list
+    dict[name: "alice", age: 30]        # dict (key: value pairs)
+    tuple[1, 2, 3]                      # positional argument unpacking
+    ordered[a: 1, b: 2]                 # named argument unpacking
+
+    list [1, 2]                         # ERROR: RILL-P007 (space before bracket)
+
+**\`keyword<...>\`** — extraction operators. Custom grammar with \`,\` or \`:\` separators:
+
+    list[1, 2, 3] -> destruct<\$a, \$b, \$c>    # destructure into variables
+    list[0,1,2,3] -> slice<1:3>               # slice with start:stop:step
+
+These are NOT function calls. They are parsed as special syntax by the compiler.
+
+## Callable Types
+
+rill has three callable types:
+
+| Type | Source | Examples |
+|------|--------|---------|
+| Closure | Script-defined | \`\\|x\\| { \$x * 2 }\`, \`{ \$ + 1 }\` |
+| Built-in function | Shipped with runtime | \`log\`, \`json\`, \`range\`, \`chain\`, \`error\` |
+| Host function | Registered by host app | \`app::fetch()\`, \`app::prompt()\` |
+
+The \`\$\` prefix disambiguates callables from variables and keys:
+
+    name()    -> built-in or host function call
+    \$name()   -> closure invocation
+    \$name     -> variable reference
+    name      -> dict key literal
+
+Without \`\$\`, \`process(data)\` is ambiguous: is \`process\` a function or stored closure? Is \`data\` a variable or key? This would require tracking all declarations.
 
 ## Syntax Quick Reference
 
     Variables:     \$name (always prefixed with \$)
-    Strings:       "hello {\$var}"          # interpolation with {}
-                   """..."""               # multiline (also interpolates)
+    Strings:       "hello {\$var}"              # interpolation with {}
+                   """..."""                   # multiline (also interpolates)
     Numbers:       42, 3.14, -7
     Booleans:      true, false
-    Lists:         [1, 2, 3]
-                   [...\$list, 4]               # spread: inline list elements
-    Dicts:         [name: "alice", age: 30]    # identifier keys
-                   [1: "one", 2: "two"]        # number keys (incl. negative: [-1: "neg"])
-                   [true: "yes", false: "no"]  # boolean keys
-                   [["a", "b"]: 1]             # multi-key: [a: 1, b: 1]
-                   [\$keyVar: value]            # variable key (must eval to string)
-                   [(\$expr): value]            # computed key (must eval to string)
-    Tuples:        *[1, 2, 3]              # for argument unpacking
-    Closures:      |x|(\$x + 1)             # like lambda/arrow functions
-    Type annot:    "hi" => \$x:string       # lock type on capture
+    Lists:         list[1, 2, 3]
+                   list[...\$list, 4]           # spread: inline list elements
+    Dicts:         dict[name: "alice", age: 30]    # identifier keys
+                   dict[1: "one", 2: "two"]        # number keys (incl. negative: dict[-1: "neg"])
+                   dict[true: "yes", false: "no"]  # boolean keys
+                   dict[list["a", "b"]: 1]         # multi-key: dict[a: 1, b: 1]
+                   dict[\$keyVar: value]             # variable key (must eval to string)
+                   dict[("{\$a}{\$b}"): value]         # computed key (must eval to string)
+    Tuples:        tuple[1, 2, 3]              # positional argument unpacking
+    Ordered:       ordered[a: 1, b: 2]         # named argument unpacking (preserves order)
+    Closures:      |x|(\$x + 1)                 # like lambda/arrow functions
+    Type annot:    "hi" => \$x:string           # lock type on capture
     Comments:      # single line only
 
 ## Pipes and \$ Binding
@@ -231,7 +178,7 @@ Example: \`"hello" -> .upper\` is the same as \`"hello" -> \$.upper()\`.
 Conditional (if-else):
 
     cond ? then_expr ! else_expr
-    cond ? then_expr                    # else returns ""
+    cond ? then_expr                    # else returns null
 
 Piped conditional (\`\$\` becomes condition):
 
@@ -259,11 +206,16 @@ Do-condition loop (body runs at least once):
 
 Break (exits loop, returns collected results before break):
 
-    [1,2,3,4,5] -> each { (\$ == 3) ? break; \$ }  # returns [1, 2]
+    list[1,2,3,4,5] -> each {
+      (\$ == 3) ? break
+      \$
+    }                                                # returns list[1, 2]
 
 Return (exits block or script with value):
 
-    { 5 => \$x; (\$x > 3) ? ("big" -> return); "small" }  # returns "big"
+    5 => \$x
+    (\$x > 3) ? ("big" -> return)
+    "small"                                          # returns "big"
     "done" -> return                                     # exits script with "done"
 
 Assert (validate condition, halt if false, pass through if true):
@@ -283,8 +235,8 @@ Pass (returns \`\$\` unchanged, explicit no-op):
 
     cond ? pass ! "fallback"               # preserve \$ when condition true
     cond ? "value" ! pass                  # preserve \$ when condition false
-    "data" -> { [status: pass] }           # include \$ in dict: [status: "data"]
-    [1, -2, 3] -> map { (\$ > 0) ? pass ! 0 }  # [1, 0, 3]
+    "data" -> { dict[status: pass] }              # include \$ in dict: dict[status: "data"]
+    list[1, -2, 3] -> map { (\$ > 0) ? pass ! 0 }  # list[1, 0, 3]
 
 Note: \`pass\` requires pipe context. Using \`pass\` without \`\$\` throws error.
 
@@ -302,10 +254,10 @@ Note: \`pass\` requires pipe context. Using \`pass\` without \`\$\` throws error
 
 Method shorthand in collection operators:
 
-    ["a", "b"] -> map .upper            # ["A", "B"]
-    ["", "x"] -> filter (!.empty)       # ["x"]
-    ["a", "b"] -> map .pad_start(3, "0") # ["00a", "00b"] (with args)
-    ["  HI  "] -> map .trim.lower       # ["hi"] (chained methods)
+    list["a", "b"] -> map .upper              # list["A", "B"]
+    list["", "x"] -> filter (!.empty)         # list["x"]
+    list["a", "b"] -> map .pad_start(3, "0")  # list["00a", "00b"] (with args)
+    list["  HI  "] -> map .trim.lower         # list["hi"] (chained methods)
 
 Body forms (all operators accept these):
 
@@ -314,17 +266,17 @@ Body forms (all operators accept these):
     -> each |x| (\$x * 2)               # inline closure
     -> each \$double                     # variable closure
     -> each .upper                      # method shorthand
-    -> each log                         # host function
+    -> each log                         # built-in function
 
 Dict iteration (\`\$\` contains \`key\` and \`value\` fields):
 
-    [a: 1, b: 2] -> each { "{\$.key}={\$.value}" }   # ["a=1", "b=2"]
-    [a: 1, b: 5] -> filter { \$.value > 2 }          # entries where value > 2
+    dict[a: 1, b: 2] -> each { "{\$.key}={\$.value}" }   # list["a=1", "b=2"]
+    dict[a: 1, b: 5] -> filter { \$.value > 2 }          # entries where value > 2
 
 String iteration (iterates over characters):
 
-    "abc" -> each { "{\$}!" }            # ["a!", "b!", "c!"]
-    "hello" -> filter { \$ != "l" }      # ["h", "e", "o"]
+    "abc" -> each { "{\$}!" }            # list["a!", "b!", "c!"]
+    "hello" -> filter { \$ != "l" }      # list["h", "e", "o"]
 
 ## Closures
 
@@ -335,8 +287,8 @@ Two ways to create closures:
     { \$ + 1 } => \$inc                  # implicit \$ parameter
     \$inc(5)                            # 6
     5 -> \$inc                          # 6 (pipe invocation)
-    [x: { \$ * 2 }]                     # dict value is closure
-    type({ "hi" })                     # "closure"
+    dict[x: { \$ * 2 }]                # dict value is closure
+    { "hi" }:?closure                  # true
 
 **Explicit closures:** \`|params| body\`
 
@@ -345,6 +297,26 @@ Two ways to create closures:
     |x = 0|(\$x + 1) => \$inc_or_one     # default value
     |x: number|(\$x + 1) => \$typed      # type annotation
 
+**Return type assertions** (enforced at runtime — RILL-R004 on mismatch):
+
+    |x: number| { "{\$x}" }:string => \$fn    # asserts string return type
+    \$fn(42)                                  # "42" (passes assertion)
+
+    |x: number| { \$x * 2 }:string => \$fn    # mismatch halts with RILL-R004
+    \$fn(5)                                   # RILL-R004: expected string, got number
+
+Valid return type targets: string, number, bool, list, dict, any, vector, shape(...), \$shapeVar.
+Declared return type accessible via \$fn.^output annotation.
+
+**Description shorthand** (bare string in \`^(...)\` expands to \`description: <string>\`):
+
+    ^("Get weather for city") |city: string|(\$city) => \$weather
+    \$weather.^description                        # "Get weather for city"
+
+    ^("Fetch profile", cache: true) |id|(\$id) => \$get_user
+    \$get_user.^description                       # "Fetch profile"
+    \$get_user.^cache                             # true
+
 \`{ body }\` vs \`( expr )\` distinction:
 
 | Syntax | Semantics | Example |
@@ -361,7 +333,7 @@ LATE BINDING: closures capture scope, not values. Variables resolve at call time
 
 Zero-param dict closures (methods):
 
-    [count: 3, double: ||{ \$.count * 2 }] => \$obj
+    dict[count: 3, double: ||{ \$.count * 2 }] => \$obj
     \$obj.double                         # 6 (\$ is bound to dict)
 
 ## Property Access
@@ -383,29 +355,33 @@ Zero-param dict closures (methods):
 
 **Dict dispatch** (single key) — pipe a value to a dict to match keys:
 
-    \$val -> [apple: "fruit", carrot: "veg"]        # "fruit" if \$val is "apple"
-    \$val -> [apple: "fruit"] ?? "not found"         # default if no match
-    \$method -> [["GET", "HEAD"]: "safe", ["POST", "PUT"]: "unsafe"]  # multi-key
+    \$val -> dict[apple: "fruit", carrot: "veg"]                              # "fruit" if \$val is "apple"
+    \$val -> dict[apple: "fruit"] ?? "not found"                              # default if no match
+    \$method -> dict[list["GET", "HEAD"]: "safe", list["POST", "PUT"]: "unsafe"]  # multi-key
 
 Type-aware matching (keys matched by value AND type):
 
-    1 -> [1: "number", "1": "string"]              # "number"
-    "1" -> [1: "number", "1": "string"]            # "string"
-    true -> [true: "bool", "true": "str"]          # "bool"
+    1 -> dict[1: "number", "1": "string"]              # "number"
+    "1" -> dict[1: "number", "1": "string"]            # "string"
+    true -> dict[true: "bool", "true": "str"]          # "bool"
 
 **List dispatch** (index) — pipe a number to a list:
 
-    0 -> ["first", "second"]                        # "first"
-    -1 -> ["first", "second"]                       # "second" (last)
-    5 -> ["a", "b"] ?? "not found"                  # default if out of bounds
+    0 -> list["first", "second"]                        # "first"
+    -1 -> list["first", "second"]                       # "second" (last)
+    5 -> list["a", "b"] ?? "not found"                  # default if out of bounds
 
 **Hierarchical dispatch** (path navigation) — pipe a list of keys/indexes:
 
-    ["name", "first"] -> [name: [first: "Alice"]]   # "Alice"
-    [0, 1] -> [[1, 2, 3], [4, 5, 6]]                # 2
-    ["users", 0, "name"] -> [users: [[name: "Alice"]]] # "Alice"
-    [] -> [a: 1]                                    # [a: 1] (empty path = unchanged)
-    ["a", "missing"] -> [a: [x: 1]] ?? "default"    # "default"
+    list["name", "first"] -> dict[name: dict[first: "Alice"]]              # "Alice"
+    list[0, 1] -> list[list[1, 2, 3], list[4, 5, 6]]                      # 2
+    list[] -> dict[a: 1]                                                    # dict[a: 1] (empty path = unchanged)
+    list["a", "missing"] -> dict[a: dict[x: 1]] ?? "default"              # "default"
+
+Note: lists require same-type elements. For mixed paths (strings and numbers), use property access:
+
+    dict[users: list[dict[name: "Alice"]]] => \$d
+    \$d.users[0].name                                                       # "Alice"
 
 ## Type Operations
 
@@ -437,39 +413,31 @@ Use parentheses to override: \`(2 + 3) * 4\`
 
 ## Extraction Operators
 
-Destructure (\`*<>\`):
+Destructure (\`destruct<>\`):
 
-    [1, 2, 3] -> *<\$a, \$b, \$c>          # \$a=1, \$b=2, \$c=3
-    [x: 1, y: 2] -> *<x: \$a, y: \$b>     # \$a=1, \$b=2
-    [1, 2, 3] -> *<\$first, _, \$third>   # _ skips element
+    list[1, 2, 3] -> destruct<\$a, \$b, \$c>          # \$a=1, \$b=2, \$c=3
+    dict[x: 1, y: 2] -> destruct<x: \$a, y: \$b>     # \$a=1, \$b=2
+    list[1, 2, 3] -> destruct<\$first, _, \$third>    # _ skips element
 
-Slice (\`/<start:stop:step>\`):
+Slice (\`slice<start:stop:step>\`):
 
-    [0,1,2,3,4] -> /<1:3>               # [1, 2]
-    [0,1,2,3,4] -> /<-2:>               # [3, 4]
-    [0,1,2,3,4] -> /<::-1>              # [4,3,2,1,0] (reverse)
-    "hello" -> /<1:4>                   # "ell"
+    list[0,1,2,3,4] -> slice<1:3>               # list[1, 2]
+    list[0,1,2,3,4] -> slice<-2:>               # list[3, 4]
+    list[0,1,2,3,4] -> slice<::-1>              # list[4,3,2,1,0] (reverse)
+    "hello" -> slice<1:4>                       # "ell"
 
 ## List Spread in Literals
 
-Inline list elements into a new list using \`...\` (spread operator):
-
-    [1, 2] => \$a
-    [...\$a, 3]                          # [1, 2, 3]
-    [...\$a, ...\$b]                      # concatenate lists
-    [...(\$nums -> map {\$ * 2})]         # spread expression result
-
-## Tuples for Argument Unpacking
-
-    *[1, 2, 3] -> \$fn()                   # positional: \$fn(1, 2, 3)
-    *[b: 2, a: 1] -> \$fn()                # named: \$fn(a=1, b=2)
-    *[...\$list, 3] -> \$fn()               # spread in tuple: combines elements
+    list[1, 2] => \$a
+    list[...\$a, 3]                      # list[1, 2, 3]
+    list[...\$a, ...\$b]                  # concatenate lists
+    list[...(\$nums -> map {\$ * 2})]     # spread expression result
 
-## Closure Chain (@)
+## Tuples and Ordered for Argument Unpacking
 
-Chains closures sequentially (each receives previous result):
-
-    5 -> @[\$inc, \$double, \$add10]       # (5+1)*2+10 = 22
+    tuple[1, 2, 3] -> \$fn(...)             # positional spread: \$fn(1, 2, 3)
+    ordered[a: 10, b: 2] -> \$fn(...)       # named spread: keys must match parameter order
+    tuple[...\$list, 3] -> \$fn(...)         # spread in tuple then spread into call
 
 ## String Methods
 
@@ -511,33 +479,33 @@ Chains closures sequentially (each receives previous result):
 | \`.at(i)\` | element at index |
 | \`.keys\` | dict keys as list |
 | \`.values\` | dict values as list |
-| \`.entries\` | dict as list of [k, v] tuples |
+| \`.entries\` | dict as list of \`tuple[k, v]\` pairs |
 | \`.has(val)\` | list contains value (deep equality) |
 | \`.has_any(list)\` | list contains any value from candidates |
 | \`.has_all(list)\` | list contains all values from candidates |
 
-## Global Functions
+## Built-in Functions
 
 | Function | Description |
 |---|---|
-| \`type(val)\` | returns type name |
 | \`log(val)\` | print and pass through |
 | \`json(val)\` | convert to JSON string |
 | \`identity(val)\` | returns input unchanged |
 | \`range(start, end, step?)\` | number sequence (iterator) |
 | \`repeat(val, count)\` | repeat value n times (iterator) |
-| \`enumerate(coll)\` | lists: [index, value]; dicts: [index, key, value] |
+| \`enumerate(coll)\` | lists: \`tuple[index, value]\`; dicts: \`tuple[index, key, value]\` |
+| \`chain(\$fn)\` | apply single closure; chain(val, list[\$f, \$g]) applies in sequence |
 
 ## Iterators
 
 Lazy sequence generation. Collection operators auto-expand iterators.
 
-    range(0, 5) -> each { \$ * 2 }        # [0, 2, 4, 6, 8]
-    repeat("x", 3) -> each { \$ }         # ["x", "x", "x"]
+    range(0, 5) -> each { \$ * 2 }        # list[0, 2, 4, 6, 8]
+    repeat("x", 3) -> each { \$ }         # list["x", "x", "x"]
 
 \`.first()\` method (returns iterator for any collection):
 
-    [1, 2, 3] -> .first()                # iterator at 1
+    list[1, 2, 3] -> .first()            # iterator at 1
     "abc" -> .first()                     # iterator at "a"
 
 Iterator protocol (dict with \`value\`, \`done\`, \`next\`):
@@ -549,10 +517,13 @@ Iterator protocol (dict with \`value\`, \`done\`, \`next\`):
 ## Iteration Limits
 
 Default: 10,000 iterations max for loops.
-Override: \`^(limit: N)\` statement.
+Override: \`^(limit: N)\` at operator level (between operator name and body).
+
+    0 -> (\$ < 50) @ ^(limit: 100) { \$ + 1 }         # while loop
+    \$items -> each ^(limit: 1000) { process(\$) }     # each operator
+    \$items -> map ^(limit: 3) { slow_process(\$) }    # concurrency limit
 
-    ^(limit: 100) 0 -> (\$ < 50) @ { \$ + 1 }
-    ^(limit: 3) \$items -> map { slow_process(\$) }  # concurrency limit
+Invalid annotation keys produce a runtime error.
 
 ## Script Return Values
 
@@ -560,7 +531,45 @@ Override: \`^(limit: N)\` statement.
 |---|---|
 | \`true\` / non-empty string | 0 |
 | \`false\` / empty string | 1 |
-| \`[0, "message"]\` | 0 with message |
-| \`[1, "message"]\` | 1 with message |
+| \`list[0, "message"]\` | 0 with message |
+| \`list[1, "message"]\` | 1 with message |
+
+## Style
+
+### Naming: snake_case
+
+    \$user_name, \$item_list, \$is_valid             # variables
+    \$double_value, \$cleanup_text                  # closures
+    dict[first_name: "x", last_name: "y"]         # dict keys
+
+### Spacing
+
+    Operators:     space both sides       5 + 3, \$x -> .upper, "a" => \$b
+    Parentheses:   no inner space         (\$x + 1), (\$ > 3) ? "yes"
+    Braces:        space inside           { \$x + 1 }, each { \$ * 2 }
+    Brackets:      no inner space         \$list[0], \$dict.items[1]
+    Literals:      space after , and :    list[1, 2, 3], dict[name: "x", age: 30]
+    Keyword+[      NO space between       list[1, 2] (not list [1, 2] — RILL-P007)
+    Closures:      space after params     |x| (\$x * 2), |a, b| { \$a + \$b }
+    Methods:       no space before . or ( \$str.upper(), \$list.join(", ")
+    Pipes:         space both sides       "x" -> .upper -> .len
+    Continuations: indent 2 spaces        \$data
+                                            -> .filter { \$.active }
+                                            -> map { \$.name }
+
+### Implicit \$ Shorthand (Always Prefer)
+
+    \$.method()  ->  .method            "x" -> .upper  (not \$.upper())
+    func(\$)     ->  func               "x" -> log     (not log(\$))
+    \$fn(\$)      ->  \$fn                5 -> \$double   (not \$double(\$))
+
+Don't capture just to continue — use line continuation instead:
+
+    # avoid                          # good
+    "x" => \$a                        "x"
+    \$a -> .upper => \$b                 -> .upper
+    \$b -> .len                         -> .len
+
+Only capture when the variable is reused later in the code.
 `;
 //# sourceMappingURL=introspection-data.js.map

package/dist/generated/introspection-data.js.map

@@ -1 +1 @@
-{"version":3,"file":"introspection-data.js","sourceRoot":"","sources":["../../src/generated/introspection-data.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,mFAAmF;AAEnF,MAAM,CAAC,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkjBjC,CAAC"}
+{"version":3,"file":"introspection-data.js","sourceRoot":"","sources":["../../src/generated/introspection-data.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,mFAAmF;AAEnF,MAAM,CAAC,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2jBjC,CAAC"}

package/dist/generated/version-data.d.ts

@@ -10,7 +10,7 @@ export interface VersionInfo {
 /**
  * Version string from package.json
  */
-export declare const VERSION = "0.8.6";
+export declare const VERSION = "0.10.0";
 /**
  * Parsed version components
  */

package/dist/generated/version-data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"version-data.d.ts","sourceRoot":"","sources":["../../src/generated/version-data.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;CACzC;AAED;;GAEG;AACH,eAAO,MAAM,OAAO,UAAU,CAAC;AAE/B;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,WAK1B,CAAC"}
+{"version":3,"file":"version-data.d.ts","sourceRoot":"","sources":["../../src/generated/version-data.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;CACzC;AAED;;GAEG;AACH,eAAO,MAAM,OAAO,WAAW,CAAC;AAEhC;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,WAK1B,CAAC"}

package/dist/generated/version-data.js

@@ -3,14 +3,14 @@
 /**
  * Version string from package.json
  */
-export const VERSION = '0.8.6';
+export const VERSION = '0.10.0';
 /**
  * Parsed version components
  */
 export const VERSION_INFO = {
     major: 0,
-    minor: 8,
-    patch: 6,
+    minor: 10,
+    patch: 0,
     prerelease: undefined,
 };
 //# sourceMappingURL=version-data.js.map

package/dist/generated/version-data.js.map

@@ -1 +1 @@
-{"version":3,"file":"version-data.js","sourceRoot":"","sources":["../../src/generated/version-data.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,2EAA2E;AAY3E;;GAEG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,OAAO,CAAC;AAE/B;;GAEG;AACH,MAAM,CAAC,MAAM,YAAY,GAAgB;IACvC,KAAK,EAAE,CAAC;IACR,KAAK,EAAE,CAAC;IACR,KAAK,EAAE,CAAC;IACR,UAAU,EAAE,SAAS;CACtB,CAAC"}
+{"version":3,"file":"version-data.js","sourceRoot":"","sources":["../../src/generated/version-data.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,2EAA2E;AAY3E;;GAEG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,QAAQ,CAAC;AAEhC;;GAEG;AACH,MAAM,CAAC,MAAM,YAAY,GAAgB;IACvC,KAAK,EAAE,CAAC;IACR,KAAK,EAAE,EAAE;IACT,KAAK,EAAE,CAAC;IACR,UAAU,EAAE,SAAS;CACtB,CAAC"}

package/dist/highlight-map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"highlight-map.d.ts","sourceRoot":"","sources":["../src/highlight-map.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAM5C,MAAM,MAAM,iBAAiB,GACzB,SAAS,GACT,UAAU,GACV,QAAQ,GACR,QAAQ,GACR,MAAM,GACN,SAAS,GACT,cAAc,GACd,aAAa,GACb,SAAS,GACT,MAAM,CAAC;AAMX,eAAO,MAAM,mBAAmB,EAAE,WAAW,CAAC,SAAS,EAAE,iBAAiB,CA2EtE,CAAC"}
+{"version":3,"file":"highlight-map.d.ts","sourceRoot":"","sources":["../src/highlight-map.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAM5C,MAAM,MAAM,iBAAiB,GACzB,SAAS,GACT,UAAU,GACV,QAAQ,GACR,QAAQ,GACR,MAAM,GACN,SAAS,GACT,cAAc,GACd,aAAa,GACb,SAAS,GACT,MAAM,CAAC;AAMX,eAAO,MAAM,mBAAmB,EAAE,WAAW,CAAC,SAAS,EAAE,iBAAiB,CAkFtE,CAAC"}

package/dist/highlight-map.js

@@ -9,6 +9,13 @@ export const TOKEN_HIGHLIGHT_MAP = new Map([
     ['FALSE', 'bool'],
     // Comments
     ['COMMENT', 'comment'],
+    // Compound keywords
+    ['LIST_LBRACKET', 'keyword'],
+    ['DICT_LBRACKET', 'keyword'],
+    ['TUPLE_LBRACKET', 'keyword'],
+    ['ORDERED_LBRACKET', 'keyword'],
+    ['DESTRUCT_LANGLE', 'keyword'],
+    ['SLICE_LANGLE', 'keyword'],
     // Keywords
     ['EACH', 'keyword'],
     ['MAP', 'keyword'],
@@ -45,9 +52,8 @@ export const TOKEN_HIGHLIGHT_MAP = new Map([
     ['BANG', 'operator'],
     ['NULLISH_COALESCE', 'operator'],
     ['DOT_QUESTION', 'operator'],
-    ['STAR_LT', 'operator'],
-    ['SLASH_LT', 'operator'],
     ['ELLIPSIS', 'operator'],
+    ['CONVERT', 'operator'],
     ['AT', 'operator'],
     ['CARET', 'operator'],
     ['AMPERSAND', 'operator'],