@rcrsr/rill 0.8.5 → 0.9.0

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

@@ -1 +1 @@
-{"version":3,"file":"annotations.js","sourceRoot":"","sources":["../../../../../src/runtime/core/eval/mixins/annotations.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"annotations.js","sourceRoot":"","sources":["../../../../../src/runtime/core/eval/mixins/annotations.ts"],"names":[],"mappings":"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"}

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

@@ -8,7 +8,6 @@
  * - Invoke operations
  * - Pipe invocations
  * - Property access on piped values
- * - Closure chains
  *
  * Interface requirements (from spec):
  * - invokeCallable(callable, args, location) -> Promise<RillValue>
@@ -20,7 +19,6 @@
  * - 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]

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

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

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

@@ -8,7 +8,6 @@
  * - Invoke operations
  * - Pipe invocations
  * - Property access on piped values
- * - Closure chains
  *
  * Interface requirements (from spec):
  * - invokeCallable(callable, args, location) -> Promise<RillValue>
@@ -20,7 +19,6 @@
  * - 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]
@@ -46,9 +44,9 @@
  * @internal
  */
 import { RuntimeError } from '../../../../types.js';
-import { isCallable, isScriptCallable, isApplicationCallable, isDict, validateCallableArgs, } from '../../callable.js';
+import { isCallable, isScriptCallable, isApplicationCallable, isDict, validateCallableArgs, paramsToStructuralType, } from '../../callable.js';
 import { getVariable, pushCallFrame, popCallFrame } from '../../context.js';
-import { inferType, isTuple } from '../../values.js';
+import { inferType, isTypeValue, isTuple, isOrdered, inferStructuralType, } from '../../values.js';
 /**
  * ClosuresMixin implementation.
  *
@@ -70,14 +68,13 @@ import { inferType, isTuple } from '../../values.js';
  * - evaluatePipeInvoke(node, input) -> Promise<RillValue>
  * - evaluateMethod(node, receiver) -> Promise<RillValue>
  * - evaluateInvoke(node, receiver) -> Promise<RillValue>
- * - evaluateClosureChain(node, input) -> Promise<RillValue>
  * - evaluateArgs(argExprs) -> Promise<RillValue[]> (helper)
  * - invokeFnCallable(callable, args, location) -> Promise<RillValue> (helper)
  * - invokeScriptCallable(callable, args, location) -> Promise<RillValue> (helper)
- * - invokeScriptCallableWithArgs(callable, tuple, location) -> Promise<RillValue> (helper)
  * - createCallableContext(callable) -> RuntimeContext (helper)
  * - validateParamType(param, value, location) -> void (helper)
  * - inferTypeFromDefault(defaultValue) -> RillTypeName | null (helper)
+ * - bindArgsToParams(argNodes, callable, callLocation) -> Promise<BoundArgs> (helper)
  */
 function createClosuresMixin(Base) {
     return class ClosuresEvaluator extends Base {
@@ -89,8 +86,9 @@ function createClosuresMixin(Base) {
             const savedPipeValue = this.ctx.pipeValue;
             const args = [];
             for (const arg of argExprs) {
+                const expr = arg.type === 'SpreadArg' ? arg.expression : arg;
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                args.push(await this.evaluateExpression(arg));
+                args.push(await this.evaluateExpression(expr));
             }
             this.ctx.pipeValue = savedPipeValue;
             return args;
@@ -189,6 +187,8 @@ function createClosuresMixin(Base) {
          */
         validateParamType(param, value, callLocation) {
             const expectedType = param.typeName ?? this.inferTypeFromDefault(param.defaultValue);
+            if (expectedType === 'any')
+                return;
             if (expectedType !== null) {
                 const valueType = inferType(value);
                 if (valueType !== expectedType) {
@@ -201,10 +201,6 @@ function createClosuresMixin(Base) {
          * Handles parameter binding, default values, and type checking.
          */
         async invokeScriptCallable(callable, args, callLocation) {
-            const firstArg = args[0];
-            if (args.length === 1 && firstArg !== undefined && isTuple(firstArg)) {
-                return this.invokeScriptCallableWithArgs(callable, firstArg, callLocation);
-            }
             const callableCtx = this.createCallableContext(callable);
             // Validate excess arguments (EC-8)
             if (args.length > callable.params.length) {
@@ -234,73 +230,14 @@ function createClosuresMixin(Base) {
             this.ctx = callableCtx;
             try {
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                return await this.evaluateBodyExpression(callable.body);
-            }
-            finally {
-                this.ctx = savedCtx;
-            }
-        }
-        /**
-         * Invoke script callable with tuple arguments (named or positional).
-         * Handles *[...] and *[name: val] argument unpacking.
-         */
-        async invokeScriptCallableWithArgs(closure, tupleValue, callLocation) {
-            const closureCtx = this.createCallableContext(closure);
-            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-R001', '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-R001', `Extra argument at position ${position} (closure has ${closure.params.length} params)`, callLocation, { position, paramCount: closure.params.length });
-                    }
-                    this.validateParamType(param, value, callLocation);
-                    closureCtx.variables.set(param.name, value);
-                    boundParams.add(param.name);
+                const result = await this.evaluateBodyExpression(callable.body);
+                // IR-4: Assert return value against declared returnShape (AC-14, AC-15, AC-16)
+                if (callable.returnShape !== undefined) {
+                    // EC-4: Type assertion — value must match the declared scalar type
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    this.assertType(result, callable.returnShape.typeName, callLocation);
                 }
-            }
-            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-R001', `Unknown argument '${name}' (valid params: ${[...paramNames].join(', ')})`, callLocation, { argName: name, validParams: [...paramNames] });
-                    }
-                    const param = closure.params.find((p) => p.name === name);
-                    this.validateParamType(param, value, callLocation);
-                    closureCtx.variables.set(name, value);
-                    // Block-closures have param named '$': sync with pipeValue for bare $ references
-                    if (name === '$') {
-                        closureCtx.pipeValue = 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);
-                        // Block-closures have param named '$': sync with pipeValue for bare $ references
-                        if (param.name === '$') {
-                            closureCtx.pipeValue = param.defaultValue;
-                        }
-                    }
-                    else {
-                        throw new RuntimeError('RILL-R001', `Missing argument '${param.name}' (no default value)`, callLocation, { paramName: param.name });
-                    }
-                }
-            }
-            // Switch context to callable context
-            const savedCtx = this.ctx;
-            this.ctx = closureCtx;
-            try {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                return await this.evaluateBodyExpression(closure.body);
+                return result;
             }
             finally {
                 this.ctx = savedCtx;
@@ -316,6 +253,32 @@ function createClosuresMixin(Base) {
             if (!fn) {
                 throw new RuntimeError('RILL-R006', `Unknown function: ${node.name}`, this.getNodeLocation(node), { functionName: node.name });
             }
+            // EC-10/EC-11: spread-aware path for host calls
+            const hasSpread = node.args.some((a) => a.type === 'SpreadArg');
+            if (hasSpread) {
+                if (typeof fn === 'function') {
+                    // EC-10: raw built-in (RuntimeCallable) — spread not supported
+                    throw new RuntimeError('RILL-R001', `Spread not supported for built-in function '${node.name}'`, this.getNodeLocation(node), { functionName: node.name });
+                }
+                // EC-11: ApplicationCallable — bindArgsToParams handles no-params guard
+                const boundArgs = await this.bindArgsToParams(node.args, fn, node.span.start);
+                const orderedArgs = fn.params.map((p) => boundArgs.params.get(p.name));
+                // Observability: onHostCall before execution
+                this.ctx.observability.onHostCall?.({
+                    name: node.name,
+                    args: orderedArgs,
+                });
+                const startTime = performance.now();
+                const wrappedPromise = this.withTimeout(this.invokeCallable(fn, orderedArgs, node.span.start, node.name), this.ctx.timeout, node.name, node);
+                const result = await wrappedPromise;
+                const durationMs = performance.now() - startTime;
+                this.ctx.observability.onFunctionReturn?.({
+                    name: node.name,
+                    value: result,
+                    durationMs,
+                });
+                return result;
+            }
             const args = await this.evaluateArgs(node.args);
             // Add pipe value to empty args list UNLESS function has typed params with length 0
             // (typed functions with params: [] explicitly declare zero parameters)
@@ -359,6 +322,50 @@ function createClosuresMixin(Base) {
             });
             return result;
         }
+        /**
+         * Evaluate host function reference: ns::name (no parens, namespaced).
+         *
+         * When pipeValue is null (value-capture context): returns the
+         * ApplicationCallable directly without invoking [IR-4].
+         *
+         * When pipeValue is set (pipe/branch context): invokes the callable
+         * with the pipe value as the implicit argument, consistent with how
+         * bare HostRef behaves as a pipe-stage expression [IR-4].
+         *
+         * Throws RILL-R006 when the function name is not registered [EC-4].
+         */
+        async evaluateHostRef(node) {
+            this.checkAborted(node);
+            const fn = this.ctx.functions.get(node.name);
+            if (!fn) {
+                throw new RuntimeError('RILL-R006', `Function "${node.name}" not found`, this.getNodeLocation(node), { functionName: node.name });
+            }
+            // Build ApplicationCallable wrapper for raw CallableFn; pass through
+            // ApplicationCallable objects directly.
+            let appCallable;
+            if (typeof fn === 'function') {
+                appCallable = {
+                    __type: 'callable',
+                    kind: 'application',
+                    fn,
+                    params: undefined,
+                    isProperty: false,
+                };
+            }
+            else {
+                appCallable = fn;
+            }
+            // Value-capture context: no pipe value → return callable without invoking [IR-4]
+            if (this.ctx.pipeValue === null) {
+                return appCallable;
+            }
+            // Pipe/branch context: pipe value present → invoke with it as implicit argument
+            const fnHasTypedZeroParams = appCallable.params !== undefined && appCallable.params.length === 0;
+            const args = fnHasTypedZeroParams
+                ? []
+                : [this.ctx.pipeValue];
+            return this.invokeCallable(appCallable, args, this.getNodeLocation(node), node.name);
+        }
         /**
          * Evaluate closure call: $fn(args)
          * Delegates to evaluateClosureCallWithPipe using current pipe value.
@@ -396,6 +403,15 @@ function createClosuresMixin(Base) {
                 throw new RuntimeError('RILL-R002', `'${fullPath}' is not callable`, this.getNodeLocation(node), { path: fullPath, actualType: inferType(value) });
             }
             const closure = value;
+            // Spread-aware path: when args contain a SpreadArgNode use bindArgsToParams
+            if (node.args.some((a) => a.type === 'SpreadArg')) {
+                if (!isScriptCallable(closure) && !isApplicationCallable(closure)) {
+                    throw new RuntimeError('RILL-R001', `Spread not supported for built-in callable at '${fullPath}'`, this.getNodeLocation(node));
+                }
+                const boundArgs = await this.bindArgsToParams(node.args, closure, node.span.start);
+                const orderedArgs = closure.params.map((p) => boundArgs.params.get(p.name));
+                return this.invokeCallable(closure, orderedArgs, node.span.start, fullPath);
+            }
             const args = await this.evaluateArgs(node.args);
             // If no explicit args and has pipe input, add pipe value as first arg
             // UNLESS closure has zero parameters (explicit zero-param signature)
@@ -464,6 +480,12 @@ function createClosuresMixin(Base) {
             if (!isScriptCallable(input)) {
                 throw new RuntimeError('RILL-R002', `Cannot invoke non-closure value (got ${typeof input})`, this.getNodeLocation(node));
             }
+            // Spread-aware path: when args contain a SpreadArgNode use bindArgsToParams
+            if (node.args.some((a) => a.type === 'SpreadArg')) {
+                const boundArgs = await this.bindArgsToParams(node.args, input, node.span.start);
+                const orderedArgs = input.params.map((p) => boundArgs.params.get(p.name));
+                return this.invokeScriptCallable(input, orderedArgs, node.span.start);
+            }
             const args = await this.evaluateArgs(node.args);
             return this.invokeScriptCallable(input, args, node.span.start);
         }
@@ -480,6 +502,10 @@ function createClosuresMixin(Base) {
             if (isCallable(receiver)) {
                 throw new RuntimeError('RILL-R003', `Method .${node.name} not available on callable (invoke with -> $() first)`, this.getNodeLocation(node), { methodName: node.name, receiverType: 'callable' });
             }
+            // IR-3: .name on type values returns the typeName string (method path)
+            if (isTypeValue(receiver) && node.name === 'name') {
+                return receiver.typeName;
+            }
             const args = await this.evaluateArgs(node.args);
             if (isDict(receiver)) {
                 const dictValue = receiver[node.name];
@@ -506,35 +532,17 @@ function createClosuresMixin(Base) {
             if (!isCallable(receiver)) {
                 throw new RuntimeError('RILL-R002', `Cannot invoke non-callable value (got ${inferType(receiver)})`, this.getNodeLocation(node), { actualType: inferType(receiver) });
             }
-            const args = await this.evaluateArgs(node.args);
-            return this.invokeCallable(receiver, args, this.getNodeLocation(node));
-        }
-        /**
-         * Evaluate closure chain: >>expr
-         * Chains multiple closures for composition.
-         */
-        async evaluateClosureChain(node, input) {
-            // Evaluate the target expression to get the closure(s)
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const target = await this.evaluateExpression(node.target);
-            if (Array.isArray(target)) {
-                // List of closures: chain them left-to-right
-                let result = input;
-                for (const closure of target) {
-                    if (!isCallable(closure)) {
-                        throw new RuntimeError('RILL-R002', `Closure chain element must be callable, got ${inferType(closure)}`, this.getNodeLocation(node));
-                    }
-                    result = await this.invokeCallable(closure, [result], this.getNodeLocation(node));
+            // Spread-aware path: when args contain a SpreadArgNode use bindArgsToParams
+            if (node.args.some((a) => a.type === 'SpreadArg')) {
+                if (!isScriptCallable(receiver) && !isApplicationCallable(receiver)) {
+                    throw new RuntimeError('RILL-R001', `Spread not supported for built-in callable`, this.getNodeLocation(node));
                 }
-                return result;
-            }
-            else if (isCallable(target)) {
-                // Single closure: invoke with input
-                return this.invokeCallable(target, [input], this.getNodeLocation(node));
-            }
-            else {
-                throw new RuntimeError('RILL-R002', `Closure chain requires callable or list of callables, got ${inferType(target)}`, this.getNodeLocation(node));
+                const boundArgs = await this.bindArgsToParams(node.args, receiver, node.span.start);
+                const orderedArgs = receiver.params.map((p) => boundArgs.params.get(p.name));
+                return this.invokeCallable(receiver, orderedArgs, node.span.start);
             }
+            const args = await this.evaluateArgs(node.args);
+            return this.invokeCallable(receiver, args, this.getNodeLocation(node));
         }
         /**
          * Evaluate annotation reflection access: .^key
@@ -545,9 +553,52 @@ function createClosuresMixin(Base) {
          * Throws RUNTIME_UNDEFINED_ANNOTATION for missing annotations.
          */
         async evaluateAnnotationAccess(value, key, location) {
+            // IR-2: .^type returns a RillTypeValue for any rill value
+            if (key === 'type') {
+                const typeValue = Object.freeze({
+                    __rill_type: true,
+                    typeName: inferType(value),
+                    structure: inferStructuralType(value),
+                });
+                return typeValue;
+            }
+            // IR-3: .name on type values returns the typeName string
+            if (isTypeValue(value) && key === 'name') {
+                return value.typeName;
+            }
+            // IR-2/IR-5: .^input returns the input shape for callable values
+            if (key === 'input') {
+                if (isScriptCallable(value)) {
+                    return value.inputShape;
+                }
+                if (isApplicationCallable(value)) {
+                    if (value.params === undefined) {
+                        // IR-5: untyped host function — no shape available
+                        return false;
+                    }
+                    return paramsToStructuralType(value.params);
+                }
+                // Non-callable: fall through to existing RILL-R003 guard below
+            }
+            // IR-3: .^output returns the declared output contract for callable values
+            if (key === 'output') {
+                if (isScriptCallable(value)) {
+                    if (value.returnShape !== undefined) {
+                        return value.returnShape;
+                    }
+                    // No :type-target declared — return type value `any` (AC-17, AC-18, AC-19)
+                    const anyTypeValue = Object.freeze({
+                        __rill_type: true,
+                        typeName: 'any',
+                        structure: { kind: 'any' },
+                    });
+                    return anyTypeValue;
+                }
+                // Non-callable: fall through to existing RILL-R003 guard below
+            }
             // Only ScriptCallable supports annotation reflection
             if (!isScriptCallable(value)) {
-                throw new RuntimeError('RILL-R003', `Cannot access annotation on ${inferType(value)}`, location, { actualType: inferType(value) });
+                throw new RuntimeError('RILL-R003', `annotation not found: ^${key}`, location, { actualType: inferType(value) });
             }
             // Access annotation from ScriptCallable
             const annotationValue = value.annotations[key];
@@ -557,6 +608,136 @@ function createClosuresMixin(Base) {
             }
             return annotationValue;
         }
+        /**
+         * Bind argument nodes to callable parameters when a SpreadArgNode is present.
+         *
+         * Evaluates positional args LTR, evaluates the spread expression, dispatches
+         * by value type (Tuple, Ordered, or Dict), validates bindings, and returns
+         * a Map of param name → value.
+         *
+         * EC-3: bare ... with null pipe value → RuntimeError
+         * EC-4: spread value is not tuple/dict/ordered → RuntimeError
+         * EC-5: dict spread key matches no parameter → RuntimeError
+         * EC-6: ordered spread key at position N mismatches param at position N → RuntimeError
+         * EC-7: duplicate binding (positional + spread) → RuntimeError
+         * EC-8: missing required parameter after all args processed → RuntimeError
+         * EC-9: extra tuple values exceed param count → RuntimeError
+         * EC-11: ApplicationCallable with no params metadata → RuntimeError
+         */
+        async bindArgsToParams(argNodes, callable, callLocation) {
+            // EC-11: ApplicationCallable must have params metadata for spread to work
+            if (callable.kind === 'application' && callable.params === undefined) {
+                const name = callable.fn.name !== '' ? callable.fn.name : '<anonymous>';
+                throw new RuntimeError('RILL-R001', `Spread not supported for host function '${name}': parameter metadata required`, callLocation);
+            }
+            const params = callable.params;
+            const bound = new Map();
+            // Positional index: next unbound parameter position
+            let positionalIndex = 0;
+            // Save pipe value so evaluating args does not mutate it permanently
+            const savedPipeValue = this.ctx.pipeValue;
+            try {
+                for (const argNode of argNodes) {
+                    if (argNode.type !== 'SpreadArg') {
+                        // Positional argument
+                        const param = params[positionalIndex];
+                        if (param === undefined) {
+                            // Extra positional arg beyond param count — EC-9 reports after spread
+                            // but for pure positional excess, error here with the positional count
+                            throw new RuntimeError('RILL-R001', `Extra positional argument at position ${positionalIndex} (function has ${params.length} parameters)`, callLocation);
+                        }
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        const value = await this.evaluateExpression(argNode);
+                        bound.set(param.name, value);
+                        positionalIndex++;
+                    }
+                    else {
+                        // SpreadArg: evaluate the expression
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        const spreadValue = await this.evaluateExpression(argNode.expression);
+                        // EC-3: bare ... with no pipe value evaluates to null
+                        if (spreadValue === null) {
+                            throw new RuntimeError('RILL-R001', 'Spread requires an active pipe value ($)', callLocation);
+                        }
+                        // Dispatch by type: isOrdered BEFORE isDict per spec (IC-3 algorithm step 2)
+                        if (isTuple(spreadValue)) {
+                            // Tuple: fill remaining params positionally LTR (EC-9)
+                            const tupleEntries = spreadValue.entries;
+                            const remaining = params.length - positionalIndex;
+                            if (tupleEntries.length > remaining) {
+                                throw new RuntimeError('RILL-R001', `Spread tuple has ${tupleEntries.length} values but only ${remaining} parameter(s) remain`, callLocation);
+                            }
+                            for (let i = 0; i < tupleEntries.length; i++) {
+                                const param = params[positionalIndex + i];
+                                // EC-7: duplicate binding
+                                if (bound.has(param.name)) {
+                                    throw new RuntimeError('RILL-R001', `Duplicate binding for parameter '${param.name}': already bound positionally`, callLocation);
+                                }
+                                bound.set(param.name, tupleEntries[i]);
+                            }
+                            positionalIndex += tupleEntries.length;
+                        }
+                        else if (isOrdered(spreadValue)) {
+                            // Ordered: match key by name AND position
+                            // Key at position N within ordered value must match param at (spreadStart + N)
+                            const orderedEntries = spreadValue.entries;
+                            for (let i = 0; i < orderedEntries.length; i++) {
+                                const [key, value] = orderedEntries[i];
+                                const expectedParam = params[positionalIndex + i];
+                                // EC-6: key-order mismatch
+                                if (expectedParam === undefined || expectedParam.name !== key) {
+                                    const expectedName = expectedParam?.name ?? '<none>';
+                                    throw new RuntimeError('RILL-R001', `Ordered spread key '${key}' at position ${i} does not match expected parameter '${expectedName}' at position ${positionalIndex + i}`, callLocation);
+                                }
+                                // EC-7: duplicate binding
+                                if (bound.has(key)) {
+                                    throw new RuntimeError('RILL-R001', `Duplicate binding for parameter '${key}': already bound positionally`, callLocation);
+                                }
+                                bound.set(key, value);
+                            }
+                            positionalIndex += orderedEntries.length;
+                        }
+                        else if (isDict(spreadValue)) {
+                            // Dict: match each key to param by name (order irrelevant)
+                            const dictValue = spreadValue;
+                            const paramNames = new Set(params.map((p) => p.name));
+                            for (const [key, value] of Object.entries(dictValue)) {
+                                // EC-5: key matches no parameter
+                                if (!paramNames.has(key)) {
+                                    const validParams = params.map((p) => p.name).join(', ');
+                                    throw new RuntimeError('RILL-R001', `Dict spread key '${key}' does not match any parameter. Valid parameters: ${validParams}`, callLocation);
+                                }
+                                // EC-7: duplicate binding
+                                if (bound.has(key)) {
+                                    throw new RuntimeError('RILL-R001', `Duplicate binding for parameter '${key}': already bound positionally`, callLocation);
+                                }
+                                bound.set(key, value);
+                            }
+                        }
+                        else {
+                            // EC-4: spread value is not tuple/dict/ordered
+                            const actualType = inferType(spreadValue);
+                            throw new RuntimeError('RILL-R001', `Spread requires a tuple, dict, or ordered value, got ${actualType}`, callLocation);
+                        }
+                    }
+                }
+            }
+            finally {
+                this.ctx.pipeValue = savedPipeValue;
+            }
+            // EC-8: check for missing required parameters
+            for (const param of params) {
+                if (!bound.has(param.name)) {
+                    if (param.defaultValue !== null) {
+                        bound.set(param.name, param.defaultValue);
+                    }
+                    else {
+                        throw new RuntimeError('RILL-R001', `Missing required parameter '${param.name}'`, callLocation);
+                    }
+                }
+            }
+            return { params: bound };
+        }
         /**
          * Evaluate .params property access on closures.
          * Builds dict from closure parameter metadata.