@rcrsr/rill 0.1.0

package/dist/runtime/core/evaluate.js

@@ -0,0 +1,1913 @@
+/**
+ * Expression Evaluation
+ *
+ * Internal module for AST evaluation. Not part of public API.
+ * All evaluation functions are internal implementation details.
+ *
+ * @internal
+ */
+import { AbortError, AutoExceptionError, RILL_ERROR_CODES, RuntimeError, TimeoutError, } from '../../types.js';
+import { isCallable, isDict, isScriptCallable } from './callable.js';
+import { createChildContext, getVariable, hasVariable } from './context.js';
+import { BreakSignal, ReturnSignal } from './signals.js';
+import { checkType, createTupleFromDict, createTupleFromList, deepEquals, formatValue, inferType, isRillIterator, isTuple, isReservedMethod, isTruthy, } from './values.js';
+// ============================================================
+// CONSTANTS
+// ============================================================
+/** Default maximum iterations when no limit annotation is set */
+const DEFAULT_MAX_ITERATIONS = 10000;
+// ============================================================
+// EXPORTED HELPERS (used by execute.ts)
+// ============================================================
+/** Helper to get location from an AST node */
+function getNodeLocation(node) {
+    return node?.span.start;
+}
+/**
+ * Check if execution has been aborted via AbortSignal.
+ * Throws AbortError if signal is aborted.
+ */
+export function checkAborted(ctx, node) {
+    if (ctx.signal?.aborted) {
+        throw new AbortError(getNodeLocation(node));
+    }
+}
+/**
+ * Check if the current pipe value matches any autoException pattern.
+ * Only checks string values. Throws AutoExceptionError on match.
+ */
+export function checkAutoExceptions(value, ctx, node) {
+    if (typeof value !== 'string' || ctx.autoExceptions.length === 0) {
+        return;
+    }
+    for (const pattern of ctx.autoExceptions) {
+        if (pattern.test(value)) {
+            throw new AutoExceptionError(pattern.source, value, getNodeLocation(node));
+        }
+    }
+}
+/**
+ * Handle statement capture: set variable and fire observability event.
+ * Returns capture info if a capture occurred.
+ */
+export function handleCapture(capture, value, ctx) {
+    if (!capture)
+        return undefined;
+    setVariable(ctx, capture.name, value, capture.typeName, capture.span.start);
+    const captureInfo = { name: capture.name, value };
+    ctx.observability.onCapture?.(captureInfo);
+    return captureInfo;
+}
+// ============================================================
+// TYPE ASSERTION HELPERS
+// ============================================================
+/**
+ * Assert that a value is of the expected type.
+ * Returns the value unchanged if assertion passes, throws on mismatch.
+ * Exported for use by type assertion evaluation.
+ */
+export function assertType(value, expected, location) {
+    const actual = inferType(value);
+    if (actual !== expected) {
+        throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Type assertion failed: expected ${expected}, got ${actual}`, location, { expectedType: expected, actualType: actual });
+    }
+    return value;
+}
+// ============================================================
+// VARIABLE MANAGEMENT
+// ============================================================
+/**
+ * Set a variable with type checking.
+ * - First assignment locks the type (inferred or explicit)
+ * - Subsequent assignments must match the locked type
+ * - Explicit type annotation is validated against value type
+ * - Cannot shadow outer scope variables (produces error)
+ */
+function setVariable(ctx, name, value, explicitType, location) {
+    const valueType = inferType(value);
+    // Check explicit type annotation matches value
+    if (explicitType !== null && explicitType !== valueType) {
+        throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Type mismatch: cannot assign ${valueType} to $${name}:${explicitType}`, location, { variableName: name, expectedType: explicitType, actualType: valueType });
+    }
+    // Check if this is a new variable that would reassign an outer scope variable
+    // (error: cannot reassign outer scope variables from child scopes)
+    if (!ctx.variables.has(name) && ctx.parent && hasVariable(ctx.parent, name)) {
+        throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Cannot reassign outer variable $${name} from child scope`, location, { variableName: name });
+    }
+    // Check if variable already has a locked type in current scope
+    const lockedType = ctx.variableTypes.get(name);
+    if (lockedType !== undefined && lockedType !== valueType) {
+        throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Type mismatch: cannot assign ${valueType} to $${name} (locked as ${lockedType})`, location, { variableName: name, expectedType: lockedType, actualType: valueType });
+    }
+    // Set the variable and lock its type in current scope
+    ctx.variables.set(name, value);
+    if (!ctx.variableTypes.has(name)) {
+        ctx.variableTypes.set(name, explicitType ?? valueType);
+    }
+}
+// ============================================================
+// TIMEOUT WRAPPER
+// ============================================================
+/**
+ * Wrap a promise with a timeout. Returns original promise if no timeout configured.
+ */
+function withTimeout(promise, timeoutMs, functionName, node) {
+    if (timeoutMs === undefined) {
+        return promise;
+    }
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => {
+            setTimeout(() => {
+                reject(new TimeoutError(functionName, timeoutMs, getNodeLocation(node)));
+            }, timeoutMs);
+        }),
+    ]);
+}
+// ============================================================
+// EXPRESSION EVALUATION
+// ============================================================
+/**
+ * Evaluate argument expressions while preserving the current pipeValue.
+ */
+async function evaluateArgs(argExprs, ctx) {
+    const savedPipeValue = ctx.pipeValue;
+    const args = [];
+    for (const arg of argExprs) {
+        args.push(await evaluateExpression(arg, ctx));
+    }
+    ctx.pipeValue = savedPipeValue;
+    return args;
+}
+export async function evaluateExpression(expr, ctx) {
+    return evaluatePipeChain(expr, ctx);
+}
+async function evaluatePipeChain(chain, ctx) {
+    // Save parent's $ - chains don't leak $ modifications to parent scope
+    const savedPipeValue = ctx.pipeValue;
+    // Evaluate head (can be PostfixExpr, BinaryExpr, or UnaryExpr)
+    let value;
+    switch (chain.head.type) {
+        case 'BinaryExpr':
+            value = await evaluateBinaryExpr(chain.head, ctx);
+            break;
+        case 'UnaryExpr':
+            value = await evaluateUnaryExpr(chain.head, ctx);
+            break;
+        case 'PostfixExpr':
+            value = await evaluatePostfixExpr(chain.head, ctx);
+            break;
+    }
+    ctx.pipeValue = value; // OK: local to this chain evaluation
+    for (const target of chain.pipes) {
+        value = await evaluatePipeTarget(target, value, ctx);
+        ctx.pipeValue = value; // OK: flows within chain
+    }
+    // Handle chain terminator (capture, break, return)
+    if (chain.terminator) {
+        if (chain.terminator.type === 'Break') {
+            // Restore parent's $ before throwing (cleanup)
+            ctx.pipeValue = savedPipeValue;
+            throw new BreakSignal(value);
+        }
+        if (chain.terminator.type === 'Return') {
+            // Restore parent's $ before throwing (cleanup)
+            ctx.pipeValue = savedPipeValue;
+            throw new ReturnSignal(value);
+        }
+        // Capture
+        handleCapture(chain.terminator, value, ctx);
+    }
+    // Restore parent's $ - chain result is returned, but $ doesn't leak
+    ctx.pipeValue = savedPipeValue;
+    return value;
+}
+async function evaluatePostfixExpr(expr, ctx) {
+    let value = await evaluatePrimary(expr.primary, ctx);
+    for (const method of expr.methods) {
+        value = await evaluateMethod(method, value, ctx);
+    }
+    return value;
+}
+async function evaluatePrimary(primary, ctx) {
+    switch (primary.type) {
+        case 'StringLiteral':
+            return evaluateString(primary, ctx);
+        case 'NumberLiteral':
+            return primary.value;
+        case 'BoolLiteral':
+            return primary.value;
+        case 'Tuple':
+            return evaluateTuple(primary, ctx);
+        case 'Dict':
+            return evaluateDict(primary, ctx);
+        case 'Closure':
+            return await createClosure(primary, ctx);
+        case 'Variable':
+            return evaluateVariableAsync(primary, ctx);
+        case 'HostCall':
+            return evaluateHostCall(primary, ctx);
+        case 'ClosureCall':
+            return evaluateClosureCall(primary, ctx);
+        case 'MethodCall':
+            if (ctx.pipeValue === null) {
+                throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_UNDEFINED_VARIABLE, 'Undefined variable: $', primary.span?.start, { variable: '$' });
+            }
+            return evaluateMethod(primary, ctx.pipeValue, ctx);
+        case 'Conditional':
+            return evaluateConditional(primary, ctx);
+        case 'WhileLoop':
+            return evaluateWhileLoop(primary, ctx);
+        case 'DoWhileLoop':
+            return evaluateDoWhileLoop(primary, ctx);
+        case 'Block':
+            return evaluateBlockExpression(primary, ctx);
+        case 'GroupedExpr':
+            return evaluateGroupedExpr(primary, ctx);
+        case 'Spread':
+            return evaluateSpread(primary, ctx);
+        case 'TypeAssertion':
+            return evaluateTypeAssertionPrimary(primary, ctx);
+        case 'TypeCheck':
+            return evaluateTypeCheckPrimary(primary, ctx);
+        default:
+            throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Unknown primary type: ${primary.type}`, getNodeLocation(primary));
+    }
+}
+/**
+ * Evaluate postfix type assertion: expr:type
+ * The operand is always present (not null) for postfix form.
+ */
+async function evaluateTypeAssertionPrimary(node, ctx) {
+    if (!node.operand) {
+        throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, 'Postfix type assertion requires operand', node.span.start);
+    }
+    const value = await evaluatePostfixExpr(node.operand, ctx);
+    return evaluateTypeAssertion(node, value, ctx);
+}
+/**
+ * Evaluate postfix type check: expr:?type
+ * The operand is always present (not null) for postfix form.
+ */
+async function evaluateTypeCheckPrimary(node, ctx) {
+    if (!node.operand) {
+        throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, 'Postfix type check requires operand', node.span.start);
+    }
+    const value = await evaluatePostfixExpr(node.operand, ctx);
+    return evaluateTypeCheck(node, value, ctx);
+}
+async function evaluatePipeTarget(target, input, ctx) {
+    ctx.pipeValue = input;
+    switch (target.type) {
+        case 'Capture':
+            return evaluateCapture(target, input, ctx);
+        case 'HostCall':
+            return evaluateHostCall(target, ctx);
+        case 'ClosureCall':
+            return evaluateClosureCallWithPipe(target, input, ctx);
+        case 'PipeInvoke':
+            return evaluatePipeInvoke(target, input, ctx);
+        case 'MethodCall':
+            return evaluateMethod(target, input, ctx);
+        case 'Conditional':
+            return evaluateConditional(target, ctx);
+        case 'WhileLoop':
+            return evaluateWhileLoop(target, ctx);
+        case 'DoWhileLoop':
+            return evaluateDoWhileLoop(target, ctx);
+        case 'Block':
+            return evaluateBlockExpression(target, ctx);
+        case 'StringLiteral':
+            return evaluateString(target, ctx);
+        case 'GroupedExpr':
+            return evaluateGroupedExpr(target, ctx);
+        case 'ClosureChain':
+            return evaluateClosureChain(target, input, ctx);
+        case 'Destructure':
+            return evaluateDestructure(target, input, ctx);
+        case 'Slice':
+            return evaluateSlice(target, input, ctx);
+        case 'Spread':
+            return evaluateSpread(target, ctx);
+        case 'TypeAssertion':
+            return evaluateTypeAssertion(target, input, ctx);
+        case 'TypeCheck':
+            return evaluateTypeCheck(target, input, ctx);
+        case 'EachExpr':
+            return evaluateEach(target, input, ctx);
+        case 'MapExpr':
+            return evaluateMap(target, input, ctx);
+        case 'FoldExpr':
+            return evaluateFold(target, input, ctx);
+        case 'FilterExpr':
+            return evaluateFilter(target, input, ctx);
+        case 'Variable':
+            // $.field is property access on pipe value, not closure invocation
+            if (target.isPipeVar && !target.name && target.accessChain.length > 0) {
+                return evaluatePipePropertyAccess(target, input, ctx);
+            }
+            return evaluateVariableInvoke(target, input, ctx);
+        case 'PostfixExpr': {
+            // Chained methods on pipe value: -> .a.b.c
+            let value = input;
+            for (const method of target.methods) {
+                value = await evaluateMethod(method, value, ctx);
+            }
+            return value;
+        }
+        default:
+            throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Unknown pipe target type: ${target.type}`, getNodeLocation(target));
+    }
+}
+// ============================================================
+// STATEMENT EXECUTION
+// ============================================================
+export async function executeStatement(stmt, ctx) {
+    // Handle annotated statements
+    if (stmt.type === 'AnnotatedStatement') {
+        return executeAnnotatedStatement(stmt, ctx);
+    }
+    const value = await evaluateExpression(stmt.expression, ctx);
+    // Note: Do NOT set ctx.pipeValue = value here.
+    // Statements don't propagate $ to siblings. $ flows only via explicit ->.
+    checkAutoExceptions(value, ctx, stmt);
+    // Terminator handling is now inside PipeChainNode evaluation
+    // (evaluatePipeChain handles capture/break/return terminators)
+    return value;
+}
+/**
+ * Execute an annotated statement.
+ * Evaluates annotations, pushes them to the stack, executes the inner statement,
+ * and pops the annotations.
+ */
+async function executeAnnotatedStatement(stmt, ctx) {
+    // Evaluate annotation arguments to build annotation dict
+    const newAnnotations = await evaluateAnnotations(stmt.annotations, ctx);
+    // Merge with inherited annotations (inner overrides outer)
+    const inherited = ctx.annotationStack.at(-1) ?? {};
+    const merged = { ...inherited, ...newAnnotations };
+    // Push merged annotations, execute inner statement, pop
+    ctx.annotationStack.push(merged);
+    try {
+        return await executeStatement(stmt.statement, ctx);
+    }
+    finally {
+        ctx.annotationStack.pop();
+    }
+}
+/**
+ * Evaluate annotation arguments to a dict of key-value pairs.
+ */
+async function evaluateAnnotations(annotations, ctx) {
+    const result = {};
+    for (const arg of annotations) {
+        if (arg.type === 'NamedArg') {
+            result[arg.name] = await evaluateExpression(arg.value, ctx);
+        }
+        else {
+            // SpreadArg: spread tuple/dict keys as annotations
+            const spreadValue = await evaluateExpression(arg.expression, ctx);
+            if (typeof spreadValue === 'object' &&
+                spreadValue !== null &&
+                !Array.isArray(spreadValue) &&
+                !isCallable(spreadValue)) {
+                // Dict: spread all key-value pairs
+                Object.assign(result, spreadValue);
+            }
+            else if (Array.isArray(spreadValue)) {
+                // Tuple/list: not valid for annotations (need named keys)
+                throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, 'Annotation spread requires dict with named keys, got list', arg.span.start);
+            }
+            else {
+                throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Annotation spread requires dict, got ${typeof spreadValue}`, arg.span.start);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Get the current value of an annotation from the annotation stack.
+ */
+export function getAnnotation(ctx, key) {
+    return ctx.annotationStack.at(-1)?.[key];
+}
+/**
+ * Get the iteration limit for loops from the `limit` annotation.
+ * Returns the default if not set or if the value is not a positive number.
+ */
+function getIterationLimit(ctx) {
+    const limit = getAnnotation(ctx, 'limit');
+    if (typeof limit === 'number' && limit > 0) {
+        return Math.floor(limit);
+    }
+    return DEFAULT_MAX_ITERATIONS;
+}
+async function evaluateClosureChain(node, input, ctx) {
+    const target = await evaluateExpression(node.target, ctx);
+    const closures = Array.isArray(target) ? target : [target];
+    let accumulated = input;
+    for (const closure of closures) {
+        accumulated = await invokeAsCallableOrFunction(closure, [accumulated], ctx, node.span.start);
+    }
+    return accumulated;
+}
+// ============================================================
+// COLLECTION OPERATORS (each, map, fold)
+// ============================================================
+/**
+ * Get iterable elements from input value.
+ * Returns array of elements to iterate over.
+ * For dicts, returns array of { key, value } objects.
+ */
+/**
+ * Check if a value is a rill iterator (dict with value, done, next fields).
+ * Iterators follow the protocol: { value: any, done: bool, next: closure }
+ */
+/**
+ * Expand a rill iterator into an array of elements.
+ * Respects iteration limits to prevent infinite loops.
+ */
+async function expandIterator(iterator, ctx, node, limit = 10000) {
+    const elements = [];
+    let current = iterator;
+    let count = 0;
+    while (!current['done'] && count < limit) {
+        checkAborted(ctx, undefined);
+        const val = current['value'];
+        if (val !== undefined) {
+            elements.push(val);
+        }
+        count++;
+        // Invoke next() to get the next iterator
+        const nextClosure = current['next'];
+        if (nextClosure === undefined || !isCallable(nextClosure)) {
+            throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, 'Iterator .next must be a closure', node.span.start);
+        }
+        const nextIterator = await invokeCallable(nextClosure, [], ctx, node.span.start);
+        if (!isRillIterator(nextIterator)) {
+            throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, 'Iterator .next must return an iterator', node.span.start);
+        }
+        current = nextIterator;
+    }
+    if (count >= limit && !current['done']) {
+        throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Iterator exceeded ${limit} elements (use ^(limit: N) to increase)`, node.span.start);
+    }
+    return elements;
+}
+async function getIterableElements(input, ctx, node) {
+    if (Array.isArray(input)) {
+        return input;
+    }
+    if (typeof input === 'string') {
+        return [...input];
+    }
+    // Check for iterator protocol BEFORE generic dict handling
+    if (isRillIterator(input)) {
+        return expandIterator(input, ctx, node);
+    }
+    if (isDict(input)) {
+        // Dict iteration: sorted keys, each element is { key, value }
+        const keys = Object.keys(input).sort();
+        return keys.map((key) => ({
+            key,
+            value: input[key],
+        }));
+    }
+    throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Collection operators require list, string, dict, or iterator, got ${inferType(input)}`, node.span.start);
+}
+/**
+ * Evaluate collection body for a single element.
+ * Handles all body forms: closure, block, grouped, variable, postfix, spread.
+ */
+async function evaluateIteratorBody(body, element, accumulator, ctx) {
+    switch (body.type) {
+        case 'Closure': {
+            // Inline closure: invoke with element (and accumulator if present in params)
+            const closure = await createClosure(body, ctx);
+            const args = [element];
+            // Accumulator is passed as second arg if closure has 2+ params
+            if (accumulator !== null && closure.params.length >= 2) {
+                args.push(accumulator);
+            }
+            // Create context with $@ for closures that use it (e.g., |x| { $x + $@ })
+            let invokeCtx = ctx;
+            let closureToInvoke = closure;
+            if (accumulator !== null) {
+                invokeCtx = createChildContext(ctx);
+                invokeCtx.variables.set('@', accumulator);
+                // Create new closure with updated definingScope to include $@
+                closureToInvoke = { ...closure, definingScope: invokeCtx };
+            }
+            return invokeCallable(closureToInvoke, args, invokeCtx, body.span.start);
+        }
+        case 'Block': {
+            // Block: evaluate with $ = element, $@ = accumulator
+            const blockCtx = createChildContext(ctx);
+            blockCtx.pipeValue = element;
+            if (accumulator !== null) {
+                blockCtx.variables.set('@', accumulator);
+            }
+            return evaluateBlockExpression(body, blockCtx);
+        }
+        case 'GroupedExpr': {
+            // Grouped: evaluate with $ = element, $@ = accumulator (for fold)
+            const groupedCtx = createChildContext(ctx);
+            groupedCtx.pipeValue = element;
+            if (accumulator !== null) {
+                groupedCtx.variables.set('@', accumulator);
+            }
+            return evaluateGroupedExpr(body, groupedCtx);
+        }
+        case 'Variable': {
+            // Bare $ = identity, return element unchanged
+            if (body.isPipeVar && !body.name && body.accessChain.length === 0) {
+                return element;
+            }
+            // $[idx] or $.field - evaluate access chain on current element
+            if (body.isPipeVar && body.accessChain.length > 0) {
+                const bodyCtx = createChildContext(ctx);
+                bodyCtx.pipeValue = element;
+                return evaluateVariableAsync(body, bodyCtx);
+            }
+            // Variable closure: get closure and invoke with element
+            const varValue = getVariable(ctx, body.name ?? '');
+            if (!varValue) {
+                throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_UNDEFINED_VARIABLE, `Undefined variable: $${body.name}`, body.span.start);
+            }
+            if (!isCallable(varValue)) {
+                throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Collection body variable must be callable, got ${inferType(varValue)}`, body.span.start);
+            }
+            const args = [element];
+            if (accumulator !== null &&
+                varValue.kind === 'script' &&
+                varValue.params.length >= 2) {
+                args.push(accumulator);
+            }
+            return invokeCallable(varValue, args, ctx, body.span.start);
+        }
+        case 'PostfixExpr': {
+            // PostfixExpr: evaluate with $ = element
+            const postfixCtx = createChildContext(ctx);
+            postfixCtx.pipeValue = element;
+            return evaluatePostfixExpr(body, postfixCtx);
+        }
+        case 'Spread': {
+            // Spread: convert element to tuple
+            const spreadCtx = createChildContext(ctx);
+            spreadCtx.pipeValue = element;
+            return evaluateSpread(body, spreadCtx);
+        }
+        default:
+            throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Unknown collection body type: ${body.type}`, body.span.start);
+    }
+}
+/**
+ * Evaluate each expression: sequential iteration returning list of all results.
+ *
+ * With accumulator: returns list of running values (scan/prefix-sum pattern)
+ * Without accumulator: returns list of body results
+ *
+ * Supports break for early termination.
+ */
+async function evaluateEach(node, input, ctx) {
+    const elements = await getIterableElements(input, ctx, node);
+    // Empty collection: return []
+    if (elements.length === 0) {
+        return [];
+    }
+    // Get initial accumulator value if present
+    let accumulator = null;
+    if (node.accumulator) {
+        accumulator = await evaluateExpression(node.accumulator, ctx);
+    }
+    else if (node.body.type === 'Closure' && node.body.params.length >= 2) {
+        // Inline closure with accumulator: |x, acc = init| body
+        const lastParam = node.body.params[node.body.params.length - 1];
+        if (lastParam?.defaultValue) {
+            accumulator = await evaluatePrimary(lastParam.defaultValue, ctx);
+        }
+    }
+    const results = [];
+    try {
+        for (const element of elements) {
+            checkAborted(ctx, node);
+            const result = await evaluateIteratorBody(node.body, element, accumulator, ctx);
+            results.push(result);
+            // Update accumulator for next iteration (scan pattern)
+            if (accumulator !== null) {
+                accumulator = result;
+            }
+        }
+    }
+    catch (e) {
+        if (e instanceof BreakSignal) {
+            // Break: return results collected so far
+            return results;
+        }
+        throw e;
+    }
+    return results;
+}
+/**
+ * Evaluate map expression: parallel iteration returning list of all results.
+ *
+ * Uses Promise.all for concurrent execution.
+ * Concurrency limit via ^(limit: N) annotation.
+ */
+async function evaluateMap(node, input, ctx) {
+    const elements = await getIterableElements(input, ctx, node);
+    // Empty collection: return []
+    if (elements.length === 0) {
+        return [];
+    }
+    // Check for concurrency limit annotation
+    const limitAnnotation = getAnnotation(ctx, 'limit');
+    const concurrencyLimit = typeof limitAnnotation === 'number' && limitAnnotation > 0
+        ? Math.floor(limitAnnotation)
+        : Infinity;
+    if (concurrencyLimit === Infinity) {
+        // No limit: all in parallel
+        const promises = elements.map((element) => evaluateIteratorBody(node.body, element, null, ctx));
+        return Promise.all(promises);
+    }
+    // With limit: process in batches
+    const results = [];
+    for (let i = 0; i < elements.length; i += concurrencyLimit) {
+        checkAborted(ctx, node);
+        const batch = elements.slice(i, i + concurrencyLimit);
+        const batchPromises = batch.map((element) => evaluateIteratorBody(node.body, element, null, ctx));
+        const batchResults = await Promise.all(batchPromises);
+        results.push(...batchResults);
+    }
+    return results;
+}
+/**
+ * Evaluate fold expression: sequential reduction returning final result only.
+ *
+ * Accumulator is required.
+ * Empty collection: returns initial accumulator value.
+ */
+async function evaluateFold(node, input, ctx) {
+    const elements = await getIterableElements(input, ctx, node);
+    // Get initial accumulator value
+    let accumulator;
+    if (node.accumulator) {
+        accumulator = await evaluateExpression(node.accumulator, ctx);
+    }
+    else if (node.body.type === 'Closure' && node.body.params.length >= 2) {
+        // Inline closure with accumulator: |x, acc = init| body
+        const lastParam = node.body.params[node.body.params.length - 1];
+        if (lastParam?.defaultValue) {
+            accumulator = await evaluatePrimary(lastParam.defaultValue, ctx);
+        }
+        else {
+            throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, 'Fold requires accumulator: use |x, acc = init| or fold(init) { }', node.span.start);
+        }
+    }
+    else if (node.body.type === 'Variable' && !node.body.isPipeVar) {
+        // Variable closure: the closure itself must have an accumulator default
+        const varValue = getVariable(ctx, node.body.name ?? '');
+        if (!varValue || !isCallable(varValue) || varValue.kind !== 'script') {
+            throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, 'Fold variable must be a script closure with accumulator parameter', node.span.start);
+        }
+        const lastParam = varValue.params[varValue.params.length - 1];
+        if (lastParam && lastParam.defaultValue !== null) {
+            accumulator = lastParam.defaultValue;
+        }
+        else {
+            throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, 'Fold closure must have accumulator parameter with default value', node.span.start);
+        }
+    }
+    else {
+        throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, 'Fold requires accumulator: use |x, acc = init| or fold(init) { }', node.span.start);
+    }
+    // Empty collection: return initial accumulator
+    if (elements.length === 0) {
+        return accumulator;
+    }
+    for (const element of elements) {
+        checkAborted(ctx, node);
+        accumulator = await evaluateIteratorBody(node.body, element, accumulator, ctx);
+    }
+    return accumulator;
+}
+/**
+ * Evaluate filter expression: parallel filtering, returns elements where predicate is truthy.
+ *
+ * Executes predicate for all elements concurrently.
+ * Preserves original element order.
+ * Empty collection: returns [].
+ */
+async function evaluateFilter(node, input, ctx) {
+    const elements = await getIterableElements(input, ctx, node);
+    // Empty collection: return []
+    if (elements.length === 0) {
+        return [];
+    }
+    // Evaluate predicate for all elements in parallel
+    const predicatePromises = elements.map(async (element) => {
+        checkAborted(ctx, node);
+        const result = await evaluateIteratorBody(node.body, element, null, ctx);
+        // Predicate must return boolean
+        if (typeof result !== 'boolean') {
+            throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Filter predicate must return boolean, got ${inferType(result)}`, node.span.start);
+        }
+        return { element, keep: result };
+    });
+    const results = await Promise.all(predicatePromises);
+    // Filter elements where predicate was true
+    return results.filter((r) => r.keep).map((r) => r.element);
+}
+async function invokeAsCallableOrFunction(callableOrName, args, ctx, location) {
+    if (isCallable(callableOrName)) {
+        return invokeCallable(callableOrName, args, ctx, location);
+    }
+    if (typeof callableOrName === 'string') {
+        const fn = ctx.functions.get(callableOrName);
+        if (fn) {
+            return fn(args, ctx, location);
+        }
+        throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_UNDEFINED_FUNCTION, `Unknown function: ${callableOrName}`, location, { functionName: callableOrName });
+    }
+    throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Expected callable or function name, got ${typeof callableOrName}`, location);
+}
+function evaluateCapture(node, input, ctx) {
+    setVariable(ctx, node.name, input, node.typeName, node.span.start);
+    ctx.observability.onCapture?.({ name: node.name, value: input });
+    return input;
+}
+// ============================================================
+// EXTRACTION OPERATORS
+// ============================================================
+function evaluateDestructure(node, input, ctx) {
+    const isList = Array.isArray(input);
+    const isDictInput = isDict(input);
+    const firstNonSkip = node.elements.find((e) => e.kind !== 'skip');
+    const isKeyPattern = firstNonSkip?.kind === 'keyValue';
+    if (isKeyPattern) {
+        if (!isDictInput) {
+            throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Key destructure requires dict, got ${isList ? 'list' : typeof input}`, node.span.start);
+        }
+        for (const elem of node.elements) {
+            if (elem.kind === 'skip')
+                continue;
+            if (elem.kind === 'nested') {
+                throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, 'Nested destructure not supported in dict patterns', elem.span.start);
+            }
+            if (elem.kind !== 'keyValue' || elem.key === null || elem.name === null) {
+                throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, 'Dict destructure requires key: $var patterns', elem.span.start);
+            }
+            const dictInput = input;
+            if (!(elem.key in dictInput)) {
+                throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Key '${elem.key}' not found in dict`, elem.span.start, { key: elem.key, availableKeys: Object.keys(dictInput) });
+            }
+            const dictValue = dictInput[elem.key];
+            if (dictValue === undefined) {
+                throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Key '${elem.key}' has undefined value`, elem.span.start);
+            }
+            setVariable(ctx, elem.name, dictValue, elem.typeName, elem.span.start);
+        }
+    }
+    else {
+        if (!isList) {
+            throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Positional destructure requires list, got ${isDictInput ? 'dict' : typeof input}`, node.span.start);
+        }
+        const listInput = input;
+        if (node.elements.length !== listInput.length) {
+            throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Destructure pattern has ${node.elements.length} elements, list has ${listInput.length}`, node.span.start);
+        }
+        for (let i = 0; i < node.elements.length; i++) {
+            const elem = node.elements[i];
+            const value = listInput[i];
+            if (elem === undefined || value === undefined) {
+                continue;
+            }
+            if (elem.kind === 'skip')
+                continue;
+            if (elem.kind === 'nested' && elem.nested) {
+                evaluateDestructure(elem.nested, value, ctx);
+                continue;
+            }
+            if (elem.name === null) {
+                throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, 'Invalid destructure element', elem.span.start);
+            }
+            setVariable(ctx, elem.name, value, elem.typeName, elem.span.start);
+        }
+    }
+    return input;
+}
+async function evaluateSlice(node, input, ctx) {
+    const isList = Array.isArray(input);
+    const isString = typeof input === 'string';
+    if (!isList && !isString) {
+        throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Slice requires list or string, got ${isDict(input) ? 'dict' : typeof input}`, node.span.start);
+    }
+    const startBound = node.start
+        ? await evaluateSliceBound(node.start, ctx)
+        : null;
+    const stopBound = node.stop ? await evaluateSliceBound(node.stop, ctx) : null;
+    const stepBound = node.step ? await evaluateSliceBound(node.step, ctx) : null;
+    if (isList) {
+        return applySlice(input, input.length, startBound, stopBound, stepBound);
+    }
+    return applySlice(input, input.length, startBound, stopBound, stepBound);
+}
+async function evaluateSliceBound(bound, ctx) {
+    if (bound === null) {
+        throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, 'Slice bound is null', undefined);
+    }
+    switch (bound.type) {
+        case 'NumberLiteral':
+            return bound.value;
+        case 'Variable': {
+            const value = evaluateVariable(bound, ctx);
+            if (typeof value !== 'number') {
+                throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Slice bound must be number, got ${typeof value}`, bound.span.start);
+            }
+            return value;
+        }
+        case 'GroupedExpr': {
+            const value = await evaluateGroupedExpr(bound, ctx);
+            if (typeof value !== 'number') {
+                throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Slice bound must be number, got ${typeof value}`, bound.span.start);
+            }
+            return value;
+        }
+    }
+}
+function applySlice(input, len, start, stop, step) {
+    const actualStep = step ?? 1;
+    if (actualStep === 0) {
+        throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, 'Slice step cannot be zero', undefined);
+    }
+    const normalizeIndex = (idx, defaultVal, forStep) => {
+        if (idx === null)
+            return defaultVal;
+        let normalized = idx < 0 ? len + idx : idx;
+        if (forStep > 0) {
+            normalized = Math.max(0, Math.min(len, normalized));
+        }
+        else {
+            normalized = Math.max(-1, Math.min(len - 1, normalized));
+        }
+        return normalized;
+    };
+    const actualStart = normalizeIndex(start, actualStep > 0 ? 0 : len - 1, actualStep);
+    const actualStop = normalizeIndex(stop, actualStep > 0 ? len : -1, actualStep);
+    const indices = [];
+    if (actualStep > 0) {
+        for (let i = actualStart; i < actualStop; i += actualStep) {
+            indices.push(i);
+        }
+    }
+    else {
+        for (let i = actualStart; i > actualStop; i += actualStep) {
+            indices.push(i);
+        }
+    }
+    if (Array.isArray(input)) {
+        return indices.map((i) => input[i]);
+    }
+    else {
+        return indices.map((i) => input[i]).join('');
+    }
+}
+async function evaluateSpread(node, ctx) {
+    let value;
+    if (node.operand === null) {
+        value = ctx.pipeValue;
+    }
+    else {
+        value = await evaluateExpression(node.operand, ctx);
+    }
+    if (Array.isArray(value)) {
+        return createTupleFromList(value);
+    }
+    if (isDict(value)) {
+        return createTupleFromDict(value);
+    }
+    throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Spread requires list or dict, got ${inferType(value)}`, node.span.start);
+}
+// ============================================================
+// TYPE OPERATIONS
+// ============================================================
+/**
+ * Evaluate type assertion: expr:type or :type (shorthand for $:type)
+ * Returns value unchanged if type matches, throws on mismatch.
+ */
+async function evaluateTypeAssertion(node, input, ctx) {
+    // If operand is null, use the input (pipe value)
+    // Otherwise, evaluate the operand
+    const value = node.operand
+        ? await evaluatePostfixExpr(node.operand, ctx)
+        : input;
+    return assertType(value, node.typeName, node.span.start);
+}
+/**
+ * Evaluate type check: expr:?type or :?type (shorthand for $:?type)
+ * Returns true if type matches, false otherwise.
+ */
+async function evaluateTypeCheck(node, input, ctx) {
+    // If operand is null, use the input (pipe value)
+    // Otherwise, evaluate the operand
+    const value = node.operand
+        ? await evaluatePostfixExpr(node.operand, ctx)
+        : input;
+    return checkType(value, node.typeName);
+}
+// ============================================================
+// LITERAL EVALUATION
+// ============================================================
+async function evaluateString(node, ctx) {
+    let result = '';
+    // Save pipeValue since interpolation expressions can modify it
+    const savedPipeValue = ctx.pipeValue;
+    for (const part of node.parts) {
+        if (typeof part === 'string') {
+            result += part;
+        }
+        else {
+            // InterpolationNode: evaluate the expression
+            // Restore pipeValue before each interpolation so they all see the same value
+            ctx.pipeValue = savedPipeValue;
+            const value = await evaluateExpression(part.expression, ctx);
+            result += formatValue(value);
+        }
+    }
+    // Restore pipeValue after string evaluation
+    ctx.pipeValue = savedPipeValue;
+    return result;
+}
+async function evaluateTuple(node, ctx) {
+    const elements = [];
+    for (const elem of node.elements) {
+        elements.push(await evaluateExpression(elem, ctx));
+    }
+    return elements;
+}
+function isClosureExpr(expr) {
+    if (expr.pipes.length > 0)
+        return false;
+    if (expr.head.type !== 'PostfixExpr')
+        return false;
+    if (expr.head.methods.length > 0)
+        return false;
+    return expr.head.primary.type === 'Closure';
+}
+async function evaluateDict(node, ctx) {
+    const result = {};
+    for (const entry of node.entries) {
+        if (isReservedMethod(entry.key)) {
+            throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Cannot use reserved method name '${entry.key}' as dict key`, entry.span.start, { key: entry.key, reservedMethods: ['keys', 'values', 'entries'] });
+        }
+        if (isClosureExpr(entry.value)) {
+            // Safe cast: isClosureExpr ensures head is PostfixExpr with Closure primary
+            const head = entry.value.head;
+            const fnLit = head.primary;
+            const closure = await createClosure(fnLit, ctx);
+            result[entry.key] = closure;
+        }
+        else {
+            result[entry.key] = await evaluateExpression(entry.value, ctx);
+        }
+    }
+    for (const key of Object.keys(result)) {
+        const value = result[key];
+        if (value !== undefined && isCallable(value)) {
+            result[key] = {
+                ...value,
+                boundDict: result,
+            };
+        }
+    }
+    return result;
+}
+async function createClosure(node, ctx) {
+    // Store reference to the defining scope for late-bound variable resolution
+    const definingScope = ctx;
+    const params = [];
+    for (const param of node.params) {
+        let defaultValue = null;
+        if (param.defaultValue) {
+            defaultValue = await evaluatePrimary(param.defaultValue, ctx);
+        }
+        params.push({
+            name: param.name,
+            typeName: param.typeName,
+            defaultValue,
+        });
+    }
+    const isProperty = params.length === 0;
+    return {
+        __type: 'callable',
+        kind: 'script',
+        params,
+        body: node.body,
+        definingScope,
+        isProperty,
+    };
+}
+// ============================================================
+// VARIABLE EVALUATION
+// ============================================================
+function getBaseVariableValue(node, ctx) {
+    if (node.isPipeVar) {
+        if (ctx.pipeValue === null) {
+            throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_UNDEFINED_VARIABLE, 'Undefined variable: $', node.span?.start, { variable: '$' });
+        }
+        return ctx.pipeValue;
+    }
+    if (node.name) {
+        const result = getVariable(ctx, node.name);
+        if (result === undefined) {
+            // Variable doesn't exist - only return null if we'll handle with default/existence check
+            if (node.defaultValue || node.existenceCheck) {
+                return null;
+            }
+            throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_UNDEFINED_VARIABLE, `Undefined variable: $${node.name}`, node.span?.start, { variable: node.name });
+        }
+        return result;
+    }
+    return null;
+}
+function resolveFieldAccess(access, value, ctx) {
+    switch (access.kind) {
+        case 'literal':
+            return access.field;
+        case 'variable': {
+            const varValue = getVariable(ctx, access.variableName);
+            if (typeof varValue === 'string')
+                return varValue;
+            if (typeof varValue === 'number')
+                return varValue;
+            throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Variable field access requires string or number, got ${typeof varValue}`, undefined, {});
+        }
+        case 'alternatives': {
+            // Try each alternative, return first that exists
+            if (typeof value === 'object' &&
+                value !== null &&
+                !Array.isArray(value)) {
+                const dict = value;
+                for (const alt of access.alternatives) {
+                    if (alt in dict)
+                        return alt;
+                }
+            }
+            return access.alternatives[0] ?? ''; // fallback to first
+        }
+        case 'computed':
+        case 'block':
+            throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Computed/block field access requires async evaluation`, undefined, {});
+    }
+}
+function evaluateVariable(node, ctx) {
+    // Note: sync version doesn't support existence checks with computed/block access
+    // Those require async. Simple existence checks are handled here.
+    if (node.existenceCheck) {
+        return evaluateExistenceCheckSync(node, ctx);
+    }
+    let value = getBaseVariableValue(node, ctx);
+    // Use accessChain but skip bracket accesses (require async evaluation)
+    for (const access of node.accessChain) {
+        if (isBracketAccess(access)) {
+            // Bracket accesses require async evaluation - skip in sync context
+            continue;
+        }
+        if (value === null) {
+            throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Cannot access field on null value`, node.span?.start, {});
+        }
+        const field = resolveFieldAccess(access, value, ctx);
+        value = accessField(value, field);
+    }
+    if (value === null) {
+        throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Field access returned null`, node.span?.start, {});
+    }
+    return value;
+}
+/**
+ * Sync version of existence check for simple (non-computed/block) access.
+ */
+function evaluateExistenceCheckSync(node, ctx) {
+    if (!node.existenceCheck)
+        return false;
+    let value = getBaseVariableValue(node, ctx);
+    // Use accessChain but skip bracket accesses (require async evaluation)
+    for (const access of node.accessChain) {
+        if (isBracketAccess(access)) {
+            // Bracket accesses require async evaluation - skip in sync context
+            continue;
+        }
+        if (value === null)
+            return false;
+        const field = resolveFieldAccess(access, value, ctx);
+        value = accessField(value, field);
+    }
+    if (value === null)
+        return false;
+    const finalField = resolveFieldAccess(node.existenceCheck.finalAccess, value, ctx);
+    const finalValue = accessField(value, finalField);
+    if (finalValue === null)
+        return false;
+    if (node.existenceCheck.typeName) {
+        return checkType(finalValue, node.existenceCheck.typeName);
+    }
+    return true;
+}
+async function evaluateVariableAsync(node, ctx) {
+    // Handle existence check: .?path returns boolean
+    if (node.existenceCheck) {
+        return evaluateExistenceCheck(node, ctx);
+    }
+    let value = getBaseVariableValue(node, ctx);
+    // Apply unified access chain (maintains order of dot and bracket accesses)
+    for (const access of node.accessChain) {
+        // If value is null/missing, either use default or error
+        if (value === null) {
+            if (node.defaultValue) {
+                return evaluateBody(node.defaultValue, ctx);
+            }
+            if (node.existenceCheck) {
+                return false; // .?field returns false for missing
+            }
+            throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Cannot access field on null value`, node.span?.start, {});
+        }
+        // Check if this is a bracket access
+        if (isBracketAccess(access)) {
+            const indexValue = await evaluatePipeChain(access.expression, ctx);
+            if (typeof indexValue !== 'number') {
+                throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Bracket index must be number, got ${inferType(indexValue)}`, node.span.start, {});
+            }
+            // Handle negative indices (from end)
+            let index = indexValue;
+            if (index < 0) {
+                if (Array.isArray(value)) {
+                    index = value.length + index;
+                }
+                else if (typeof value === 'string') {
+                    index = value.length + index;
+                }
+            }
+            const prevValue = value;
+            value = accessField(value, index);
+            // If we got null and there's no default, throw specific error
+            if (value === null && !node.defaultValue && !node.existenceCheck) {
+                if (Array.isArray(prevValue)) {
+                    throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `List index out of bounds: ${index}`, node.span?.start, {});
+                }
+            }
+        }
+        else {
+            // Field access
+            const field = await resolveFieldAccessAsync(access, value, ctx);
+            const prevValue = value;
+            value = accessField(value, field);
+            if (isCallable(value) && value.isProperty && value.boundDict) {
+                value = await invokeCallable(value, [], ctx, node.span.start);
+            }
+            // If we got null and there's no default, throw specific error
+            if (value === null && !node.defaultValue && !node.existenceCheck) {
+                if (typeof prevValue === 'object' &&
+                    prevValue !== null &&
+                    !Array.isArray(prevValue) &&
+                    !isScriptCallable(prevValue)) {
+                    throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Dict has no field '${field}'`, node.span?.start, {});
+                }
+            }
+        }
+    }
+    // Apply default if final value is null, or error if no default
+    if (value === null) {
+        if (node.defaultValue) {
+            return evaluateBody(node.defaultValue, ctx);
+        }
+        if (node.existenceCheck) {
+            return false;
+        }
+        throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Field access returned null`, node.span?.start, {});
+    }
+    return value;
+}
+/**
+ * Type guard to check if a PropertyAccess is a BracketAccess
+ */
+function isBracketAccess(access) {
+    return 'accessKind' in access && access.accessKind === 'bracket';
+}
+/**
+ * Evaluate existence check: $data.user.?email or $data.user.?email&string
+ * Returns true if path exists (and optionally matches type), false otherwise.
+ */
+async function evaluateExistenceCheck(node, ctx) {
+    if (!node.existenceCheck)
+        return false;
+    let value = getBaseVariableValue(node, ctx);
+    // Traverse the path up to (but not including) the final existence check
+    for (const access of node.accessChain) {
+        if (value === null)
+            return false; // Missing intermediate path
+        if (isBracketAccess(access)) {
+            const indexValue = await evaluatePipeChain(access.expression, ctx);
+            if (typeof indexValue !== 'number')
+                return false;
+            let index = indexValue;
+            if (index < 0) {
+                if (Array.isArray(value)) {
+                    index = value.length + index;
+                }
+                else if (typeof value === 'string') {
+                    index = value.length + index;
+                }
+            }
+            value = accessField(value, index);
+        }
+        else {
+            const field = await resolveFieldAccessAsync(access, value, ctx);
+            value = accessField(value, field);
+        }
+    }
+    // Now check the final element
+    if (value === null)
+        return false;
+    const finalField = await resolveFieldAccessAsync(node.existenceCheck.finalAccess, value, ctx);
+    const finalValue = accessField(value, finalField);
+    // Check if exists
+    if (finalValue === null)
+        return false;
+    // If type check required, verify type matches
+    if (node.existenceCheck.typeName) {
+        return checkType(finalValue, node.existenceCheck.typeName);
+    }
+    return true;
+}
+async function resolveFieldAccessAsync(access, value, ctx) {
+    switch (access.kind) {
+        case 'literal':
+            return access.field;
+        case 'variable': {
+            const varValue = getVariable(ctx, access.variableName);
+            if (typeof varValue === 'string')
+                return varValue;
+            if (typeof varValue === 'number')
+                return varValue;
+            throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Variable field access requires string or number, got ${typeof varValue}`, undefined, {});
+        }
+        case 'alternatives': {
+            if (typeof value === 'object' &&
+                value !== null &&
+                !Array.isArray(value)) {
+                const dict = value;
+                for (const alt of access.alternatives) {
+                    if (alt in dict)
+                        return alt;
+                }
+            }
+            return access.alternatives[0] ?? '';
+        }
+        case 'computed': {
+            const result = await evaluatePipeChain(access.expression, ctx);
+            if (typeof result === 'string')
+                return result;
+            if (typeof result === 'number')
+                return result;
+            throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Computed field access requires string or number result`, undefined, {});
+        }
+        case 'block': {
+            const result = await evaluateBlock(access.block, ctx);
+            if (typeof result === 'string')
+                return result;
+            if (typeof result === 'number')
+                return result;
+            throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Block field access requires string or number result`, undefined, {});
+        }
+    }
+}
+function accessField(value, field) {
+    if (value === null)
+        return null;
+    if (typeof field === 'number') {
+        if (Array.isArray(value))
+            return value[field] ?? null;
+        if (typeof value === 'string')
+            return value[field] ?? '';
+        return null;
+    }
+    if (typeof value === 'object' &&
+        !Array.isArray(value) &&
+        !isScriptCallable(value)) {
+        return value[field] ?? null;
+    }
+    return null;
+}
+// ============================================================
+// FUNCTION & METHOD EVALUATION
+// ============================================================
+async function evaluateHostCall(node, ctx) {
+    checkAborted(ctx, node);
+    const fn = ctx.functions.get(node.name);
+    if (!fn) {
+        throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_UNDEFINED_FUNCTION, `Unknown function: ${node.name}`, getNodeLocation(node), { functionName: node.name });
+    }
+    const args = await evaluateArgs(node.args, ctx);
+    if (args.length === 0 && ctx.pipeValue !== null) {
+        args.push(ctx.pipeValue);
+    }
+    ctx.observability.onHostCall?.({ name: node.name, args });
+    const startTime = Date.now();
+    const location = getNodeLocation(node);
+    const result = fn(args, ctx, location);
+    let value;
+    if (result instanceof Promise) {
+        value = await withTimeout(result, ctx.timeout, node.name, node);
+    }
+    else {
+        value = result;
+    }
+    ctx.observability.onFunctionReturn?.({
+        name: node.name,
+        value,
+        durationMs: Date.now() - startTime,
+    });
+    return value;
+}
+async function evaluateClosureCall(node, ctx) {
+    return evaluateClosureCallWithPipe(node, ctx.pipeValue, ctx);
+}
+async function evaluateClosureCallWithPipe(node, pipeInput, ctx) {
+    // Get the base variable
+    let value = getVariable(ctx, node.name);
+    if (value === undefined || value === null) {
+        throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_UNDEFINED_VARIABLE, `Unknown variable: $${node.name}`, getNodeLocation(node), { variableName: node.name });
+    }
+    // Traverse accessChain to get the closure (e.g., $math.double)
+    const fullPath = ['$' + node.name, ...node.accessChain].join('.');
+    for (const prop of node.accessChain) {
+        if (value === null) {
+            throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Cannot access property '${prop}' on null in ${fullPath}`, getNodeLocation(node), { property: prop, path: fullPath });
+        }
+        value = accessField(value, prop);
+    }
+    const closure = value;
+    if (!isCallable(closure)) {
+        throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `${fullPath} is not a function (got ${typeof closure})`, getNodeLocation(node), { path: fullPath, actualType: typeof closure });
+    }
+    const args = await evaluateArgs(node.args, ctx);
+    if (isScriptCallable(closure) &&
+        args.length === 0 &&
+        pipeInput !== null &&
+        closure.params.length > 0) {
+        const firstParam = closure.params[0];
+        if (firstParam?.defaultValue === null && !isCallable(pipeInput)) {
+            args.push(pipeInput);
+        }
+    }
+    return invokeCallable(closure, args, ctx, node.span.start);
+}
+/**
+ * Evaluate $.field as property access on the pipe value.
+ * This allows -> $.a to access property 'a' of the current pipe value.
+ */
+async function evaluatePipePropertyAccess(node, pipeInput, ctx) {
+    let value = pipeInput;
+    for (const access of node.accessChain) {
+        if (value === null) {
+            throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Cannot access property on null`, getNodeLocation(node));
+        }
+        if (isBracketAccess(access)) {
+            // Bracket access: [expr]
+            const indexValue = await evaluatePipeChain(access.expression, ctx);
+            if (Array.isArray(value)) {
+                if (typeof indexValue !== 'number') {
+                    throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `List index must be number, got ${inferType(indexValue)}`, getNodeLocation(node));
+                }
+                const result = value[indexValue];
+                if (result === undefined) {
+                    throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `List index out of bounds: ${indexValue}`, getNodeLocation(node));
+                }
+                value = result;
+            }
+            else if (isDict(value)) {
+                if (typeof indexValue !== 'string') {
+                    throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Dict key must be string, got ${inferType(indexValue)}`, getNodeLocation(node));
+                }
+                const result = value[indexValue];
+                if (result === undefined) {
+                    throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Undefined dict key: ${indexValue}`, getNodeLocation(node));
+                }
+                value = result;
+            }
+            else {
+                throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Cannot index ${inferType(value)}`, getNodeLocation(node));
+            }
+        }
+        else {
+            // Field access: .field
+            const field = await resolveFieldAccessAsync(access, value, ctx);
+            value = accessField(value, field);
+            if (value === null) {
+                throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Undefined field: ${field}`, getNodeLocation(node));
+            }
+        }
+    }
+    return value;
+}
+/**
+ * Evaluate a bare variable as a pipe target: -> $fn
+ * This invokes the closure stored in $fn with the pipe value as argument.
+ * Use :> for captures instead.
+ */
+async function evaluateVariableInvoke(node, pipeInput, ctx) {
+    // Handle pipe variable ($) - can't invoke $ as a closure
+    if (node.isPipeVar && !node.name) {
+        throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Cannot invoke $ as pipe target. Use :> to capture, or $() to invoke $ as closure`, getNodeLocation(node));
+    }
+    // Check if variable exists
+    const rawValue = node.name ? getVariable(ctx, node.name) : null;
+    if (rawValue === undefined) {
+        throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_UNDEFINED_VARIABLE, `Unknown variable: $${node.name}`, getNodeLocation(node), { variableName: node.name });
+    }
+    // Get the full variable value (with access chain)
+    const value = evaluateVariable(node, ctx);
+    // Check if it's callable
+    if (!isCallable(value)) {
+        throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Cannot invoke $${node.name}: expected closure, got ${inferType(value)}. Use :> to capture values.`, getNodeLocation(node));
+    }
+    // Invoke with pipe input as first argument
+    return invokeCallable(value, [pipeInput], ctx, node.span.start);
+}
+async function invokeCallable(callable, args, ctx, callLocation) {
+    checkAborted(ctx, undefined);
+    if (callable.kind === 'script') {
+        return invokeScriptCallable(callable, args, ctx, callLocation);
+    }
+    else {
+        return invokeFnCallable(callable, args, ctx, callLocation);
+    }
+}
+async function invokeFnCallable(callable, args, ctx, callLocation) {
+    const effectiveArgs = callable.boundDict && args.length === 0 ? [callable.boundDict] : args;
+    const result = callable.fn(effectiveArgs, ctx, callLocation);
+    return result instanceof Promise ? await result : result;
+}
+// ============================================================
+// CALLABLE INVOCATION HELPERS
+// ============================================================
+function createCallableContext(callable, ctx) {
+    // Create a child context with the defining scope as parent
+    // This enables late-bound variable resolution through the scope chain
+    const callableCtx = {
+        ...ctx,
+        parent: callable.definingScope,
+        variables: new Map(),
+        variableTypes: new Map(),
+    };
+    if (callable.boundDict) {
+        callableCtx.pipeValue = callable.boundDict;
+    }
+    return callableCtx;
+}
+function inferTypeFromDefault(defaultValue) {
+    if (defaultValue === null)
+        return null;
+    const t = inferType(defaultValue);
+    return t === 'string' || t === 'number' || t === 'bool' ? t : null;
+}
+function validateParamType(param, value, callLocation) {
+    const expectedType = param.typeName ?? inferTypeFromDefault(param.defaultValue);
+    if (expectedType !== null) {
+        const valueType = inferType(value);
+        if (valueType !== expectedType) {
+            throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Parameter type mismatch: ${param.name} expects ${expectedType}, got ${valueType}`, callLocation, { paramName: param.name, expectedType, actualType: valueType });
+        }
+    }
+}
+async function invokeScriptCallable(callable, args, ctx, callLocation) {
+    const firstArg = args[0];
+    if (args.length === 1 && firstArg !== undefined && isTuple(firstArg)) {
+        return invokeScriptCallableWithArgs(callable, firstArg, ctx, callLocation);
+    }
+    const callableCtx = createCallableContext(callable, ctx);
+    for (let i = 0; i < callable.params.length; i++) {
+        const param = callable.params[i];
+        let value;
+        if (i < args.length) {
+            value = args[i];
+        }
+        else if (param.defaultValue !== null) {
+            value = param.defaultValue;
+        }
+        else {
+            throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Missing argument for parameter '${param.name}' at position ${i}`, callLocation, { paramName: param.name, position: i });
+        }
+        validateParamType(param, value, callLocation);
+        callableCtx.variables.set(param.name, value);
+    }
+    return evaluateBodyExpression(callable.body, callableCtx);
+}
+async function invokeScriptCallableWithArgs(closure, tupleValue, ctx, callLocation) {
+    const closureCtx = createCallableContext(closure, ctx);
+    const hasNumericKeys = [...tupleValue.entries.keys()].some((k) => typeof k === 'number');
+    const hasStringKeys = [...tupleValue.entries.keys()].some((k) => typeof k === 'string');
+    if (hasNumericKeys && hasStringKeys) {
+        throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, 'Tuple cannot mix positional (numeric) and named (string) keys', callLocation);
+    }
+    const boundParams = new Set();
+    if (hasNumericKeys) {
+        for (const [key, value] of tupleValue.entries) {
+            const position = key;
+            const param = closure.params[position];
+            if (param === undefined) {
+                throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Extra argument at position ${position} (closure has ${closure.params.length} params)`, callLocation, { position, paramCount: closure.params.length });
+            }
+            validateParamType(param, value, callLocation);
+            closureCtx.variables.set(param.name, value);
+            boundParams.add(param.name);
+        }
+    }
+    else if (hasStringKeys) {
+        const paramNames = new Set(closure.params.map((p) => p.name));
+        for (const [key, value] of tupleValue.entries) {
+            const name = key;
+            if (!paramNames.has(name)) {
+                throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Unknown argument '${name}' (valid params: ${[...paramNames].join(', ')})`, callLocation, { argName: name, validParams: [...paramNames] });
+            }
+            const param = closure.params.find((p) => p.name === name);
+            validateParamType(param, value, callLocation);
+            closureCtx.variables.set(name, value);
+            boundParams.add(name);
+        }
+    }
+    for (const param of closure.params) {
+        if (!boundParams.has(param.name)) {
+            if (param.defaultValue !== null) {
+                closureCtx.variables.set(param.name, param.defaultValue);
+            }
+            else {
+                throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Missing argument '${param.name}' (no default value)`, callLocation, { paramName: param.name });
+            }
+        }
+    }
+    return evaluateBodyExpression(closure.body, closureCtx);
+}
+async function evaluatePipeInvoke(node, input, ctx) {
+    if (!isScriptCallable(input)) {
+        throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Cannot invoke non-closure value (got ${typeof input})`, getNodeLocation(node));
+    }
+    const args = await evaluateArgs(node.args, ctx);
+    return invokeScriptCallable(input, args, ctx, node.span.start);
+}
+async function evaluateMethod(node, receiver, ctx) {
+    checkAborted(ctx, node);
+    // Handle postfix invocation: expr(args) - calls receiver as a closure
+    if (node.type === 'Invoke') {
+        return evaluateInvoke(node, receiver, ctx);
+    }
+    if (isCallable(receiver)) {
+        throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Method .${node.name} not available on callable (invoke with -> $() first)`, getNodeLocation(node), { methodName: node.name, receiverType: 'callable' });
+    }
+    const args = await evaluateArgs(node.args, ctx);
+    if (isDict(receiver)) {
+        const dictValue = receiver[node.name];
+        if (dictValue !== undefined && isCallable(dictValue)) {
+            return invokeCallable(dictValue, args, ctx, getNodeLocation(node));
+        }
+    }
+    const method = ctx.methods.get(node.name);
+    if (!method) {
+        // Fall back to property access on dict (no-arg only)
+        if (isDict(receiver) && args.length === 0 && node.name in receiver) {
+            return receiver[node.name];
+        }
+        throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_UNDEFINED_METHOD, `Unknown method: ${node.name}`, getNodeLocation(node), { methodName: node.name });
+    }
+    const result = method(receiver, args, ctx, getNodeLocation(node));
+    return result instanceof Promise ? await result : result;
+}
+/**
+ * Evaluate postfix invocation: expr(args)
+ * Calls the receiver value as a closure with the given arguments.
+ */
+async function evaluateInvoke(node, receiver, ctx) {
+    if (!isCallable(receiver)) {
+        throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Cannot invoke non-callable value (got ${inferType(receiver)})`, getNodeLocation(node), { actualType: inferType(receiver) });
+    }
+    const args = await evaluateArgs(node.args, ctx);
+    return invokeCallable(receiver, args, ctx, getNodeLocation(node));
+}
+// ============================================================
+// CONTROL FLOW EVALUATION
+// ============================================================
+async function evaluateConditional(node, ctx) {
+    // Preserve pipe value before evaluating condition (condition may modify it)
+    const savedPipeValue = ctx.pipeValue;
+    let conditionResult;
+    if (node.condition) {
+        const conditionValue = await evaluateBodyExpression(node.condition, ctx);
+        // Condition must be boolean
+        if (typeof conditionValue !== 'boolean') {
+            throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Conditional expression must be boolean, got ${inferType(conditionValue)}`, node.span.start);
+        }
+        conditionResult = conditionValue;
+    }
+    else {
+        // Piped conditional: $ -> ? then ! else
+        // The pipe value must be boolean
+        if (typeof ctx.pipeValue !== 'boolean') {
+            throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Piped conditional requires boolean, got ${inferType(ctx.pipeValue)}`, node.span.start);
+        }
+        conditionResult = ctx.pipeValue;
+    }
+    // Restore pipe value for then/else branch evaluation
+    ctx.pipeValue = savedPipeValue;
+    if (conditionResult) {
+        // Create child scope for then branch (reads parent, writes local only)
+        const thenCtx = createChildContext(ctx);
+        thenCtx.pipeValue = savedPipeValue;
+        // Use evaluateBody (not evaluateBodyExpression) so ReturnSignal
+        // propagates up to the containing block rather than being caught here
+        return evaluateBody(node.thenBranch, thenCtx);
+    }
+    else if (node.elseBranch) {
+        // Create child scope for else branch (reads parent, writes local only)
+        const elseCtx = createChildContext(ctx);
+        elseCtx.pipeValue = savedPipeValue;
+        if (node.elseBranch.type === 'Conditional') {
+            return evaluateConditional(node.elseBranch, elseCtx);
+        }
+        return evaluateBody(node.elseBranch, elseCtx);
+    }
+    return ctx.pipeValue;
+}
+/**
+ * While loop evaluation: cond @ body
+ * Condition must evaluate to boolean. Re-evaluated each iteration.
+ * Each iteration creates a child scope (reads parent, writes local only).
+ * For iteration over collections, use `each` operator instead.
+ */
+async function evaluateWhileLoop(node, ctx) {
+    // Save original pipe value before evaluating condition
+    const originalPipeValue = ctx.pipeValue;
+    // Evaluate condition
+    const conditionValue = await evaluateExpression(node.condition, ctx);
+    // Restore original pipe value for loop body
+    ctx.pipeValue = originalPipeValue;
+    // Condition must be boolean
+    if (typeof conditionValue !== 'boolean') {
+        throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `While loop condition must be boolean, got ${typeof conditionValue}`, getNodeLocation(node));
+    }
+    let value = ctx.pipeValue;
+    let iterCount = 0;
+    const maxIter = getIterationLimit(ctx);
+    try {
+        let conditionResult = conditionValue;
+        while (conditionResult) {
+            iterCount++;
+            if (iterCount > maxIter) {
+                throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_LIMIT_EXCEEDED, `While loop exceeded ${maxIter} iterations`, getNodeLocation(node), { limit: maxIter, iterations: iterCount });
+            }
+            checkAborted(ctx, node);
+            // Create child scope for this iteration
+            const iterCtx = createChildContext(ctx);
+            iterCtx.pipeValue = value;
+            value = await evaluateBody(node.body, iterCtx);
+            ctx.pipeValue = value;
+            // Re-evaluate condition for next iteration
+            const nextCondition = await evaluateExpression(node.condition, ctx);
+            if (typeof nextCondition !== 'boolean') {
+                throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `While loop condition must be boolean, got ${typeof nextCondition}`, getNodeLocation(node));
+            }
+            conditionResult = nextCondition;
+            // Restore pipeValue after condition evaluation
+            ctx.pipeValue = value;
+        }
+    }
+    catch (e) {
+        if (e instanceof BreakSignal) {
+            return e.value;
+        }
+        throw e;
+    }
+    return value;
+}
+async function evaluateDoWhileLoop(node, ctx) {
+    let value = ctx.pipeValue;
+    try {
+        // Do-while: body executes first, then condition is checked
+        // Each iteration creates a child scope (reads parent, writes local only)
+        let shouldContinue = true;
+        while (shouldContinue) {
+            checkAborted(ctx, node);
+            const iterCtx = createChildContext(ctx);
+            iterCtx.pipeValue = value;
+            value = await evaluateBody(node.body, iterCtx);
+            ctx.pipeValue = value;
+            const conditionValue = await evaluateBodyExpression(node.condition, ctx);
+            // Condition must be boolean
+            if (typeof conditionValue !== 'boolean') {
+                throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Do-while condition must be boolean, got ${inferType(conditionValue)}`, getNodeLocation(node));
+            }
+            shouldContinue = conditionValue;
+        }
+    }
+    catch (e) {
+        if (e instanceof BreakSignal) {
+            return e.value;
+        }
+        throw e;
+    }
+    return value;
+}
+async function evaluateBlock(node, ctx) {
+    // Create child scope for the block: reads from parent, writes to local only
+    const blockCtx = createChildContext(ctx);
+    // All siblings inherit the SAME $ from parent (captured when block entered)
+    const parentPipeValue = blockCtx.pipeValue;
+    let lastValue = parentPipeValue;
+    for (const stmt of node.statements) {
+        // Each statement gets fresh child context with parent's $
+        // This ensures siblings don't share $ - each sees the block's $
+        const stmtCtx = createChildContext(blockCtx);
+        stmtCtx.pipeValue = parentPipeValue; // Always parent's $, not previous sibling's
+        lastValue = await executeStatement(stmt, stmtCtx);
+        // Variables captured via -> need to be promoted to block scope
+        // so they're visible to later siblings
+        for (const [name, value] of stmtCtx.variables) {
+            if (!blockCtx.variables.has(name)) {
+                blockCtx.variables.set(name, value);
+                const varType = stmtCtx.variableTypes.get(name);
+                if (varType !== undefined) {
+                    blockCtx.variableTypes.set(name, varType);
+                }
+            }
+        }
+    }
+    return lastValue; // Last sibling's result is block result
+}
+async function evaluateBlockExpression(node, ctx) {
+    try {
+        return await evaluateBlock(node, ctx);
+    }
+    catch (e) {
+        if (e instanceof ReturnSignal) {
+            return e.value;
+        }
+        throw e;
+    }
+}
+/**
+ * Evaluate a simple body (Block, GroupedExpr, or PostfixExpr).
+ * Used by conditionals and loops.
+ */
+async function evaluateBody(node, ctx) {
+    switch (node.type) {
+        case 'Block':
+            return evaluateBlock(node, ctx);
+        case 'GroupedExpr':
+            return evaluateGroupedExpr(node, ctx);
+        case 'PostfixExpr':
+            return evaluatePostfixExpr(node, ctx);
+        case 'PipeChain':
+            return evaluatePipeChain(node, ctx);
+    }
+}
+/**
+ * Evaluate a simple body as an expression (catches ReturnSignal).
+ */
+async function evaluateBodyExpression(node, ctx) {
+    try {
+        return await evaluateBody(node, ctx);
+    }
+    catch (e) {
+        if (e instanceof ReturnSignal) {
+            return e.value;
+        }
+        throw e;
+    }
+}
+// ============================================================
+// EXPRESSION EVALUATION (arithmetic, comparison, logical)
+// ============================================================
+async function evaluateBinaryExpr(node, ctx) {
+    const { op } = node;
+    // Logical operators with short-circuit evaluation
+    if (op === '||') {
+        const left = await evaluateExprHead(node.left, ctx);
+        if (isTruthy(left))
+            return true;
+        const right = await evaluateExprHead(node.right, ctx);
+        return isTruthy(right);
+    }
+    if (op === '&&') {
+        const left = await evaluateExprHead(node.left, ctx);
+        if (!isTruthy(left))
+            return false;
+        const right = await evaluateExprHead(node.right, ctx);
+        return isTruthy(right);
+    }
+    // Comparison operators - work on any values, return boolean
+    if (op === '==' ||
+        op === '!=' ||
+        op === '<' ||
+        op === '>' ||
+        op === '<=' ||
+        op === '>=') {
+        const left = await evaluateExprHead(node.left, ctx);
+        const right = await evaluateExprHead(node.right, ctx);
+        return evaluateBinaryComparison(left, right, op, node);
+    }
+    // Arithmetic operators - require numbers
+    const left = await evaluateExprHeadNumber(node.left, ctx);
+    const right = await evaluateExprHeadNumber(node.right, ctx);
+    switch (op) {
+        case '+':
+            return left + right;
+        case '-':
+            return left - right;
+        case '*':
+            return left * right;
+        case '/':
+            if (right === 0) {
+                throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, 'Division by zero', node.span.start);
+            }
+            return left / right;
+        case '%':
+            if (right === 0) {
+                throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, 'Modulo by zero', node.span.start);
+            }
+            return left % right;
+    }
+}
+/** Evaluate comparison between two values */
+function evaluateBinaryComparison(left, right, op, node) {
+    switch (op) {
+        case '==':
+            return deepEquals(left, right);
+        case '!=':
+            return !deepEquals(left, right);
+        case '<':
+        case '>':
+        case '<=':
+        case '>=':
+            // Ordering comparisons require compatible types
+            if (typeof left === 'number' && typeof right === 'number') {
+                return op === '<'
+                    ? left < right
+                    : op === '>'
+                        ? left > right
+                        : op === '<='
+                            ? left <= right
+                            : left >= right;
+            }
+            if (typeof left === 'string' && typeof right === 'string') {
+                return op === '<'
+                    ? left < right
+                    : op === '>'
+                        ? left > right
+                        : op === '<='
+                            ? left <= right
+                            : left >= right;
+            }
+            throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Cannot compare ${inferType(left)} with ${inferType(right)} using ${op}`, node.span.start);
+    }
+}
+async function evaluateUnaryExpr(node, ctx) {
+    if (node.op === '!') {
+        const value = await evaluateExprHead(node.operand, ctx);
+        return !isTruthy(value);
+    }
+    // Unary minus
+    const operand = node.operand;
+    if (operand.type === 'UnaryExpr') {
+        const inner = await evaluateUnaryExpr(operand, ctx);
+        if (typeof inner !== 'number') {
+            throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Unary minus requires number, got ${inferType(inner)}`, node.span.start);
+        }
+        return -inner;
+    }
+    const value = await evaluateExprHeadNumber(operand, ctx);
+    return -value;
+}
+/** Evaluate expression head, returning any RillValue */
+async function evaluateExprHead(node, ctx) {
+    switch (node.type) {
+        case 'BinaryExpr':
+            return evaluateBinaryExpr(node, ctx);
+        case 'UnaryExpr':
+            return evaluateUnaryExpr(node, ctx);
+        case 'PostfixExpr':
+            return evaluatePostfixExpr(node, ctx);
+    }
+}
+/** Evaluate expression head, requiring a number result */
+async function evaluateExprHeadNumber(node, ctx) {
+    const value = await evaluateExprHead(node, ctx);
+    if (typeof value !== 'number') {
+        throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Arithmetic requires number, got ${inferType(value)}`, node.span.start);
+    }
+    return value;
+}
+async function evaluateGroupedExpr(node, ctx) {
+    // Grouped expressions have their own scope (reads parent, writes local only)
+    const childCtx = createChildContext(ctx);
+    return evaluatePipeChain(node.expression, childCtx);
+}
+//# sourceMappingURL=evaluate.js.map