@rcrsr/rill 0.1.0

package/dist/runtime/core/eval/evaluator.js

@@ -0,0 +1,73 @@
+/**
+ * Composed Evaluator
+ *
+ * The complete evaluator class composed from all mixins.
+ * Uses WeakMap caching to reuse evaluator instances per RuntimeContext.
+ *
+ * Mixin composition order (bottom to top):
+ * 1. EvaluatorBase - Foundation utilities
+ * 2. CoreMixin - Expression dispatch
+ * 3. LiteralsMixin - String, dict, tuple, closure literals
+ * 4. VariablesMixin - Variable resolution and access chains
+ * 5. CollectionsMixin - each, map, fold, filter operators
+ * 6. ExtractionMixin - Destructure, slice, spread operators
+ * 7. ControlFlowMixin - Conditionals, loops, blocks
+ * 8. ClosuresMixin - Function calls and invocation
+ * 9. ExpressionsMixin - Binary, unary, grouped expressions
+ * 10. TypesMixin - Type assertions and checks
+ * 11. AnnotationsMixin - Annotated statement execution (outermost)
+ *
+ * The order ensures that each mixin can depend on the methods provided
+ * by mixins below it in the stack.
+ *
+ * @internal
+ */
+import { EvaluatorBase } from './base.js';
+import { CoreMixin } from './mixins/core.js';
+import { LiteralsMixin } from './mixins/literals.js';
+import { VariablesMixin } from './mixins/variables.js';
+import { CollectionsMixin } from './mixins/collections.js';
+import { ExtractionMixin } from './mixins/extraction.js';
+import { ControlFlowMixin } from './mixins/control-flow.js';
+import { ClosuresMixin } from './mixins/closures.js';
+import { ExpressionsMixin } from './mixins/expressions.js';
+import { TypesMixin } from './mixins/types.js';
+import { AnnotationsMixin } from './mixins/annotations.js';
+/**
+ * Complete Evaluator class composed from all mixins.
+ *
+ * This is the final, fully-composed evaluator that has all evaluation
+ * capabilities. The composition order is carefully chosen to ensure
+ * dependencies are satisfied.
+ */
+export const Evaluator = AnnotationsMixin(TypesMixin(ExpressionsMixin(ClosuresMixin(ControlFlowMixin(ExtractionMixin(CollectionsMixin(VariablesMixin(LiteralsMixin(CoreMixin(EvaluatorBase))))))))));
+/**
+ * WeakMap cache for evaluator instances.
+ *
+ * Key: RuntimeContext object reference
+ * Value: Evaluator instance for that context
+ *
+ * Cache eviction happens automatically when the RuntimeContext is
+ * garbage collected, since WeakMap keys don't prevent GC.
+ */
+const evaluatorCache = new WeakMap();
+/**
+ * Get or create an evaluator instance for a given RuntimeContext.
+ *
+ * Evaluator instances are cached per context to avoid recreating
+ * the same evaluator multiple times during script execution.
+ *
+ * @param ctx - The runtime context
+ * @returns Evaluator instance (cached or newly created)
+ *
+ * @internal
+ */
+export function getEvaluator(ctx) {
+    let evaluator = evaluatorCache.get(ctx);
+    if (!evaluator) {
+        evaluator = new Evaluator(ctx);
+        evaluatorCache.set(ctx, evaluator);
+    }
+    return evaluator;
+}
+//# sourceMappingURL=evaluator.js.map

package/dist/runtime/core/eval/evaluator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluator.js","sourceRoot":"","sources":["../../../../src/runtime/core/eval/evaluator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAG3D;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,gBAAgB,CACvC,UAAU,CACR,gBAAgB,CACd,aAAa,CACX,gBAAgB,CACd,eAAe,CACb,gBAAgB,CACd,cAAc,CAAC,aAAa,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC,CACxD,CACF,CACF,CACF,CACF,CACF,CACF,CAAC;AAKF;;;;;;;;GAQG;AACH,MAAM,cAAc,GAAG,IAAI,OAAO,EAG/B,CAAC;AAEJ;;;;;;;;;;GAUG;AACH,MAAM,UAAU,YAAY,CAC1B,GAAmB;IAEnB,IAAI,SAAS,GAAG,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACxC,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,SAAS,GAAG,IAAI,SAAS,CAAC,GAAG,CAAC,CAAC;QAC/B,cAAc,CAAC,GAAG,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;IACrC,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/dist/runtime/core/eval/index.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Evaluation Public API
+ *
+ * Public API for AST evaluation using the class-based Evaluator architecture.
+ * Provides functional wrappers around Evaluator methods for backward compatibility.
+ *
+ * @internal
+ */
+import type { AnnotatedStatementNode, ASTNode, CaptureNode, ExpressionNode, RillTypeName, SourceLocation, StatementNode } from '../../../types.js';
+import type { RuntimeContext } from '../types.js';
+import type { RillValue } from '../values.js';
+/**
+ * Capture information returned by handleCapture.
+ */
+export type CaptureInfo = {
+    name: string;
+    value: RillValue;
+};
+/**
+ * Check if execution has been aborted via AbortSignal.
+ * Throws AbortError if signal is aborted.
+ */
+export declare function checkAborted(ctx: RuntimeContext, node?: ASTNode): void;
+/**
+ * Check if the current pipe value matches any autoException pattern.
+ * Only checks string values. Throws AutoExceptionError on match.
+ */
+export declare function checkAutoExceptions(value: RillValue, ctx: RuntimeContext, node?: ASTNode): void;
+/**
+ * Handle statement capture: set variable and fire observability event.
+ * Returns capture info if a capture occurred.
+ *
+ * Note: Accepts CaptureNode | null because internal calls from CoreMixin
+ * pass chain.terminator which may be null.
+ */
+export declare function handleCapture(capture: CaptureNode | null, value: RillValue, ctx: RuntimeContext): CaptureInfo | undefined;
+/**
+ * Assert that a value is of the expected type.
+ * Returns the value unchanged if assertion passes, throws on mismatch.
+ */
+export declare function assertType(value: RillValue, expected: RillTypeName, location?: SourceLocation): RillValue;
+/**
+ * Evaluate an expression and return its value.
+ * Main entry point for expression evaluation.
+ */
+export declare function evaluateExpression(expr: ExpressionNode, ctx: RuntimeContext): Promise<RillValue>;
+/**
+ * Execute a statement and return the result.
+ * Handles annotations and observability events.
+ */
+export declare function executeStatement(stmt: StatementNode | AnnotatedStatementNode, ctx: RuntimeContext): Promise<RillValue>;
+/**
+ * Get annotation value by key from the context's annotation stack.
+ * Returns undefined if annotation is not set.
+ */
+export declare function getAnnotation(ctx: RuntimeContext, key: string): RillValue | undefined;
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/core/eval/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/runtime/core/eval/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACV,sBAAsB,EACtB,OAAO,EACP,WAAW,EACX,cAAc,EACd,YAAY,EACZ,cAAc,EACd,aAAa,EACd,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAG9C;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,SAAS,CAAA;CAAE,CAAC;AAE7D;;;GAGG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAKtE;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,SAAS,EAChB,GAAG,EAAE,cAAc,EACnB,IAAI,CAAC,EAAE,OAAO,GACb,IAAI,CAKN;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,WAAW,GAAG,IAAI,EAC3B,KAAK,EAAE,SAAS,EAChB,GAAG,EAAE,cAAc,GAClB,WAAW,GAAG,SAAS,CAUzB;AAED;;;GAGG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,SAAS,EAChB,QAAQ,EAAE,YAAY,EACtB,QAAQ,CAAC,EAAE,cAAc,GACxB,SAAS,CAoBX;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,cAAc,EACpB,GAAG,EAAE,cAAc,GAClB,OAAO,CAAC,SAAS,CAAC,CAGpB;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,aAAa,GAAG,sBAAsB,EAC5C,GAAG,EAAE,cAAc,GAClB,OAAO,CAAC,SAAS,CAAC,CAGpB;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,cAAc,EACnB,GAAG,EAAE,MAAM,GACV,SAAS,GAAG,SAAS,CAGvB"}

package/dist/runtime/core/eval/index.js

@@ -0,0 +1,95 @@
+/**
+ * Evaluation Public API
+ *
+ * Public API for AST evaluation using the class-based Evaluator architecture.
+ * Provides functional wrappers around Evaluator methods for backward compatibility.
+ *
+ * @internal
+ */
+import { getEvaluator } from './evaluator.js';
+/**
+ * Check if execution has been aborted via AbortSignal.
+ * Throws AbortError if signal is aborted.
+ */
+export function checkAborted(ctx, node) {
+    const evaluator = getEvaluator(ctx);
+    // Access protected method via type assertion
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    evaluator.checkAborted(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) {
+    const evaluator = getEvaluator(ctx);
+    // Access protected method via type assertion
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    evaluator.checkAutoExceptions(value, node);
+}
+/**
+ * Handle statement capture: set variable and fire observability event.
+ * Returns capture info if a capture occurred.
+ *
+ * Note: Accepts CaptureNode | null because internal calls from CoreMixin
+ * pass chain.terminator which may be null.
+ */
+export function handleCapture(capture, value, ctx) {
+    if (!capture)
+        return undefined;
+    const evaluator = getEvaluator(ctx);
+    // Access protected evaluateCapture method via type assertion
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    evaluator.evaluateCapture(capture, value);
+    // Return capture info for observability
+    return { name: capture.name, value };
+}
+/**
+ * Assert that a value is of the expected type.
+ * Returns the value unchanged if assertion passes, throws on mismatch.
+ */
+export function assertType(value, expected, location) {
+    // Create a minimal context for standalone type assertions
+    // This is needed for assertType calls that occur outside expression evaluation
+    const minimalContext = {
+        variables: new Map(),
+        variableTypes: new Map(),
+        functions: new Map(),
+        methods: new Map(),
+        callbacks: { onLog: () => { } },
+        pipeValue: null,
+        parent: undefined,
+        signal: undefined,
+        observability: {},
+        timeout: undefined,
+        autoExceptions: [],
+        annotationStack: [],
+    };
+    const evaluator = getEvaluator(minimalContext);
+    return evaluator.assertType(value, expected, location);
+}
+/**
+ * Evaluate an expression and return its value.
+ * Main entry point for expression evaluation.
+ */
+export async function evaluateExpression(expr, ctx) {
+    const evaluator = getEvaluator(ctx);
+    return evaluator.evaluateExpression(expr);
+}
+/**
+ * Execute a statement and return the result.
+ * Handles annotations and observability events.
+ */
+export async function executeStatement(stmt, ctx) {
+    const evaluator = getEvaluator(ctx);
+    return evaluator.executeStatement(stmt);
+}
+/**
+ * Get annotation value by key from the context's annotation stack.
+ * Returns undefined if annotation is not set.
+ */
+export function getAnnotation(ctx, key) {
+    const evaluator = getEvaluator(ctx);
+    return evaluator.getAnnotation(key);
+}
+//# sourceMappingURL=index.js.map

package/dist/runtime/core/eval/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/runtime/core/eval/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAaH,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAO9C;;;GAGG;AACH,MAAM,UAAU,YAAY,CAAC,GAAmB,EAAE,IAAc;IAC9D,MAAM,SAAS,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC;IACpC,6CAA6C;IAC7C,8DAA8D;IAC7D,SAAiB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;AACxC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,mBAAmB,CACjC,KAAgB,EAChB,GAAmB,EACnB,IAAc;IAEd,MAAM,SAAS,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC;IACpC,6CAA6C;IAC7C,8DAA8D;IAC7D,SAAiB,CAAC,mBAAmB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;AACtD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAC3B,OAA2B,EAC3B,KAAgB,EAChB,GAAmB;IAEnB,IAAI,CAAC,OAAO;QAAE,OAAO,SAAS,CAAC;IAE/B,MAAM,SAAS,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC;IACpC,6DAA6D;IAC7D,8DAA8D;IAC7D,SAAiB,CAAC,eAAe,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IAEnD,wCAAwC;IACxC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC;AACvC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,UAAU,CACxB,KAAgB,EAChB,QAAsB,EACtB,QAAyB;IAEzB,0DAA0D;IAC1D,+EAA+E;IAC/E,MAAM,cAAc,GAAmB;QACrC,SAAS,EAAE,IAAI,GAAG,EAAE;QACpB,aAAa,EAAE,IAAI,GAAG,EAAE;QACxB,SAAS,EAAE,IAAI,GAAG,EAAE;QACpB,OAAO,EAAE,IAAI,GAAG,EAAE;QAClB,SAAS,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,GAAE,CAAC,EAAE;QAC9B,SAAS,EAAE,IAAI;QACf,MAAM,EAAE,SAAS;QACjB,MAAM,EAAE,SAAS;QACjB,aAAa,EAAE,EAAE;QACjB,OAAO,EAAE,SAAS;QAClB,cAAc,EAAE,EAAE;QAClB,eAAe,EAAE,EAAE;KACpB,CAAC;IAEF,MAAM,SAAS,GAAG,YAAY,CAAC,cAAc,CAAC,CAAC;IAC/C,OAAO,SAAS,CAAC,UAAU,CAAC,KAAK,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;AACzD,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACtC,IAAoB,EACpB,GAAmB;IAEnB,MAAM,SAAS,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC;IACpC,OAAO,SAAS,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;AAC5C,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACpC,IAA4C,EAC5C,GAAmB;IAEnB,MAAM,SAAS,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC;IACpC,OAAO,SAAS,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;AAC1C,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,aAAa,CAC3B,GAAmB,EACnB,GAAW;IAEX,MAAM,SAAS,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC;IACpC,OAAO,SAAS,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;AACtC,CAAC"}

package/dist/runtime/core/eval/mixins/annotations.d.ts

@@ -0,0 +1,19 @@
+/**
+ * AnnotationsMixin: Annotated Statement Execution
+ *
+ * Provides statement execution wrapper with annotation handling.
+ * Annotations modify execution behavior (e.g., iteration limits).
+ *
+ * Interface requirements (from spec IR-53 through IR-55):
+ * - executeStatement(stmt) -> Promise<RillValue> [IR-53]
+ * - getAnnotation(key) -> RillValue | undefined [IR-54]
+ * - getIterationLimit() -> number [IR-55]
+ *
+ * Error Handling:
+ * - Annotated statement execution errors propagate [EC-25]
+ * - Annotation evaluation errors propagate [EC-26]
+ *
+ * @internal
+ */
+export declare const AnnotationsMixin: any;
+//# sourceMappingURL=annotations.d.ts.map

package/dist/runtime/core/eval/mixins/annotations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotations.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/core/eval/mixins/annotations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AA2KH,eAAO,MAAM,gBAAgB,EAA6B,GAAG,CAAC"}

package/dist/runtime/core/eval/mixins/annotations.js

@@ -0,0 +1,146 @@
+/**
+ * AnnotationsMixin: Annotated Statement Execution
+ *
+ * Provides statement execution wrapper with annotation handling.
+ * Annotations modify execution behavior (e.g., iteration limits).
+ *
+ * Interface requirements (from spec IR-53 through IR-55):
+ * - executeStatement(stmt) -> Promise<RillValue> [IR-53]
+ * - getAnnotation(key) -> RillValue | undefined [IR-54]
+ * - getIterationLimit() -> number [IR-55]
+ *
+ * Error Handling:
+ * - Annotated statement execution errors propagate [EC-25]
+ * - Annotation evaluation errors propagate [EC-26]
+ *
+ * @internal
+ */
+import { RuntimeError, RILL_ERROR_CODES } from '../../../../types.js';
+import { isCallable } from '../../callable.js';
+/** Default maximum loop iterations */
+const DEFAULT_MAX_ITERATIONS = 10000;
+/**
+ * AnnotationsMixin implementation.
+ *
+ * Provides methods for handling annotated statements and retrieving
+ * annotation values from the context stack.
+ *
+ * Depends on:
+ * - EvaluatorBase: ctx, checkAborted(), getNodeLocation(), checkAutoExceptions()
+ * - CoreMixin: evaluateExpression()
+ *
+ * Methods added:
+ * - executeStatement(stmt) -> Promise<RillValue>
+ * - getAnnotation(key) -> RillValue | undefined
+ * - getIterationLimit() -> number
+ */
+function createAnnotationsMixin(Base) {
+    return class AnnotationsEvaluator extends Base {
+        /**
+         * Execute statement with annotation handling [IR-53].
+         *
+         * Handles both regular and annotated statements.
+         * For annotated statements, evaluates annotations, pushes to stack,
+         * executes inner statement, and pops annotations.
+         */
+        async executeStatement(stmt) {
+            // Handle annotated statements
+            if (stmt.type === 'AnnotatedStatement') {
+                return this.executeAnnotatedStatement(stmt);
+            }
+            // Regular statement: evaluate expression
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const value = await this.evaluateExpression(stmt.expression);
+            // Note: Do NOT set ctx.pipeValue = value here.
+            // Statements don't propagate $ to siblings. $ flows only via explicit ->.
+            this.checkAutoExceptions(value, 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.
+         *
+         * Errors during annotation evaluation or statement execution propagate.
+         */
+        async executeAnnotatedStatement(stmt) {
+            // Evaluate annotation arguments to build annotation dict [EC-26]
+            const newAnnotations = await this.evaluateAnnotations(stmt.annotations);
+            // Merge with inherited annotations (inner overrides outer)
+            const inherited = this.ctx.annotationStack.at(-1) ?? {};
+            const merged = { ...inherited, ...newAnnotations };
+            // Push merged annotations, execute inner statement, pop
+            this.ctx.annotationStack.push(merged);
+            try {
+                return await this.executeStatement(stmt.statement);
+            }
+            finally {
+                this.ctx.annotationStack.pop();
+            }
+        }
+        /**
+         * Evaluate annotation arguments to a dict of key-value pairs.
+         * Handles both named arguments and spread arguments.
+         *
+         * Errors during evaluation propagate [EC-26].
+         */
+        async evaluateAnnotations(annotations) {
+            const result = {};
+            for (const arg of annotations) {
+                if (arg.type === 'NamedArg') {
+                    const namedArg = arg;
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    result[namedArg.name] = await this.evaluateExpression(namedArg.value);
+                }
+                else {
+                    // SpreadArg: spread tuple/dict keys as annotations
+                    const spreadArg = arg;
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const spreadValue = await this.evaluateExpression(spreadArg.expression);
+                    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', spreadArg.span.start);
+                    }
+                    else {
+                        throw new RuntimeError(RILL_ERROR_CODES.RUNTIME_TYPE_ERROR, `Annotation spread requires dict, got ${typeof spreadValue}`, spreadArg.span.start);
+                    }
+                }
+            }
+            return result;
+        }
+        /**
+         * Get the current value of an annotation from the annotation stack [IR-54].
+         *
+         * Returns the value from the top of the annotation stack (innermost scope).
+         */
+        getAnnotation(key) {
+            return this.ctx.annotationStack.at(-1)?.[key];
+        }
+        /**
+         * Get the iteration limit for loops from the `limit` annotation [IR-55].
+         *
+         * Returns the default if not set or if the value is not a positive number.
+         */
+        getIterationLimit() {
+            const limit = this.getAnnotation('limit');
+            if (typeof limit === 'number' && limit > 0) {
+                return Math.floor(limit);
+            }
+            return DEFAULT_MAX_ITERATIONS;
+        }
+    };
+}
+// Export with type assertion to work around TS4094 limitation
+// TypeScript can't generate declarations for functions returning classes with protected members
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const AnnotationsMixin = createAnnotationsMixin;
+//# sourceMappingURL=annotations.js.map

package/dist/runtime/core/eval/mixins/annotations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotations.js","sourceRoot":"","sources":["../../../../../src/runtime/core/eval/mixins/annotations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AASH,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAEtE,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAI/C,sCAAsC;AACtC,MAAM,sBAAsB,GAAG,KAAK,CAAC;AAErC;;;;;;;;;;;;;;GAcG;AACH,SAAS,sBAAsB,CAAC,IAAyC;IACvE,OAAO,MAAM,oBAAqB,SAAQ,IAAI;QAC5C;;;;;;WAMG;QACH,KAAK,CAAC,gBAAgB,CACpB,IAA4C;YAE5C,8BAA8B;YAC9B,IAAI,IAAI,CAAC,IAAI,KAAK,oBAAoB,EAAE,CAAC;gBACvC,OAAO,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,CAAC;YAC9C,CAAC;YAED,yCAAyC;YACzC,8DAA8D;YAC9D,MAAM,KAAK,GAAG,MAAO,IAAY,CAAC,kBAAkB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAEtE,+CAA+C;YAC/C,0EAA0E;YAC1E,IAAI,CAAC,mBAAmB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;YAEtC,6DAA6D;YAC7D,+DAA+D;YAE/D,OAAO,KAAK,CAAC;QACf,CAAC;QAED;;;;;;WAMG;QACK,KAAK,CAAC,yBAAyB,CACrC,IAA4B;YAE5B,iEAAiE;YACjE,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAExE,2DAA2D;YAC3D,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;YACxD,MAAM,MAAM,GAAG,EAAE,GAAG,SAAS,EAAE,GAAG,cAAc,EAAE,CAAC;YAEnD,wDAAwD;YACxD,IAAI,CAAC,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACtC,IAAI,CAAC;gBACH,OAAO,MAAM,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YACrD,CAAC;oBAAS,CAAC;gBACT,IAAI,CAAC,GAAG,CAAC,eAAe,CAAC,GAAG,EAAE,CAAC;YACjC,CAAC;QACH,CAAC;QAED;;;;;WAKG;QACK,KAAK,CAAC,mBAAmB,CAC/B,WAA4B;YAE5B,MAAM,MAAM,GAA8B,EAAE,CAAC;YAE7C,KAAK,MAAM,GAAG,IAAI,WAAW,EAAE,CAAC;gBAC9B,IAAI,GAAG,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;oBAC5B,MAAM,QAAQ,GAAG,GAAmB,CAAC;oBACrC,8DAA8D;oBAC9D,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,MAAO,IAAY,CAAC,kBAAkB,CAC5D,QAAQ,CAAC,KAAK,CACf,CAAC;gBACJ,CAAC;qBAAM,CAAC;oBACN,mDAAmD;oBACnD,MAAM,SAAS,GAAG,GAAoB,CAAC;oBACvC,8DAA8D;oBAC9D,MAAM,WAAW,GAAG,MAAO,IAAY,CAAC,kBAAkB,CACxD,SAAS,CAAC,UAAU,CACrB,CAAC;oBAEF,IACE,OAAO,WAAW,KAAK,QAAQ;wBAC/B,WAAW,KAAK,IAAI;wBACpB,CAAC,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC;wBAC3B,CAAC,UAAU,CAAC,WAAW,CAAC,EACxB,CAAC;wBACD,mCAAmC;wBACnC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;oBACrC,CAAC;yBAAM,IAAI,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,CAAC;wBACtC,0DAA0D;wBAC1D,MAAM,IAAI,YAAY,CACpB,gBAAgB,CAAC,kBAAkB,EACnC,2DAA2D,EAC3D,SAAS,CAAC,IAAI,CAAC,KAAK,CACrB,CAAC;oBACJ,CAAC;yBAAM,CAAC;wBACN,MAAM,IAAI,YAAY,CACpB,gBAAgB,CAAC,kBAAkB,EACnC,wCAAwC,OAAO,WAAW,EAAE,EAC5D,SAAS,CAAC,IAAI,CAAC,KAAK,CACrB,CAAC;oBACJ,CAAC;gBACH,CAAC;YACH,CAAC;YAED,OAAO,MAAM,CAAC;QAChB,CAAC;QAED;;;;WAIG;QACH,aAAa,CAAC,GAAW;YACvB,OAAO,IAAI,CAAC,GAAG,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;QAChD,CAAC;QAED;;;;WAIG;QACH,iBAAiB;YACf,MAAM,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;YAC1C,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;gBAC3C,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YAC3B,CAAC;YACD,OAAO,sBAAsB,CAAC;QAChC,CAAC;KACF,CAAC;AACJ,CAAC;AAED,8DAA8D;AAC9D,gGAAgG;AAChG,8DAA8D;AAC9D,MAAM,CAAC,MAAM,gBAAgB,GAAG,sBAA6B,CAAC"}

package/dist/runtime/core/eval/mixins/closures.d.ts

@@ -0,0 +1,49 @@
+/**
+ * ClosuresMixin: Closure and Method Invocation
+ *
+ * Handles all callable operations:
+ * - Host function calls
+ * - Closure calls (script callables)
+ * - Method calls on values
+ * - Invoke operations
+ * - Pipe invocations
+ * - Property access on piped values
+ * - Closure chains
+ *
+ * Interface requirements (from spec):
+ * - invokeCallable(callable, args, location) -> Promise<RillValue>
+ * - evaluateHostCall(node) -> Promise<RillValue>
+ * - evaluateClosureCall(node) -> Promise<RillValue>
+ * - evaluateClosureCallWithPipe(node, pipeInput) -> Promise<RillValue>
+ * - evaluatePipePropertyAccess(node, pipeInput) -> Promise<RillValue>
+ * - evaluateVariableInvoke(node, pipeInput) -> Promise<RillValue>
+ * - evaluatePipeInvoke(node, input) -> Promise<RillValue>
+ * - evaluateMethod(node, receiver) -> Promise<RillValue>
+ * - evaluateInvoke(node, receiver) -> Promise<RillValue>
+ * - evaluateClosureChain(node, input) -> Promise<RillValue>
+ *
+ * Error Handling:
+ * - Undefined functions throw RuntimeError(RUNTIME_UNDEFINED_FUNCTION) [EC-18]
+ * - Undefined methods throw RuntimeError(RUNTIME_UNDEFINED_METHOD) [EC-19]
+ * - Parameter type mismatches throw RuntimeError(RUNTIME_TYPE_ERROR) [EC-20]
+ * - Async operations timeout per TimeoutError [EC-21]
+ *
+ * ## Implementation Notes
+ *
+ * [DEVIATION] Function naming: Spec references validateHostFunctionArgs but implementation
+ * uses validateCallableArgs because ApplicationCallable stores CallableParam[] (not
+ * HostFunctionParam[]). The two interfaces have different type field names ('type' vs
+ * 'typeName'). Separate validation functions maintain proper abstraction boundaries.
+ *
+ * [ASSUMPTION] Excess argument validation occurs before default application to fail fast
+ * on arity mismatches, improving error messages. This matches the algorithm order in the
+ * spec where excess check happens first.
+ *
+ * [ASSUMPTION] boundDict substitution happens before validation for property-style
+ * callables to ensure type checks apply to the effective arguments (including bound dict).
+ * This prevents validation bypass when property-style callables are accessed.
+ *
+ * @internal
+ */
+export declare const ClosuresMixin: any;
+//# sourceMappingURL=closures.d.ts.map

package/dist/runtime/core/eval/mixins/closures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"closures.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/core/eval/mixins/closures.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AA2rBH,eAAO,MAAM,aAAa,EAA0B,GAAG,CAAC"}