@rcrsr/rill 0.14.0 → 0.16.0

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 { isCallable, isScriptCallable, isApplicationCallable, isDict, marshalArgs, } 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 { inferType, isTypeValue, isTuple, isOrdered, paramToFieldDef, inferStructuralType, structuralTypeMatches, formatStructuralType, anyTypeValue, rillTypeToTypeValue, } 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) {
@@ -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' &&
@@ -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) {
@@ -623,7 +639,18 @@ function createClosuresMixin(Base) {
                     if (fallbackMethod !== undefined &&
                         isApplicationCallable(fallbackMethod)) {
                         try {
-                            const result = fallbackMethod.fn([receiver, ...args], this.ctx, this.getNodeLocation(node));
+                            // UNVALIDATED_METHOD_RECEIVERS 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) {
@@ -695,25 +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 false;
-                }
-                const shape = paramsToStructuralType(value.params);
-                if (shape.type === 'closure') {
-                    return {
-                        type: shape.type,
-                        params: createOrdered(shape.params),
-                        // Use callable.returnType.structure so :type-target return annotation is reflected
-                        // Fall back to { type: 'any' } for callables without returnType (legacy construction)
-                        ret: value.returnType?.structure ?? { type: 'any' },
-                    };
+                    return rillTypeToTypeValue({ type: 'ordered', fields: [] });
                 }
-                return shape;
+                const fields = value.params.map((param) => paramToFieldDef(param.name, param.type ?? { type: 'any' }, param.defaultValue));
+                return rillTypeToTypeValue({ type: 'ordered', fields });
             }
             // IR-3: ^output reads callable.returnType directly for all kinds
             if (key === 'output') {
@@ -732,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
@@ -844,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 };
         }
         /**
@@ -896,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

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

@@ -24,7 +24,7 @@ import { RuntimeError } from '../../../../types.js';
 import { inferType, isRillIterator, isVector } from '../../values.js';
 import { createChildContext, getVariable } from '../../context.js';
 import { BreakSignal } from '../../signals.js';
-import { isCallable, isDict } from '../../callable.js';
+import { isCallable, isDict, marshalArgs } from '../../callable.js';
 import { getEvaluator } from '../evaluator.js';
 /**
  * Default maximum iteration count for iterators.
@@ -223,9 +223,15 @@ function createCollectionsMixin(Base) {
                     if (accumulator !== null) {
                         args.push(accumulator);
                     }
-                    // Handle both CallableFn and ApplicationCallable (task 1.5 will refactor validation)
                     const fnToCall = typeof fn === 'function' ? fn : fn.fn;
-                    return fnToCall(args, this.ctx, body.span.start);
+                    // Marshal args to named record if fn has params; cast otherwise (IC-1).
+                    const callArgs = typeof fn !== 'function' && fn.params !== undefined
+                        ? marshalArgs(args, fn.params, {
+                            functionName: body.name,
+                            location: body.span.start,
+                        })
+                        : args;
+                    return fnToCall(callArgs, this.ctx, body.span.start);
                 }
                 default: {
                     // TypeScript exhaustiveness check - should never reach here
@@ -509,4 +515,3 @@ function createCollectionsMixin(Base) {
 // TypeScript can't generate declarations for functions returning classes with protected members
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const CollectionsMixin = createCollectionsMixin;
-//# sourceMappingURL=collections.js.map

package/dist/runtime/core/eval/mixins/control-flow.d.ts

@@ -24,4 +24,3 @@
  * @internal
  */
 export declare const ControlFlowMixin: any;
-//# sourceMappingURL=control-flow.d.ts.map

package/dist/runtime/core/eval/mixins/control-flow.js

@@ -453,4 +453,3 @@ function createControlFlowMixin(Base) {
 // TypeScript can't generate declarations for functions returning classes with protected members
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const ControlFlowMixin = createControlFlowMixin;
-//# sourceMappingURL=control-flow.js.map

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

@@ -27,4 +27,3 @@
  * @internal
  */
 export declare const ConversionMixin: any;
-//# sourceMappingURL=conversion.d.ts.map

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

@@ -27,7 +27,7 @@
  * @internal
  */
 import { RuntimeError } from '../../../../types.js';
-import { inferType, isTuple, isOrdered, isTypeValue, createOrdered, createTuple, formatValue, } from '../../values.js';
+import { inferType, isTuple, isOrdered, isTypeValue, createOrdered, createTuple, formatValue, deepCopyRillValue, hasCollectionFields, emptyForType, } from '../../values.js';
 import { isDict } from '../../callable.js';
 import { getVariable } from '../../context.js';
 /**
@@ -54,10 +54,31 @@ function createConversionMixin(Base) {
             const typeRef = node.typeRef;
             // Structural type constructor: :>ordered(name: type, ...) or :>list(T), :>dict(...), :>tuple(...)
             if (isTypeConstructorNode(typeRef)) {
-                if (typeRef.constructorName === 'ordered') {
-                    return this.convertToOrderedWithSig(input, typeRef, node);
+                // For dict/ordered/tuple, evaluate the type constructor to determine
+                // uniform (valueType) vs structural (fields/elements) dispatch.
+                if (typeRef.constructorName === 'ordered' ||
+                    typeRef.constructorName === 'dict' ||
+                    typeRef.constructorName === 'tuple') {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const typeValue = await this.evaluateTypeConstructor(typeRef);
+                    const structure = typeValue.structure;
+                    // Uniform types (valueType present): use general convert-then-assert path
+                    if ('valueType' in structure && structure.valueType) {
+                        const result = this.applyConversion(input, typeRef.constructorName, node);
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        this.assertType(result, structure, node.span.start);
+                        return result;
+                    }
+                    // Structural types (fields/elements present): use structural-specific handlers
+                    if (typeRef.constructorName === 'ordered') {
+                        return this.convertToOrderedWithSig(input, typeRef, node);
+                    }
+                    if (typeRef.constructorName === 'dict') {
+                        return this.convertToDictWithSig(input, typeRef, node);
+                    }
+                    return this.convertToTupleWithSig(input, typeRef, node);
                 }
-                // Non-ordered constructors: convert first, then assert structural type
+                // Non-dict/ordered/tuple constructors: convert first, then assert structural type
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 const typeValue = await this.evaluateTypeConstructor(typeRef);
                 const result = this.applyConversion(input, typeRef.constructorName, node);
@@ -194,26 +215,253 @@ function createConversionMixin(Base) {
             return formatValue(input);
         }
         /**
-         * Convert dict -> :>ordered(field: type, ...) using structural signature.
-         * Extracts fields in the order specified by the signature.
+         * Convert dict -> :>ordered(field: type = default, ...) using structural signature.
+         *
+         * - Input must be a dict (else RILL-R036)
+         * - Iterates signature fields in declaration order
+         * - Missing field with default: inserts deep copy of default value
+         * - Missing field without default: emits RILL-R044
+         * - Extra keys not in signature: omitted from result
          */
-        convertToOrderedWithSig(input, sigNode, node) {
-            if (!isDict(input)) {
+        async convertToOrderedWithSig(input, sigNode, node) {
+            let dictInput;
+            if (isOrdered(input)) {
+                dictInput = Object.fromEntries(input.entries);
+            }
+            else if (isDict(input)) {
+                dictInput = input;
+            }
+            else {
                 throw new RuntimeError('RILL-R036', `cannot convert ${inferType(input)} to ordered`, this.getNodeLocation(node), { source: inferType(input), target: 'ordered' });
             }
-            const dictInput = input;
+            const sourceType = isOrdered(input) ? 'ordered' : 'dict';
+            // Evaluate the full type constructor to get resolved fields with defaults.
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const typeValue = await this.evaluateTypeConstructor(sigNode);
+            const resolvedFields = typeValue.structure.type === 'ordered' && typeValue.structure.fields
+                ? typeValue.structure.fields
+                : [];
             const entries = [];
+            for (const field of resolvedFields) {
+                const fieldName = field.name;
+                if (fieldName in dictInput) {
+                    let fieldValue = dictInput[fieldName];
+                    fieldValue = this.hydrateNested(fieldValue, field.type, node);
+                    entries.push([fieldName, fieldValue]);
+                }
+                else if (field.defaultValue !== undefined) {
+                    entries.push([
+                        fieldName,
+                        this.hydrateNested(deepCopyRillValue(field.defaultValue), field.type, node),
+                    ]);
+                }
+                else if (hasCollectionFields(field.type)) {
+                    entries.push([
+                        fieldName,
+                        this.hydrateNested(emptyForType(field.type), field.type, node),
+                    ]);
+                }
+                else {
+                    throw new RuntimeError('RILL-R044', `cannot convert ${sourceType} to ordered: missing required field '${fieldName}'`, this.getNodeLocation(node), { source: sourceType, target: 'ordered' });
+                }
+            }
+            return createOrdered(entries);
+        }
+        /**
+         * Convert dict -> :>dict(field: type = default, ...) using structural signature [IR-4].
+         *
+         * - Input must be a dict (else RILL-R036)
+         * - Iterates signature fields in declaration order
+         * - Missing field with default: inserts deep copy of default value
+         * - Missing field without default: emits RILL-R044
+         * - Extra keys not in signature: omitted from result
+         * - Recurses into nested dict-typed fields for nested hydration
+         */
+        async convertToDictWithSig(input, sigNode, node) {
+            let dictInput;
+            if (isOrdered(input)) {
+                dictInput = Object.fromEntries(input.entries);
+            }
+            else if (isDict(input)) {
+                dictInput = input;
+            }
+            else {
+                throw new RuntimeError('RILL-R036', `cannot convert ${inferType(input)} to dict`, this.getNodeLocation(node), { source: inferType(input), target: 'dict' });
+            }
+            const sourceType = isOrdered(input) ? 'ordered' : 'dict';
+            // Evaluate the full type constructor to get resolved fields with defaults.
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const typeValue = await this.evaluateTypeConstructor(sigNode);
+            const resolvedFields = typeValue.structure.type === 'dict' && typeValue.structure.fields
+                ? typeValue.structure.fields
+                : {};
+            const result = {};
             for (const arg of sigNode.args) {
-                if (arg.kind !== 'named') {
-                    throw new RuntimeError('RILL-R037', 'dict to ordered conversion requires structural type signature', this.getNodeLocation(node));
+                if (arg.name === undefined) {
+                    continue;
                 }
                 const fieldName = arg.name;
-                if (!(fieldName in dictInput)) {
-                    throw new RuntimeError('RILL-R036', `cannot convert dict to ordered: missing field '${fieldName}'`, this.getNodeLocation(node), { source: 'dict', target: 'ordered' });
+                const resolvedField = resolvedFields[fieldName];
+                if (fieldName in dictInput) {
+                    // Field present in input: use it, recursing if the field type is a nested dict
+                    let fieldValue = dictInput[fieldName];
+                    if (resolvedField !== undefined) {
+                        fieldValue = this.hydrateNested(fieldValue, resolvedField.type, node);
+                    }
+                    result[fieldName] = fieldValue;
+                }
+                else {
+                    // Field missing from input: use default if available, else error
+                    if (resolvedField !== undefined &&
+                        resolvedField.defaultValue !== undefined) {
+                        result[fieldName] = this.hydrateNested(deepCopyRillValue(resolvedField.defaultValue), resolvedField.type, node);
+                    }
+                    else if (resolvedField !== undefined &&
+                        hasCollectionFields(resolvedField.type)) {
+                        result[fieldName] = this.hydrateNested(emptyForType(resolvedField.type), resolvedField.type, node);
+                    }
+                    else {
+                        throw new RuntimeError('RILL-R044', `cannot convert ${sourceType} to dict: missing required field '${fieldName}'`, this.getNodeLocation(node), { source: sourceType, target: 'dict' });
+                    }
                 }
-                entries.push([fieldName, dictInput[fieldName]]);
             }
-            return createOrdered(entries);
+            return result;
+        }
+        /**
+         * Convert tuple/list -> :>tuple(type, ...) using structural signature [IR-5].
+         *
+         * - Input must be a tuple or list (else RILL-R036)
+         * - Iterates signature elements in declaration order
+         * - Missing trailing element with default: inserts deep copy of default value
+         * - Missing element without default: emits RILL-R044 with position
+         * - Extra elements beyond signature length: omitted from result
+         */
+        async convertToTupleWithSig(input, sigNode, node) {
+            const isTupleInput = isTuple(input);
+            const isListInput = Array.isArray(input) && !isTupleInput && !isOrdered(input);
+            if (!isTupleInput && !isListInput) {
+                throw new RuntimeError('RILL-R036', `cannot convert ${inferType(input)} to tuple`, this.getNodeLocation(node), { source: inferType(input), target: 'tuple' });
+            }
+            // Evaluate the full type constructor to get resolved elements with defaults.
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const typeValue = await this.evaluateTypeConstructor(sigNode);
+            const resolvedElements = typeValue.structure.type === 'tuple' && typeValue.structure.elements
+                ? typeValue.structure.elements
+                : [];
+            const inputEntries = isTupleInput
+                ? input.entries
+                : input;
+            const result = [];
+            for (let i = 0; i < resolvedElements.length; i++) {
+                const element = resolvedElements[i];
+                if (i < inputEntries.length) {
+                    // Element present in input: recurse into nested types
+                    result.push(this.hydrateNested(inputEntries[i], element.type, node));
+                }
+                else if (element.defaultValue !== undefined) {
+                    // Missing trailing element with default: deep copy and hydrate
+                    result.push(this.hydrateNested(deepCopyRillValue(element.defaultValue), element.type, node));
+                }
+                else if (hasCollectionFields(element.type)) {
+                    // Missing element with collection type: seed empty and hydrate
+                    result.push(this.hydrateNested(emptyForType(element.type), element.type, node));
+                }
+                else {
+                    // Missing element without default
+                    throw new RuntimeError('RILL-R044', `cannot convert ${inferType(input)} to tuple: missing required element at position ${i}`, this.getNodeLocation(node), { source: inferType(input), target: 'tuple' });
+                }
+            }
+            return createTuple(result);
+        }
+        /**
+         * Recursively hydrate a value against a nested dict, ordered, or tuple RillType.
+         * Only applies when the field type has explicit fields/elements.
+         * Returns the value unchanged if the type has no fields or the value type does not match.
+         */
+        hydrateNested(value, fieldType, node) {
+            if (fieldType.type === 'dict' && fieldType.fields && isDict(value)) {
+                const dictValue = value;
+                const result = {};
+                for (const [fieldName, resolvedField] of Object.entries(fieldType.fields)) {
+                    if (fieldName in dictValue) {
+                        const fieldValue = this.hydrateNested(dictValue[fieldName], resolvedField.type, node);
+                        result[fieldName] = fieldValue;
+                    }
+                    else {
+                        if (resolvedField.defaultValue !== undefined) {
+                            result[fieldName] = this.hydrateNested(deepCopyRillValue(resolvedField.defaultValue), resolvedField.type, node);
+                        }
+                        else if (hasCollectionFields(resolvedField.type)) {
+                            result[fieldName] = this.hydrateNested(emptyForType(resolvedField.type), resolvedField.type, node);
+                        }
+                        else {
+                            throw new RuntimeError('RILL-R044', `cannot convert dict to dict: missing required field '${fieldName}'`, this.getNodeLocation(node), { source: 'dict', target: 'dict' });
+                        }
+                    }
+                }
+                return result;
+            }
+            else if (fieldType.type === 'ordered' && fieldType.fields) {
+                // Only hydrate if the runtime value is an ordered or dict; return unchanged otherwise.
+                if (!isOrdered(value) && !isDict(value)) {
+                    return value;
+                }
+                const source = isOrdered(value) ? 'ordered' : 'dict';
+                // Build a key->value lookup from either an ordered value or a dict value.
+                const lookup = new Map(isOrdered(value)
+                    ? value.entries.map(([k, v]) => [k, v])
+                    : Object.entries(value));
+                const resultEntries = [];
+                for (const field of fieldType.fields) {
+                    const name = field.name;
+                    if (lookup.has(name)) {
+                        const fieldValue = this.hydrateNested(lookup.get(name), field.type, node);
+                        resultEntries.push([name, fieldValue]);
+                    }
+                    else if (field.defaultValue !== undefined) {
+                        resultEntries.push([
+                            name,
+                            this.hydrateNested(deepCopyRillValue(field.defaultValue), field.type, node),
+                        ]);
+                    }
+                    else if (hasCollectionFields(field.type)) {
+                        resultEntries.push([
+                            name,
+                            this.hydrateNested(emptyForType(field.type), field.type, node),
+                        ]);
+                    }
+                    else {
+                        throw new RuntimeError('RILL-R044', `cannot convert ${source} to ordered: missing required field '${name}'`, this.getNodeLocation(node), { source, target: 'ordered' });
+                    }
+                }
+                return createOrdered(resultEntries);
+            }
+            else if (fieldType.type === 'tuple' && fieldType.elements) {
+                // Only hydrate if the runtime value is a tuple; return unchanged otherwise.
+                if (!isTuple(value)) {
+                    return value;
+                }
+                const inputEntries = value.entries;
+                const resultEntries = [];
+                for (let i = 0; i < fieldType.elements.length; i++) {
+                    const element = fieldType.elements[i];
+                    if (i < inputEntries.length) {
+                        const elementValue = this.hydrateNested(inputEntries[i], element.type, node);
+                        resultEntries.push(elementValue);
+                    }
+                    else if (element.defaultValue !== undefined) {
+                        resultEntries.push(this.hydrateNested(deepCopyRillValue(element.defaultValue), element.type, node));
+                    }
+                    else if (hasCollectionFields(element.type)) {
+                        resultEntries.push(this.hydrateNested(emptyForType(element.type), element.type, node));
+                    }
+                    else {
+                        throw new RuntimeError('RILL-R044', `cannot convert tuple to tuple: missing required element at position ${i}`, this.getNodeLocation(node), { source: 'tuple', target: 'tuple' });
+                    }
+                }
+                return createTuple(resultEntries);
+            }
+            return value;
         }
         /** Throw EC-10 incompatible conversion error. */
         throwIncompatible(source, target, node) {
@@ -230,4 +478,3 @@ function isTypeConstructorNode(ref) {
 // Export with type assertion to work around TS4094 limitation
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const ConversionMixin = createConversionMixin;
-//# sourceMappingURL=conversion.js.map

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

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

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

@@ -753,4 +753,3 @@ function createCoreMixin(Base) {
 // TypeScript can't generate declarations for functions returning classes with protected members
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const CoreMixin = createCoreMixin;
-//# sourceMappingURL=core.js.map

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

@@ -18,4 +18,3 @@
  * @internal
  */
 export declare const ExpressionsMixin: any;
-//# sourceMappingURL=expressions.d.ts.map

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

@@ -252,4 +252,3 @@ function createExpressionsMixin(Base) {
 // TypeScript can't generate declarations for functions returning classes with protected members
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const ExpressionsMixin = createExpressionsMixin;
-//# sourceMappingURL=expressions.js.map

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

@@ -7,4 +7,3 @@
  * @internal
  */
 export declare const ExtractionMixin: any;
-//# sourceMappingURL=extraction.d.ts.map