@rcrsr/rill 0.15.0 → 0.17.0

package/dist/runtime/core/context.js

@@ -5,7 +5,8 @@
  * Public API for host applications.
  */
 import { RuntimeError } from '../../types.js';
-import { BUILTIN_FUNCTIONS, BUILTIN_METHODS } from '../ext/builtins.js';
+import { BUILTIN_FUNCTIONS } from '../ext/builtins.js';
+import { BUILT_IN_TYPES } from './type-registrations.js';
 import { bindDictCallables } from './types.js';
 import { inferType } from './values.js';
 import { callable, validateDefaultValueType, } from './callable.js';
@@ -14,72 +15,26 @@ import { callable, validateDefaultValueType, } from './callable.js';
 // chain: pipe form sends 1 arg when signature declares 2 (pipeValue is the first).
 const UNTYPED_BUILTINS = new Set(['log', 'chain']);
 // Built-in methods that do their own internal arg validation with specific error
-// messages expected by protected language tests. Generic validateCallableArgs
+// messages expected by protected language tests. Generic marshalArgs
 // must not fire before the method body's own check.
 export const UNVALIDATED_METHOD_PARAMS = new Set(['has', 'has_any', 'has_all']);
-// Built-in methods that perform their own receiver type checking with specific
-// error messages. Generic RILL-R003 must not fire before the method body runs.
-// Mirrors the old flat-structure convention of receiverTypes: [].
-export const UNVALIDATED_METHOD_RECEIVERS = new Set([
-    'head',
-    'tail',
-    'first',
-    'at',
-    'eq',
-    'ne',
-    'keys',
-    'values',
-    'entries',
-    'has',
-    'has_any',
-    'has_all',
-    'dimensions',
-    'model',
-    'similarity',
-    'dot',
-    'distance',
-    'norm',
-    'normalize',
-]);
 /**
- * Build a ReadonlyMap of frozen ApplicationCallable dicts from an array of
- * [typeName, methods] pairs. Accepts pairs (not a plain object) so the same
- * typeName can appear more than once — duplicate method names across entries
- * for the same type trigger an Error (EC-6).
- *
- * Re-exported from the public barrel index for host integration use.
+ * Derive the set of method names that handle their own receiver type checking.
+ * Collects names from methods where skipReceiverValidation is true.
+ * Methods without the flag default to standard RILL-R003 receiver validation.
  */
-export function buildTypeMethodDicts(pairs) {
-    const registry = new Map();
-    const result = new Map();
-    for (const [typeName, methods] of pairs) {
-        const seen = registry.get(typeName) ?? new Set();
-        registry.set(typeName, seen);
-        const existing = result.get(typeName) ?? {};
-        const dict = { ...existing };
-        for (const [name, fn] of Object.entries(methods)) {
-            if (seen.has(name)) {
-                throw new Error(`Duplicate method '${name}' on type '${typeName}'`);
+function deriveUnvalidatedMethodReceivers(registrations) {
+    const bypass = new Set();
+    for (const reg of registrations) {
+        for (const [name, method] of Object.entries(reg.methods)) {
+            if (method.skipReceiverValidation) {
+                bypass.add(name);
             }
-            seen.add(name);
-            const appCallable = {
-                __type: 'callable',
-                kind: 'application',
-                params: fn.params,
-                returnType: fn.returnType,
-                annotations: fn.annotations ?? {},
-                isProperty: false,
-                fn: fn.fn,
-            };
-            dict[name] = appCallable;
         }
-        result.set(typeName, Object.freeze(dict));
     }
-    return result;
+    return Object.freeze(bypass);
 }
 const BUILTIN_FN_CACHE = new Map();
-const BUILTIN_METHOD_PARAMS_CACHE = new Map();
-const BUILTIN_METHOD_RECEIVER_TYPES_CACHE = new Map();
 function initBuiltinCaches() {
     for (const [name, entry] of Object.entries(BUILTIN_FUNCTIONS)) {
         if (UNTYPED_BUILTINS.has(name)) {
@@ -94,21 +49,6 @@ function initBuiltinCaches() {
         };
         BUILTIN_FN_CACHE.set(name, { appCallable: typedCallable });
     }
-    for (const [typeName, methods] of Object.entries(BUILTIN_METHODS)) {
-        for (const [name, impl] of Object.entries(methods)) {
-            // Accumulate receiver types across all type groups for this method name.
-            // Skip methods that perform their own receiver type checking.
-            if (!UNVALIDATED_METHOD_RECEIVERS.has(name)) {
-                const existing = BUILTIN_METHOD_RECEIVER_TYPES_CACHE.get(name);
-                BUILTIN_METHOD_RECEIVER_TYPES_CACHE.set(name, existing !== undefined ? [...existing, typeName] : [typeName]);
-            }
-            if (!UNVALIDATED_METHOD_PARAMS.has(name)) {
-                if (impl.params.length > 0) {
-                    BUILTIN_METHOD_PARAMS_CACHE.set(name, impl.params);
-                }
-            }
-        }
-    }
 }
 // Initialise once at module load.
 initBuiltinCaches();
@@ -194,15 +134,74 @@ export function createRuntimeContext(options = {}) {
     const resolverConfigs = new Map(options.configurations?.resolvers
         ? Object.entries(options.configurations.resolvers)
         : []);
-    // Build typeMethodDicts fresh per context so duplicate detection (EC-6)
-    // uses isolated state and does not leak across context instances.
-    const typeMethodDicts = buildTypeMethodDicts(Object.entries(BUILTIN_METHODS));
+    // EC-1: Validate no duplicate type names in registrations.
+    const seenTypeNames = new Set();
+    for (const reg of BUILT_IN_TYPES) {
+        if (seenTypeNames.has(reg.name)) {
+            throw new Error(`Duplicate type registration '${reg.name}'`);
+        }
+        seenTypeNames.add(reg.name);
+    }
+    // EC-2: Validate every registration has protocol.format.
+    for (const reg of BUILT_IN_TYPES) {
+        if (!reg.protocol.format) {
+            throw new Error(`Type '${reg.name}' missing required format protocol`);
+        }
+    }
+    // Derive typeNames from registrations (replaces VALID_TYPE_NAMES in context).
+    const typeNames = Object.freeze(BUILT_IN_TYPES.map((r) => r.name));
+    // Derive leafTypes from registrations where isLeaf === true, plus 'any'
+    // which has no registration but rejects type arguments (AC-4).
+    const leafTypes = Object.freeze(new Set([
+        ...BUILT_IN_TYPES.filter((r) => r.isLeaf).map((r) => r.name),
+        'any',
+    ]));
+    // Derive method dicts from registration.methods (absorbs buildTypeMethodDicts
+    // logic). Validates EC-6: duplicate method on same type.
+    const methodRegistry = new Map();
+    const typeMethodDicts = new Map();
+    for (const reg of BUILT_IN_TYPES) {
+        const methods = reg.methods;
+        if (!methods || Object.keys(methods).length === 0)
+            continue;
+        const seen = methodRegistry.get(reg.name) ?? new Set();
+        methodRegistry.set(reg.name, seen);
+        const existing = typeMethodDicts.get(reg.name) ?? {};
+        const dict = { ...existing };
+        for (const [name, fn] of Object.entries(methods)) {
+            if (seen.has(name)) {
+                throw new Error(`Duplicate method '${name}' on type '${reg.name}'`);
+            }
+            seen.add(name);
+            const appCallable = {
+                __type: 'callable',
+                kind: 'application',
+                params: fn.params,
+                returnType: fn.returnType,
+                annotations: fn.annotations ?? {},
+                isProperty: false,
+                fn: fn.fn,
+            };
+            dict[name] = appCallable;
+        }
+        typeMethodDicts.set(reg.name, Object.freeze(dict));
+    }
+    // Derive bypass set from registrations: method names that handle their own
+    // receiver type checking. Generic RILL-R003 must not fire before the method body.
+    const unvalidatedMethodReceivers = deriveUnvalidatedMethodReceivers(BUILT_IN_TYPES);
+    // BC-5: Freeze all derived collections after creation.
+    Object.freeze(typeNames);
+    Object.freeze(typeMethodDicts);
+    // Suppress unused-variable warning for typeNames (consumed in later phases).
+    void typeNames;
     return {
         parent: undefined,
         variables,
         variableTypes,
         functions,
         typeMethodDicts,
+        leafTypes,
+        unvalidatedMethodReceivers,
         callbacks: { ...defaultCallbacks, ...options.callbacks },
         observability: options.observability ?? {},
         pipeValue: null,
@@ -232,6 +231,8 @@ export function createChildContext(parent, overrides) {
         variableTypes: new Map(),
         functions: parent.functions,
         typeMethodDicts: parent.typeMethodDicts,
+        leafTypes: parent.leafTypes,
+        unvalidatedMethodReceivers: parent.unvalidatedMethodReceivers,
         callbacks: parent.callbacks,
         observability: parent.observability,
         pipeValue: parent.pipeValue,
@@ -319,4 +320,3 @@ export function popCallFrame(ctx) {
         ctx.callStack.pop();
     }
 }
-//# sourceMappingURL=context.js.map

package/dist/runtime/core/equals.d.ts

@@ -6,4 +6,3 @@
  */
 import type { ASTNode } from '../../types.js';
 export declare function astEquals(a: ASTNode, b: ASTNode): boolean;
-//# sourceMappingURL=equals.d.ts.map

package/dist/runtime/core/equals.js

@@ -544,7 +544,7 @@ function typeRefStaticEquals(a, b) {
     return typeRefArgListEquals(a.args, b.args);
 }
 /**
- * Compare two optional TypeRefArg arrays for structural equality.
+ * Compare two optional FieldArg arrays for structural equality.
  */
 function typeRefArgListEquals(a, b) {
     const aArgs = a ?? [];
@@ -556,7 +556,9 @@ function typeRefArgListEquals(a, b) {
         const bArg = bArgs[i];
         if (aArg.name !== bArg.name)
             return false;
-        if (!typeRefEquals(aArg.ref, bArg.ref))
+        if (!typeRefEquals(aArg.value, bArg.value))
+            return false;
+        if (!literalNodeEquals(aArg.defaultValue, bArg.defaultValue))
             return false;
     }
     return true;
@@ -578,4 +580,34 @@ function typeRefEquals(a, b) {
     }
     return false;
 }
-//# sourceMappingURL=equals.js.map
+/**
+ * Compare two optional LiteralNode values for structural equality.
+ * Both-undefined returns true. One-undefined returns false.
+ * Complex nodes (ListLiteral, Dict, Closure) return false defensively.
+ */
+function literalNodeEquals(a, b) {
+    if (a === undefined && b === undefined)
+        return true;
+    if (a === undefined || b === undefined)
+        return false;
+    if (a.type !== b.type)
+        return false;
+    switch (a.type) {
+        case 'NumberLiteral':
+            return a.value === b.value;
+        case 'BoolLiteral':
+            return a.value === b.value;
+        case 'StringLiteral': {
+            const bStr = b;
+            if (a.parts.length !== 1 || bStr.parts.length !== 1)
+                return false;
+            return a.parts[0] === bStr.parts[0];
+        }
+        case 'ListLiteral':
+        case 'Dict':
+        case 'Closure':
+            return false;
+        default:
+            return false;
+    }
+}

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

@@ -62,4 +62,3 @@ export declare class EvaluatorBase {
      */
     protected accessDictField(value: RillValue, field: string, location?: SourceLocation, allowMissing?: boolean): Promise<RillValue>;
 }
-//# sourceMappingURL=base.d.ts.map

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

@@ -112,4 +112,3 @@ export class EvaluatorBase {
         return dictValue;
     }
 }
-//# sourceMappingURL=base.js.map

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

@@ -122,4 +122,3 @@ export type Evaluator = InstanceType<typeof Evaluator>;
  * @internal
  */
 export declare function getEvaluator(ctx: RuntimeContext): InstanceType<typeof Evaluator>;
-//# sourceMappingURL=evaluator.d.ts.map

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

@@ -151,4 +151,3 @@ export function getEvaluator(ctx) {
     }
     return evaluator;
 }
-//# sourceMappingURL=evaluator.js.map

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

@@ -9,7 +9,7 @@
 import type { AnnotatedStatementNode, ASTNode, CaptureNode, ExpressionNode, RillTypeName, SourceLocation, StatementNode } from '../../../types.js';
 import type { RillCallable } from '../callable.js';
 import type { RuntimeContext } from '../types.js';
-import type { RillValue, RillType } from '../values.js';
+import type { RillValue, TypeStructure } from '../values.js';
 /**
  * Capture information returned by handleCapture.
  */
@@ -39,7 +39,7 @@ export declare function handleCapture(capture: CaptureNode | null, value: RillVa
  * 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 | RillType, location?: SourceLocation): RillValue;
+export declare function assertType(value: RillValue, expected: RillTypeName | TypeStructure, location?: SourceLocation): RillValue;
 /**
  * Evaluate an expression and return its value.
  * Main entry point for expression evaluation.
@@ -69,4 +69,3 @@ export declare function getAnnotation(ctx: RuntimeContext, key: string): RillVal
  * @param location - Optional call site location for error reporting
  */
 export declare function invokeCallable(callable: RillCallable, args: RillValue[], ctx: RuntimeContext, location?: SourceLocation): Promise<RillValue>;
-//# sourceMappingURL=index.d.ts.map

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

@@ -70,6 +70,17 @@ export function assertType(value, expected, location) {
         resolverConfigs: new Map(),
         resolvingSchemes: new Set(),
         typeMethodDicts: new Map(),
+        leafTypes: new Set([
+            'string',
+            'number',
+            'bool',
+            'vector',
+            'type',
+            'any',
+            'closure',
+            'field_descriptor',
+        ]),
+        unvalidatedMethodReceivers: new Set(),
     };
     const evaluator = getEvaluator(minimalContext);
     return evaluator.assertType(value, expected, location);
@@ -117,4 +128,3 @@ export async function invokeCallable(callable, args, ctx, location) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return evaluator.invokeCallable(callable, args, location);
 }
-//# sourceMappingURL=index.js.map

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

@@ -16,4 +16,3 @@
  * @internal
  */
 export declare const AnnotationsMixin: any;
-//# sourceMappingURL=annotations.d.ts.map

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

@@ -149,4 +149,3 @@ function createAnnotationsMixin(Base) {
 // 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/closures.d.ts

@@ -42,4 +42,3 @@
  * @internal
  */
 export declare const ClosuresMixin: any;
-//# sourceMappingURL=closures.d.ts.map

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

@@ -42,9 +42,9 @@
  * @internal
  */
 import { RillError, RuntimeError } from '../../../../types.js';
-import { isCallable, isScriptCallable, isApplicationCallable, isDict, validateCallableArgs, paramsToStructuralType, } from '../../callable.js';
-import { getVariable, pushCallFrame, popCallFrame, UNVALIDATED_METHOD_PARAMS, UNVALIDATED_METHOD_RECEIVERS, } from '../../context.js';
-import { inferType, isTypeValue, isTuple, isOrdered, createOrdered, inferStructuralType, structuralTypeMatches, formatStructuralType, anyTypeValue, } from '../../values.js';
+import { isCallable, isScriptCallable, isApplicationCallable, isDict, marshalArgs, } from '../../callable.js';
+import { getVariable, pushCallFrame, popCallFrame, UNVALIDATED_METHOD_PARAMS, } from '../../context.js';
+import { inferType, isTypeValue, isTuple, isOrdered, paramToFieldDef, inferStructure, structureMatches, formatStructure, anyTypeValue, structureToTypeValue, } from '../../values.js';
 /**
  * ClosuresMixin implementation.
  *
@@ -153,14 +153,22 @@ function createClosuresMixin(Base) {
         async invokeFnCallable(callable, args, callLocation, functionName = 'callable') {
             // Apply boundDict BEFORE validation (property-style callables need dict as first arg)
             const effectiveArgs = callable.boundDict && args.length === 0 ? [callable.boundDict] : args;
-            // Validate arguments for typed ApplicationCallable (task 1.5)
+            // Marshal arguments for typed ApplicationCallable (IC-1).
             // Skip when params is undefined (untyped callable() factory).
-            // Explicitly registered zero-param callables have params: [] and still validate.
+            // Untyped callables still receive RillValue[] cast as Record to preserve
+            // existing runtime behavior without changing the fn contract.
+            let fnArgs;
             if (isApplicationCallable(callable) && callable.params !== undefined) {
-                validateCallableArgs(effectiveArgs, callable.params, functionName, callLocation);
+                fnArgs = marshalArgs(effectiveArgs, callable.params, {
+                    functionName,
+                    location: callLocation,
+                });
+            }
+            else {
+                fnArgs = effectiveArgs;
             }
             try {
-                const result = callable.fn(effectiveArgs, this.ctx, callLocation);
+                const result = callable.fn(fnArgs, this.ctx, callLocation);
                 return result instanceof Promise ? await result : result;
             }
             catch (error) {
@@ -207,8 +215,8 @@ function createClosuresMixin(Base) {
         validateParamType(param, value, callLocation) {
             if (param.type === undefined)
                 return;
-            if (!structuralTypeMatches(value, param.type)) {
-                const expectedType = formatStructuralType(param.type);
+            if (!structureMatches(value, param.type)) {
+                const expectedType = formatStructure(param.type);
                 const actualType = inferType(value);
                 throw new RuntimeError('RILL-R001', `Parameter type mismatch: ${param.name} expects ${expectedType}, got ${actualType}`, callLocation, { paramName: param.name, expectedType, actualType });
             }
@@ -219,28 +227,20 @@ function createClosuresMixin(Base) {
          */
         async invokeScriptCallable(callable, args, callLocation) {
             const callableCtx = this.createCallableContext(callable);
-            // Validate excess arguments (EC-8)
-            if (args.length > callable.params.length) {
-                throw new RuntimeError('RILL-R001', `Function expects ${callable.params.length} arguments, got ${args.length}`, callLocation);
+            // Marshal positional args to named record (IC-1).
+            // Script callables always have params defined.
+            const record = marshalArgs(args, callable.params, {
+                functionName: '<anonymous>',
+                location: callLocation,
+            });
+            // Bind each named value into the callable context.
+            for (const [name, value] of Object.entries(record)) {
+                callableCtx.variables.set(name, value);
             }
-            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 !== undefined) {
-                    value = param.defaultValue;
-                }
-                else {
-                    throw new RuntimeError('RILL-R001', `Missing argument for parameter '${param.name}' at position ${i}`, callLocation, { paramName: param.name, position: i });
-                }
-                this.validateParamType(param, value, callLocation);
-                callableCtx.variables.set(param.name, value);
-                // Block-closures have param named '$': sync with pipeValue for bare $ references
-                if (param.name === '$') {
-                    callableCtx.pipeValue = value;
-                }
+            // IR-4: Block closure pipe sync — first param named '$' means block closure.
+            // Sync pipeValue so bare '$' references resolve correctly inside the body.
+            if (callable.params[0]?.name === '$') {
+                callableCtx.pipeValue = record['$'];
             }
             // EC-1: Reject empty block bodies before execution (AC-17)
             if (callable.body.type === 'Block' &&
@@ -541,13 +541,13 @@ function createClosuresMixin(Base) {
                 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)
-            // IR-4: .signature on type values returns formatStructuralType(structure)
+            // IR-4: .signature on type values returns formatStructure(structure)
             if (isTypeValue(receiver)) {
                 if (node.name === 'name') {
                     return receiver.typeName;
                 }
                 if (node.name === 'signature') {
-                    return formatStructuralType(receiver.structure);
+                    return formatStructure(receiver.structure);
                 }
             }
             const args = await this.evaluateArgs(node.args);
@@ -557,23 +557,39 @@ function createClosuresMixin(Base) {
             const typeDict = this.ctx.typeMethodDicts.get(typeName);
             const typeMethod = typeDict?.[node.name];
             if (typeMethod !== undefined && isApplicationCallable(typeMethod)) {
-                // AC-24 (EC-7): validate method args via typeMethod.params when set.
-                // Methods in UNVALIDATED_METHOD_PARAMS handle their own arg validation
-                // with specific error messages; skip generic validation for them.
-                if (!UNVALIDATED_METHOD_PARAMS.has(node.name) &&
-                    typeMethod.params !== undefined &&
-                    typeMethod.params.length > 0) {
-                    validateCallableArgs(args, typeMethod.params, node.name, this.getNodeLocation(node));
-                }
-                // buildMethodEntry wraps fn(args) where args[0] = receiver and args[1..] = method args
-                // Invoke fn directly to preserve the receiver-as-first-arg contract without
-                // triggering invokeCallable's arity validation (params counts method args only)
+                // IC-1: marshalArgs handles type method dispatch.
+                // effectiveArgs prepends receiver as first element; after task 2.3 typeMethod.params
+                // will include the receiver param so the counts align.
+                // UNVALIDATED_METHOD_PARAMS methods handle their own validation internally;
+                // skip marshalArgs for them and pass the positional array via cast.
+                const callLocation = this.getNodeLocation(node);
+                const effectiveArgs = [receiver, ...args];
+                let methodArgs;
+                if (typeMethod.params === undefined) {
+                    // Untyped method: pass positional array via cast.
+                    methodArgs = effectiveArgs;
+                }
+                else if (UNVALIDATED_METHOD_PARAMS.has(node.name)) {
+                    // UNVALIDATED_METHOD_PARAMS: method handles its own arity and type
+                    // validation with custom error messages. Pass the actual user args
+                    // via __positionalArgs so buildMethodEntry reconstructs positionalArgs
+                    // with the correct length, letting method body arity checks fire.
+                    methodArgs = {
+                        receiver,
+                        __positionalArgs: args,
+                    };
+                }
+                else {
+                    methodArgs = marshalArgs(effectiveArgs, typeMethod.params, {
+                        functionName: node.name,
+                        location: callLocation,
+                    });
+                }
                 try {
-                    const result = typeMethod.fn([receiver, ...args], this.ctx, this.getNodeLocation(node));
+                    const result = typeMethod.fn(methodArgs, this.ctx, callLocation);
                     return result instanceof Promise ? await result : result;
                 }
                 catch (error) {
-                    const callLocation = this.getNodeLocation(node);
                     if (error instanceof RuntimeError &&
                         !error.location &&
                         callLocation) {
@@ -601,10 +617,10 @@ function createClosuresMixin(Base) {
                 throw new RuntimeError('RILL-R009', `Property '${node.name}' not found on type value (available: name, signature)`, this.getNodeLocation(node), { property: node.name, type: 'type value' });
             }
             // RILL-R003: method exists on other types but not this receiver's type.
-            // Methods in UNVALIDATED_METHOD_RECEIVERS handle their own receiver validation
+            // Methods in unvalidatedMethodReceivers handle their own receiver validation
             // with specific error messages; skip generic RILL-R003 for them and let the
             // method body run its own check (they exist in at least one type dict).
-            if (!UNVALIDATED_METHOD_RECEIVERS.has(node.name)) {
+            if (!this.ctx.unvalidatedMethodReceivers.has(node.name)) {
                 const supportedTypes = [];
                 for (const [dictType, dict] of this.ctx.typeMethodDicts) {
                     if (dict[node.name] !== undefined) {
@@ -616,14 +632,25 @@ function createClosuresMixin(Base) {
                 }
             }
             else {
-                // UNVALIDATED_METHOD_RECEIVERS: dispatch to the method in ANY type dict so the
+                // unvalidatedMethodReceivers: dispatch to the method in ANY type dict so the
                 // method body can run its own custom receiver validation and error message.
                 for (const [, dict] of this.ctx.typeMethodDicts) {
                     const fallbackMethod = dict[node.name];
                     if (fallbackMethod !== undefined &&
                         isApplicationCallable(fallbackMethod)) {
                         try {
-                            const result = fallbackMethod.fn([receiver, ...args], this.ctx, this.getNodeLocation(node));
+                            // Unvalidated methods handle their own receiver validation.
+                            // Build named record with receiver so buildMethodEntry extracts it correctly;
+                            // the method body performs its own receiver type check with a custom error.
+                            const fbMethodArgs = { receiver };
+                            if (fallbackMethod.params) {
+                                for (let i = 1; i < fallbackMethod.params.length; i++) {
+                                    const p = fallbackMethod.params[i];
+                                    if (p)
+                                        fbMethodArgs[p.name] = args[i - 1] ?? null;
+                                }
+                            }
+                            const result = fallbackMethod.fn(fbMethodArgs, this.ctx, this.getNodeLocation(node));
                             return result instanceof Promise ? await result : result;
                         }
                         catch (error) {
@@ -679,7 +706,7 @@ function createClosuresMixin(Base) {
                 const typeValue = Object.freeze({
                     __rill_type: true,
                     typeName: inferType(value),
-                    structure: inferStructuralType(value),
+                    structure: inferStructure(value),
                 });
                 return typeValue;
             }
@@ -695,16 +722,16 @@ function createClosuresMixin(Base) {
             if (key === 'description') {
                 return value.annotations['description'] ?? {};
             }
-            // IR-3: ^input computes from callable.params via paramsToStructuralType() for all kinds
-            // Params are converted from internal tuples to RillOrdered so the
-            // value survives rill's homogeneous-list constraint.
+            // IR-3: ^input computes from callable.params for all kinds.
+            // Each param's RillType is converted to a RillTypeValue so it is recognized
+            // as a type token (not a plain dict) in rill's type system.
             if (key === 'input') {
                 // Untyped host callables have params set to undefined at runtime (see callable() factory)
                 if (value.params === undefined) {
-                    return createOrdered([]);
+                    return structureToTypeValue({ kind: 'ordered', fields: [] });
                 }
-                const shape = paramsToStructuralType(value.params);
-                return createOrdered(shape.params);
+                const fields = value.params.map((param) => paramToFieldDef(param.name, param.type ?? { kind: 'any' }, param.defaultValue));
+                return structureToTypeValue({ kind: 'ordered', fields });
             }
             // IR-3: ^output reads callable.returnType directly for all kinds
             if (key === 'output') {
@@ -723,7 +750,14 @@ function createClosuresMixin(Base) {
          *
          * 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.
+         * a BoundArgs map of param name → value.
+         *
+         * Output is compatible with marshalArgs stages 2-3 (IR-1):
+         * - All params present in returned map (defaults applied, missing required throws)
+         * - Stage 1 (excess args) is NOT checked here; bindArgsToParams validates arity
+         *   differently per spread source type (tuple length, dict key match, etc.)
+         * - Phase 2 callers convert BoundArgs.params to positional RillValue[] then
+         *   feed into marshalArgs stages 2-3 for type-checking
          *
          * EC-3: bare ... with null pipe value → RuntimeError
          * EC-4: spread value is not tuple/dict/ordered → RuntimeError
@@ -835,17 +869,6 @@ function createClosuresMixin(Base) {
             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 && param.defaultValue !== undefined) {
-                        bound.set(param.name, param.defaultValue);
-                    }
-                    else {
-                        throw new RuntimeError('RILL-R001', `Missing required parameter '${param.name}'`, callLocation);
-                    }
-                }
-            }
             return { params: bound };
         }
         /**
@@ -871,7 +894,7 @@ function createClosuresMixin(Base) {
                 const paramEntry = {};
                 // Add type field if param has type annotation
                 if (param.type !== undefined) {
-                    paramEntry['type'] = formatStructuralType(param.type);
+                    paramEntry['type'] = formatStructure(param.type);
                 }
                 // Add __annotations field if param has parameter-level annotations
                 if (Object.keys(param.annotations).length > 0) {
@@ -887,4 +910,3 @@ function createClosuresMixin(Base) {
 // TypeScript can't generate declarations for functions returning classes with protected members
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const ClosuresMixin = createClosuresMixin;
-//# sourceMappingURL=closures.js.map

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

@@ -21,4 +21,3 @@
  * @internal
  */
 export declare const CollectionsMixin: any;
-//# sourceMappingURL=collections.d.ts.map