@rcrsr/rill 0.15.0 → 0.17.0

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

@@ -12,6 +12,8 @@
  * - evaluateTypeCheckPrimary(node) -> Promise<boolean>
  * - evaluateTypeConstructor(node) -> Promise<RillTypeValue> [IR-7]
  * - evaluateClosureSigLiteral(node) -> Promise<RillTypeValue> [IR-8]
+ * - resolveTypeRef(typeRef, getVariable) -> Promise<RillTypeValue> [IR-2]
+ * - buildCollectionType(name, args, resolveArg, evaluateDefault, location?) -> Promise<RillTypeValue> [IR-4]
  *
  * Error Handling:
  * - Type assertion failures throw RuntimeError(RUNTIME_TYPE_ERROR) [EC-24]
@@ -21,7 +23,7 @@
  * @internal
  */
 import { RuntimeError } from '../../../../types.js';
-import { inferType, checkType, isTypeValue, structuralTypeMatches, inferStructuralType, formatStructuralType, } from '../../values.js';
+import { inferType, checkType, isTypeValue, structureMatches, inferStructure, formatStructure, } from '../../values.js';
 import { getVariable } from '../../context.js';
 /**
  * TypesMixin implementation.
@@ -34,6 +36,7 @@ import { getVariable } from '../../context.js';
  * - EvaluatorBase: ctx, checkAborted(), getNodeLocation()
  * - evaluatePostfixExpr() (from future CoreMixin composition)
  * - evaluateExpression() (from CoreMixin, for type constructor arg evaluation)
+ * - evaluatePrimary() (from CoreMixin, for default value evaluation)
  *
  * Methods added:
  * - assertType(value, expected, location?) -> RillValue
@@ -43,133 +46,233 @@ import { getVariable } from '../../context.js';
  * - evaluateTypeCheckPrimary(node) -> Promise<boolean>
  * - evaluateTypeConstructor(node) -> Promise<RillTypeValue>
  * - evaluateClosureSigLiteral(node) -> Promise<RillTypeValue>
+ * - resolveTypeRef(typeRef, getVariable) -> Promise<RillTypeValue>
+ * - buildCollectionType(name, args, resolveArg, evaluateDefault, location?) -> Promise<RillTypeValue>
  */
 function createTypesMixin(Base) {
     return class TypesEvaluator extends Base {
         /**
-         * Resolve a TypeRef to a RillTypeValue [IR-2].
+         * Shared helper that partitions args, enforces validation, evaluates
+         * defaults, and constructs a RillTypeValue [IR-4].
          *
-         * Static refs with no args return a frozen RillTypeValue directly.
-         * Static refs with args build a parameterized RillType.
-         * Dynamic refs call getVariable, then dispatch on the result:
-         * - RillTypeValue → return as-is
-         * - Otherwise → throw RILL-R004
+         * Called by both resolveTypeRef and evaluateTypeConstructor with
+         * different resolution/evaluation strategies via callbacks.
          *
-         * EC-1: Variable not found → undefined from getVariable → RILL-R005.
-         * EC-2: Non-type variable value → RILL-R004.
-         * EC-3: Leaf type with args → RILL-R004.
-         * EC-4: list with != 1 positional arg → RILL-R004.
-         * EC-5: dict/ordered with positional arg → RILL-R004.
-         * EC-6: tuple with named arg → RILL-R004.
-         * EC-7: arg value is not a type value → RILL-R004.
+         * Error contracts:
+         * - EC-B1: Leaf type with args -> RILL-R004
+         * - EC-B2: list != 1 arg -> RILL-R004
+         * - EC-B3: Positional+named mix -> RILL-R004
+         * - EC-B4: tuple with named arg -> RILL-R004
+         * - EC-B5: Non-type arg value (delegated to resolveArg callback)
+         * - EC-B6: Default type mismatch -> RILL-R004
+         * - EC-B7: Tuple non-trailing default -> RILL-R004
          */
-        resolveTypeRef(typeRef, getVariable) {
-            if (typeRef.kind === 'static') {
-                const { typeName, args } = typeRef;
-                // No args: existing bare-type behavior
-                if (!args || args.length === 0) {
-                    return Object.freeze({
-                        __rill_type: true,
-                        typeName,
-                        structure: { type: typeName },
-                    });
-                }
-                // EC-3: Leaf types reject all type arguments
-                const LEAF_TYPES = new Set([
-                    'string',
-                    'number',
-                    'bool',
-                    'vector',
-                    'type',
-                    'any',
-                    'closure',
-                ]);
-                if (LEAF_TYPES.has(typeName)) {
-                    throw new RuntimeError('RILL-R004', `${typeName} does not accept type arguments`);
+        async buildCollectionType(name, args, resolveArg, evaluateDefault, location) {
+            if (name === 'list') {
+                // EC-B2: list requires exactly 1 positional arg
+                if (args.length !== 1 || args[0].name !== undefined) {
+                    throw new RuntimeError('RILL-R004', 'list() requires exactly 1 type argument', location);
                 }
-                // Helper: recursively resolve one TypeRefArg to RillType
-                const resolveArg = (arg) => {
-                    const resolved = this.resolveTypeRef(arg.ref, getVariable);
-                    return resolved.structure;
-                };
-                if (typeName === 'list') {
-                    // EC-4: list requires exactly 1 positional arg
-                    if (args.length !== 1 || args[0].name !== undefined) {
-                        throw new RuntimeError('RILL-R004', 'list() requires exactly 1 type argument');
-                    }
-                    const structure = {
-                        type: 'list',
-                        element: resolveArg(args[0]),
-                    };
-                    return Object.freeze({
-                        __rill_type: true,
-                        typeName,
-                        structure,
-                    });
+                const element = await resolveArg(args[0]);
+                const structure = { kind: 'list', element };
+                return Object.freeze({
+                    __rill_type: true,
+                    typeName: name,
+                    structure,
+                });
+            }
+            if (name === 'dict' || name === 'ordered') {
+                const positional = args.filter((a) => a.name === undefined);
+                const named = args.filter((a) => a.name !== undefined);
+                // EC-B3: Cannot mix positional and named arguments
+                if (positional.length > 0 && named.length > 0) {
+                    throw new RuntimeError('RILL-R004', `${name}() cannot mix positional and named arguments`, location);
                 }
-                if (typeName === 'dict') {
-                    // EC-5: dict requires named args only
-                    for (const arg of args) {
-                        if (arg.name === undefined) {
-                            throw new RuntimeError('RILL-R004', 'dict() requires named arguments (field: type)');
+                // Uniform path: exactly 1 positional, 0 named -> valueType
+                if (positional.length === 1 && named.length === 0) {
+                    const valueType = await resolveArg(positional[0]);
+                    // EC-B6: Default type mismatch on uniform single-arg path
+                    if (positional[0].defaultValue !== undefined) {
+                        const defaultVal = await evaluateDefault(positional[0].defaultValue);
+                        if (!structureMatches(defaultVal, valueType)) {
+                            throw new RuntimeError('RILL-R004', `Default value for ${name} element must be ${formatStructure(valueType)}, got ${inferType(defaultVal)}`, location);
                         }
                     }
-                    const fields = {};
-                    for (const arg of args) {
-                        fields[arg.name] = resolveArg(arg);
-                    }
-                    const structure = { type: 'dict', fields };
+                    const structure = { kind: name, valueType };
                     return Object.freeze({
                         __rill_type: true,
-                        typeName,
+                        typeName: name,
                         structure,
                     });
                 }
-                if (typeName === 'tuple') {
-                    // EC-6: tuple requires positional args only
+                // EC: dict/ordered with 2+ positional args
+                if (positional.length >= 2) {
+                    throw new RuntimeError('RILL-R004', `${name}() requires exactly 1 positional type argument`, location);
+                }
+                // Structural path: named args only -> fields
+                if (name === 'dict') {
+                    const fields = {};
                     for (const arg of args) {
-                        if (arg.name !== undefined) {
-                            throw new RuntimeError('RILL-R004', 'tuple() requires positional arguments');
+                        const resolvedType = await resolveArg(arg);
+                        const fieldDef = { type: resolvedType };
+                        if (arg.defaultValue !== undefined) {
+                            const defaultVal = await evaluateDefault(arg.defaultValue);
+                            // EC-B6: Default type mismatch
+                            if (!structureMatches(defaultVal, resolvedType)) {
+                                throw new RuntimeError('RILL-R004', `Default value for field '${arg.name}' must be ${formatStructure(resolvedType)}, got ${inferType(defaultVal)}`, location);
+                            }
+                            fieldDef.defaultValue = defaultVal;
                         }
+                        fields[arg.name] = fieldDef;
                     }
-                    const elements = args.map((arg) => [resolveArg(arg)]);
-                    const structure = { type: 'tuple', elements };
+                    const structure = { kind: 'dict', fields };
                     return Object.freeze({
                         __rill_type: true,
-                        typeName,
+                        typeName: name,
                         structure,
                     });
                 }
-                // typeName === 'ordered'
-                // EC-5: ordered requires named args only
+                // name === 'ordered': structural path -> fields array with name
+                const orderedFields = [];
                 for (const arg of args) {
-                    if (arg.name === undefined) {
-                        throw new RuntimeError('RILL-R004', 'dict() requires named arguments (field: type)');
+                    const resolvedType = await resolveArg(arg);
+                    const fieldDef = {
+                        name: arg.name,
+                        type: resolvedType,
+                    };
+                    if (arg.defaultValue !== undefined) {
+                        const defaultVal = await evaluateDefault(arg.defaultValue);
+                        // EC-B6: Default type mismatch
+                        if (!structureMatches(defaultVal, resolvedType)) {
+                            throw new RuntimeError('RILL-R004', `Default value for field '${arg.name}' must be ${formatStructure(resolvedType)}, got ${inferType(defaultVal)}`, location);
+                        }
+                        fieldDef.defaultValue = defaultVal;
                     }
+                    orderedFields.push(fieldDef);
                 }
-                const orderedFields = args.map((arg) => [arg.name, resolveArg(arg)]);
                 const structure = {
-                    type: 'ordered',
+                    kind: 'ordered',
                     fields: orderedFields,
                 };
                 return Object.freeze({
                     __rill_type: true,
-                    typeName,
+                    typeName: name,
+                    structure,
+                });
+            }
+            // name === 'tuple'
+            // EC-B4: tuple requires positional args only
+            for (const arg of args) {
+                if (arg.name !== undefined) {
+                    throw new RuntimeError('RILL-R004', 'tuple() requires positional arguments', location);
+                }
+            }
+            // Uniform path: exactly 1 positional -> valueType
+            if (args.length === 1 && args[0].name === undefined) {
+                const valueType = await resolveArg(args[0]);
+                // EC-B6: Default type mismatch on uniform single-arg path
+                if (args[0].defaultValue !== undefined) {
+                    const defaultVal = await evaluateDefault(args[0].defaultValue);
+                    if (!structureMatches(defaultVal, valueType)) {
+                        throw new RuntimeError('RILL-R004', `Default value for tuple element must be ${formatStructure(valueType)}, got ${inferType(defaultVal)}`, location);
+                    }
+                }
+                const structure = { kind: 'tuple', valueType };
+                return Object.freeze({
+                    __rill_type: true,
+                    typeName: 'tuple',
                     structure,
                 });
             }
-            // Union type ref: (A | B) — resolve each member recursively and
-            // return a RillTypeValue with structure: { type: 'union', members: [...] }.
+            // Structural path: 2+ positional -> elements
+            const elements = [];
+            for (const arg of args) {
+                const resolvedType = await resolveArg(arg);
+                const fieldDef = { type: resolvedType };
+                if (arg.defaultValue !== undefined) {
+                    const defaultVal = await evaluateDefault(arg.defaultValue);
+                    // EC-B6: Default type mismatch
+                    if (!structureMatches(defaultVal, resolvedType)) {
+                        throw new RuntimeError('RILL-R004', `Default value for tuple element must be ${formatStructure(resolvedType)}, got ${inferType(defaultVal)}`, location);
+                    }
+                    fieldDef.defaultValue = defaultVal;
+                }
+                elements.push(fieldDef);
+            }
+            // EC-B7: Tuple non-trailing default — no element without a default
+            // may follow an element that has one.
+            let sawDefault = false;
+            for (let i = 0; i < elements.length; i++) {
+                const hasDefault = elements[i].defaultValue !== undefined;
+                if (hasDefault) {
+                    sawDefault = true;
+                }
+                else if (sawDefault) {
+                    throw new RuntimeError('RILL-R004', `tuple() default values must be trailing: element at position ${i} has no default but a preceding element does`, location);
+                }
+            }
+            const structure = { kind: 'tuple', elements };
+            return Object.freeze({
+                __rill_type: true,
+                typeName: 'tuple',
+                structure,
+            });
+        }
+        /**
+         * Resolve a TypeRef to a RillTypeValue [IR-2].
+         *
+         * Static refs with no args return a frozen RillTypeValue directly.
+         * Static refs with args delegate to buildCollectionType.
+         * Dynamic refs call getVariable, then dispatch on the result:
+         * - RillTypeValue -> return as-is
+         * - Otherwise -> throw RILL-R004
+         *
+         * EC-3: Variable not found -> RILL-R005.
+         * EC-4: Non-type variable value -> RILL-R004.
+         * EC-5: list with != 1 positional arg -> RILL-R004.
+         * EC-6: dict/ordered positional+named mix -> RILL-R004.
+         * EC-7: tuple with named arg -> RILL-R004.
+         * EC-8: Default type mismatch -> RILL-R004.
+         * EC-9: Default evaluation failure -> propagated.
+         * EC-10: Tuple non-trailing default -> RILL-R004.
+         */
+        async resolveTypeRef(typeRef, getVariableFn) {
+            if (typeRef.kind === 'static') {
+                const { typeName, args } = typeRef;
+                // No args: existing bare-type behavior
+                if (!args || args.length === 0) {
+                    return Object.freeze({
+                        __rill_type: true,
+                        typeName,
+                        structure: { kind: typeName },
+                    });
+                }
+                // EC-B1: Leaf types reject all type arguments (AC-4: derived from registrations)
+                if (this.ctx.leafTypes.has(typeName)) {
+                    throw new RuntimeError('RILL-R004', `${typeName} does not accept type arguments`);
+                }
+                // Delegate to buildCollectionType with recursive resolveTypeRef
+                return this.buildCollectionType(typeName, args, async (arg) => {
+                    const resolved = await this.resolveTypeRef(arg.value, getVariableFn);
+                    return resolved.structure;
+                }, async (node) => {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    return this.evaluatePrimary(node);
+                });
+            }
+            // Union type ref: (A | B) -- resolve each member recursively and
+            // return a RillTypeValue with structure: { kind: 'union', members: [...] }.
             // typeName is set to a display string for error messages; the structure
             // field carries the authoritative type shape for validation (DR-1).
             if (typeRef.kind === 'union') {
-                const members = typeRef.members.map((member) => {
-                    const resolved = this.resolveTypeRef(member, getVariable);
-                    return resolved.structure;
-                });
-                const structure = { type: 'union', members };
+                const members = [];
+                for (const member of typeRef.members) {
+                    const resolved = await this.resolveTypeRef(member, getVariableFn);
+                    members.push(resolved.structure);
+                }
+                const structure = { kind: 'union', members };
                 const displayName = members
-                    .map(formatStructuralType)
+                    .map(formatStructure)
                     .join('|');
                 return Object.freeze({
                     __rill_type: true,
@@ -177,7 +280,7 @@ function createTypesMixin(Base) {
                     structure,
                 });
             }
-            const result = getVariable(typeRef.varName);
+            const result = getVariableFn(typeRef.varName);
             if (result === undefined) {
                 throw new RuntimeError('RILL-R005', `Variable $${typeRef.varName} is not defined`);
             }
@@ -188,28 +291,29 @@ function createTypesMixin(Base) {
         /**
          * Assert that a value is of the expected type.
          * Returns the value unchanged if assertion passes, throws on mismatch.
-         * Accepts a bare RillTypeName or a full RillType.
-         * When expected is a RillType with sub-fields (element, fields, elements),
-         * dispatches to structuralTypeMatches for deep validation.
+         * Accepts a bare RillTypeName or a full TypeStructure.
+         * When expected is a TypeStructure with sub-fields (element, fields, elements),
+         * dispatches to structureMatches for deep validation.
          * Exported for use by type assertion evaluation.
          */
         assertType(value, expected, location) {
-            // Structural path: expected is a RillType object
+            // Structural path: expected is a TypeStructure object
             if (typeof expected !== 'string') {
                 const hasSubFields = 'element' in expected ||
                     'fields' in expected ||
                     'elements' in expected ||
-                    'members' in expected;
+                    'members' in expected ||
+                    'valueType' in expected;
                 if (hasSubFields) {
-                    if (!structuralTypeMatches(value, expected)) {
-                        const expectedStr = formatStructuralType(expected);
-                        const actualStr = formatStructuralType(inferStructuralType(value));
+                    if (!structureMatches(value, expected)) {
+                        const expectedStr = formatStructure(expected);
+                        const actualStr = formatStructure(inferStructure(value));
                         throw new RuntimeError('RILL-R004', `Type assertion failed: expected ${expectedStr}, got ${actualStr}`, location, { expectedType: expectedStr, actualType: actualStr });
                     }
                     return value;
                 }
                 // Bare structural type (no sub-fields): fall through using type name
-                expected = expected.type;
+                expected = expected.kind;
             }
             // Bare type name path
             if (expected === 'any')
@@ -231,7 +335,7 @@ function createTypesMixin(Base) {
                 ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     await this.evaluatePostfixExpr(node.operand)
                 : input;
-            const resolved = this.resolveTypeRef(node.typeRef, (name) => getVariable(this.ctx, name));
+            const resolved = await this.resolveTypeRef(node.typeRef, (name) => getVariable(this.ctx, name));
             return this.assertType(value, resolved.structure, node.span.start);
         }
         /**
@@ -245,13 +349,14 @@ function createTypesMixin(Base) {
                 ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     await this.evaluatePostfixExpr(node.operand)
                 : input;
-            const resolved = this.resolveTypeRef(node.typeRef, (name) => getVariable(this.ctx, name));
+            const resolved = await this.resolveTypeRef(node.typeRef, (name) => getVariable(this.ctx, name));
             const hasSubFields = 'element' in resolved.structure ||
                 'fields' in resolved.structure ||
                 'elements' in resolved.structure ||
-                'members' in resolved.structure;
+                'members' in resolved.structure ||
+                'valueType' in resolved.structure;
             if (hasSubFields) {
-                return structuralTypeMatches(value, resolved.structure);
+                return structureMatches(value, resolved.structure);
             }
             return checkType(value, resolved.typeName);
         }
@@ -282,166 +387,32 @@ function createTypesMixin(Base) {
         /**
          * Evaluate a type constructor node into a RillTypeValue [IR-7].
          *
-         * Handles list(T), dict(k: T, ...), tuple(T1, T2, ...), ordered(k: T, ...).
-         * All arguments must evaluate to RillTypeValue.
+         * Handles list(T), dict(...), tuple(...), ordered(...).
+         * Delegates to buildCollectionType with evaluateTypeConstructor-specific
+         * resolution strategy (resolves TypeRef via resolveTypeRef, evaluates
+         * defaults via evaluatePrimary).
          *
-         * Error contracts:
-         * - EC-4: list() with != 1 arg -> RILL-R004
-         * - EC-5: non-type argument -> RILL-R004
-         * - EC-6: positional arg in dict/ordered -> RILL-R004
-         * - EC-7: named arg in tuple -> RILL-R004
+         * Error contracts delegated to buildCollectionType.
          */
         async evaluateTypeConstructor(node) {
             const name = node.constructorName;
             const location = node.span.start;
-            // Helper: evaluate one arg expression and assert it is a RillTypeValue
-            const resolveArgAsType = async (argValue) => {
-                if (!isTypeValue(argValue)) {
-                    throw new RuntimeError('RILL-R004', `Type constructor argument must be a type value, got ${inferType(argValue)}`, location);
-                }
-                return argValue.structure.type === 'any' &&
-                    argValue.typeName !== 'any'
-                    ? { type: argValue.typeName }
-                    : argValue.structure;
-            };
-            if (name === 'list') {
-                // EC-4: list() requires exactly 1 argument
-                if (node.args.length !== 1) {
-                    throw new RuntimeError('RILL-R004', 'list() requires exactly 1 type argument', location);
-                }
-                const arg = node.args[0];
+            return this.buildCollectionType(name, node.args, async (arg) => {
+                const resolved = await this.resolveTypeRef(arg.value, (varName) => getVariable(this.ctx, varName));
+                return resolved.structure.kind === 'any' &&
+                    resolved.typeName !== 'any'
+                    ? { kind: resolved.typeName }
+                    : resolved.structure;
+            }, async (node) => {
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const argVal = await this.evaluateExpression(arg.value);
-                const elementType = await resolveArgAsType(argVal);
-                const structure = {
-                    type: 'list',
-                    element: elementType,
-                };
-                return Object.freeze({
-                    __rill_type: true,
-                    typeName: 'list',
-                    structure,
-                });
-            }
-            if (name === 'dict') {
-                // EC-6: dict() requires named arguments
-                for (const arg of node.args) {
-                    if (arg.kind === 'positional') {
-                        throw new RuntimeError('RILL-R004', 'dict() requires named arguments (field: type)', location);
-                    }
-                }
-                const fields = {};
-                for (const arg of node.args) {
-                    if (arg.kind === 'named') {
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                        const argVal = await this.evaluateExpression(arg.value);
-                        const resolvedType = await resolveArgAsType(argVal);
-                        if (arg.defaultValue !== undefined) {
-                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                            const defaultVal = await this.evaluatePrimary(arg.defaultValue);
-                            if (!structuralTypeMatches(defaultVal, resolvedType)) {
-                                throw new RuntimeError('RILL-R004', `Default value for field '${arg.name}' must be ${formatStructuralType(resolvedType)}, got ${inferType(defaultVal)}`, location);
-                            }
-                            fields[arg.name] = {
-                                type: resolvedType,
-                                defaultValue: defaultVal,
-                            };
-                        }
-                        else {
-                            fields[arg.name] = resolvedType;
-                        }
-                    }
-                }
-                const structure = { type: 'dict', fields };
-                return Object.freeze({
-                    __rill_type: true,
-                    typeName: 'dict',
-                    structure,
-                });
-            }
-            if (name === 'tuple') {
-                // EC-7: tuple() requires positional arguments
-                for (const arg of node.args) {
-                    if (arg.kind === 'named') {
-                        throw new RuntimeError('RILL-R004', 'tuple() requires positional arguments', location);
-                    }
-                }
-                const elements = [];
-                for (const arg of node.args) {
-                    if (arg.kind === 'positional') {
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                        const argVal = await this.evaluateExpression(arg.value);
-                        const resolvedType = await resolveArgAsType(argVal);
-                        if (arg.defaultValue !== undefined) {
-                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                            const defaultVal = await this.evaluatePrimary(arg.defaultValue);
-                            elements.push([resolvedType, defaultVal]);
-                        }
-                        else {
-                            elements.push([resolvedType]);
-                        }
-                    }
-                }
-                // EC-3: defaults must be trailing-only — no element without a default
-                // may follow an element that has one.
-                let sawDefault = false;
-                for (let i = 0; i < elements.length; i++) {
-                    const hasDefault = elements[i].length === 2;
-                    if (hasDefault) {
-                        sawDefault = true;
-                    }
-                    else if (sawDefault) {
-                        throw new RuntimeError('RILL-P003', `tuple() default values must be trailing: element at position ${i} has no default but a preceding element does`, location);
-                    }
-                }
-                const structure = { type: 'tuple', elements };
-                return Object.freeze({
-                    __rill_type: true,
-                    typeName: 'tuple',
-                    structure,
-                });
-            }
-            // name === 'ordered'
-            // EC-6: ordered() requires named arguments
-            for (const arg of node.args) {
-                if (arg.kind === 'positional') {
-                    throw new RuntimeError('RILL-R004', 'ordered() requires named arguments (field: type)', location);
-                }
-            }
-            const orderedFields = [];
-            for (const arg of node.args) {
-                if (arg.kind === 'named') {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    const argVal = await this.evaluateExpression(arg.value);
-                    const resolvedType = await resolveArgAsType(argVal);
-                    if (arg.defaultValue !== undefined) {
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                        const defaultVal = await this.evaluatePrimary(arg.defaultValue);
-                        if (!structuralTypeMatches(defaultVal, resolvedType)) {
-                            throw new RuntimeError('RILL-R004', `Default value for field '${arg.name}' must be ${formatStructuralType(resolvedType)}, got ${inferType(defaultVal)}`, location);
-                        }
-                        orderedFields.push([arg.name, resolvedType, defaultVal]);
-                    }
-                    else {
-                        orderedFields.push([arg.name, resolvedType]);
-                    }
-                }
-            }
-            const structure = {
-                type: 'ordered',
-                fields: orderedFields,
-            };
-            return Object.freeze({
-                __rill_type: true,
-                typeName: 'ordered',
-                structure,
-            });
+                return this.evaluatePrimary(node);
+            }, location);
         }
         /**
          * Evaluate a closure signature literal into a RillTypeValue [IR-8].
          *
          * Creates a closure type value from |param: T, ...|: R syntax.
-         * Each parameter produces a [name, RillType] entry.
+         * Each parameter produces a [name, TypeStructure] entry.
          *
          * Error contracts:
          * - EC-8: missing return type -> RILL-R004 (enforced at parse time; node always has returnType)
@@ -449,14 +420,14 @@ function createTypesMixin(Base) {
          */
         async evaluateClosureSigLiteral(node) {
             const location = node.span.start;
-            // Helper: evaluate a type expression and extract RillType
+            // Helper: evaluate a type expression and extract TypeStructure
             const resolveTypeExpr = async (argVal) => {
                 if (!isTypeValue(argVal)) {
                     throw new RuntimeError('RILL-R004', `Parameter type must be a type value, got ${inferType(argVal)}`, location);
                 }
-                return argVal.structure.type === 'any' &&
+                return argVal.structure.kind === 'any' &&
                     argVal.typeName !== 'any'
-                    ? { type: argVal.typeName }
+                    ? { kind: argVal.typeName }
                     : argVal.structure;
             };
             // Evaluate parameter types
@@ -465,9 +436,9 @@ function createTypesMixin(Base) {
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 const paramVal = await this.evaluateExpression(param.typeExpr);
                 const paramType = await resolveTypeExpr(paramVal);
-                params.push([param.name, paramType]);
+                params.push({ name: param.name, type: paramType });
             }
-            // Evaluate return type (EC-8: required — parser enforces this at parse time)
+            // Evaluate return type (EC-8: required -- parser enforces this at parse time)
             // returnType is PostfixExprNode (stops before pipe operators) so the
             // return type annotation cannot accidentally consume a trailing pipe chain.
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -475,11 +446,11 @@ function createTypesMixin(Base) {
             if (!isTypeValue(retVal)) {
                 throw new RuntimeError('RILL-R004', `Closure type literal requires return type after |, got ${inferType(retVal)}`, location);
             }
-            const ret = retVal.structure.type === 'any' &&
+            const ret = retVal.structure.kind === 'any' &&
                 retVal.typeName !== 'any'
-                ? { type: retVal.typeName }
+                ? { kind: retVal.typeName }
                 : retVal.structure;
-            const structure = { type: 'closure', params, ret };
+            const structure = { kind: 'closure', params, ret };
             return Object.freeze({
                 __rill_type: true,
                 typeName: 'closure',
@@ -492,4 +463,3 @@ function createTypesMixin(Base) {
 // TypeScript can't generate declarations for functions returning classes with protected members
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const TypesMixin = createTypesMixin;
-//# sourceMappingURL=types.js.map