@rcrsr/rill 0.14.0 → 0.16.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]
@@ -23,6 +25,19 @@
 import { RuntimeError } from '../../../../types.js';
 import { inferType, checkType, isTypeValue, structuralTypeMatches, inferStructuralType, formatStructuralType, } from '../../values.js';
 import { getVariable } from '../../context.js';
+/**
+ * Leaf types that reject all type arguments.
+ * Extracted as module-level constant to avoid per-call allocation.
+ */
+const LEAF_TYPES = new Set([
+    'string',
+    'number',
+    'bool',
+    'vector',
+    'type',
+    'any',
+    'closure',
+]);
 /**
  * TypesMixin implementation.
  *
@@ -34,6 +49,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 +59,227 @@ 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 },
-                    });
+        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);
                 }
-                // 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`);
+                const element = await resolveArg(args[0]);
+                const structure = { type: '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);
                 }
-                // 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');
+                // 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 (!structuralTypeMatches(defaultVal, valueType)) {
+                            throw new RuntimeError('RILL-R004', `Default value for ${name} element must be ${formatStructuralType(valueType)}, got ${inferType(defaultVal)}`, location);
+                        }
                     }
-                    const structure = {
-                        type: 'list',
-                        element: resolveArg(args[0]),
-                    };
+                    const structure = { type: name, valueType };
                     return Object.freeze({
                         __rill_type: true,
-                        typeName,
+                        typeName: name,
                         structure,
                     });
                 }
-                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)');
-                        }
-                    }
+                // 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) {
-                        fields[arg.name] = resolveArg(arg);
+                        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 (!structuralTypeMatches(defaultVal, resolvedType)) {
+                                throw new RuntimeError('RILL-R004', `Default value for field '${arg.name}' must be ${formatStructuralType(resolvedType)}, got ${inferType(defaultVal)}`, location);
+                            }
+                            fieldDef.defaultValue = defaultVal;
+                        }
+                        fields[arg.name] = fieldDef;
                     }
                     const structure = { type: 'dict', fields };
                     return Object.freeze({
                         __rill_type: true,
-                        typeName,
+                        typeName: name,
                         structure,
                     });
                 }
-                if (typeName === 'tuple') {
-                    // EC-6: tuple requires positional args only
-                    for (const arg of args) {
-                        if (arg.name !== undefined) {
-                            throw new RuntimeError('RILL-R004', 'tuple() requires positional arguments');
+                // name === 'ordered': structural path -> fields array with name
+                const orderedFields = [];
+                for (const arg of args) {
+                    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 (!structuralTypeMatches(defaultVal, resolvedType)) {
+                            throw new RuntimeError('RILL-R004', `Default value for field '${arg.name}' must be ${formatStructuralType(resolvedType)}, got ${inferType(defaultVal)}`, location);
                         }
+                        fieldDef.defaultValue = defaultVal;
                     }
-                    const elements = args.map(resolveArg);
-                    const structure = { type: 'tuple', elements };
-                    return Object.freeze({
-                        __rill_type: true,
-                        typeName,
-                        structure,
-                    });
+                    orderedFields.push(fieldDef);
                 }
-                // typeName === 'ordered'
-                // EC-5: ordered requires named args only
-                for (const arg of args) {
-                    if (arg.name === undefined) {
-                        throw new RuntimeError('RILL-R004', 'dict() requires named arguments (field: type)');
+                const structure = { type: 'ordered', fields: orderedFields };
+                return Object.freeze({
+                    __rill_type: true,
+                    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 (!structuralTypeMatches(defaultVal, valueType)) {
+                        throw new RuntimeError('RILL-R004', `Default value for tuple element must be ${formatStructuralType(valueType)}, got ${inferType(defaultVal)}`, location);
                     }
                 }
-                const orderedFields = args.map((arg) => [
-                    arg.name,
-                    resolveArg(arg),
-                ]);
-                const structure = {
-                    type: 'ordered',
-                    fields: orderedFields,
-                };
+                const structure = { type: 'tuple', valueType };
                 return Object.freeze({
                     __rill_type: true,
-                    typeName,
+                    typeName: 'tuple',
                     structure,
                 });
             }
-            // Union type ref: (A | B) — resolve each member recursively and
+            // 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 (!structuralTypeMatches(defaultVal, resolvedType)) {
+                        throw new RuntimeError('RILL-R004', `Default value for tuple element must be ${formatStructuralType(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 = { type: '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: { type: typeName },
+                    });
+                }
+                // EC-B1: Leaf types reject all type arguments
+                if (LEAF_TYPES.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: { type: '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 members = [];
+                for (const member of typeRef.members) {
+                    const resolved = await this.resolveTypeRef(member, getVariableFn);
+                    members.push(resolved.structure);
+                }
                 const structure = { type: 'union', members };
                 const displayName = members
                     .map(formatStructuralType)
@@ -180,7 +290,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`);
             }
@@ -202,7 +312,8 @@ function createTypesMixin(Base) {
                 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);
@@ -234,7 +345,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);
         }
         /**
@@ -248,11 +359,12 @@ 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);
             }
@@ -285,115 +397,26 @@ 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.type === 'any' &&
+                    resolved.typeName !== 'any'
+                    ? { type: 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);
-                        fields[arg.name] = await resolveArgAsType(argVal);
-                    }
-                }
-                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);
-                        elements.push(await resolveArgAsType(argVal));
-                    }
-                }
-                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);
-                    orderedFields.push([arg.name, await resolveArgAsType(argVal)]);
-                }
-            }
-            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].
@@ -423,9 +446,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
@@ -450,4 +473,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

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

@@ -22,4 +22,3 @@
  * @internal
  */
 export declare const UseMixin: any;
-//# sourceMappingURL=use.d.ts.map

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

@@ -179,4 +179,3 @@ function parseSchemeString(value, node) {
 // TypeScript can't generate declarations for functions returning classes with protected members
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const UseMixin = createUseMixin;
-//# sourceMappingURL=use.js.map

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

@@ -31,4 +31,3 @@
  * @internal
  */
 export declare const VariablesMixin: any;
-//# sourceMappingURL=variables.d.ts.map

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

@@ -317,11 +317,11 @@ function createVariablesMixin(Base) {
                 const finalAccess = node.existenceCheck.finalAccess;
                 const typeRef = node.existenceCheck.typeRef;
                 // Helper: check type match using structural resolution (EC-4: mismatch returns false)
-                const matchesType = (fieldValue) => {
+                const matchesType = async (fieldValue) => {
                     if (typeRef === null)
                         return true;
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    const resolved = this.resolveTypeRef(typeRef, (name) => getVariable(this.ctx, name));
+                    const resolved = await this.resolveTypeRef(typeRef, (name) => getVariable(this.ctx, name));
                     return structuralTypeMatches(fieldValue, resolved.structure);
                 };
                 if (finalAccess.kind === 'literal') {
@@ -331,7 +331,7 @@ function createVariablesMixin(Base) {
                         const exists = fieldValue !== undefined && fieldValue !== null;
                         // If type-qualified check, verify type matches
                         if (exists && typeRef !== null) {
-                            return matchesType(fieldValue);
+                            return await matchesType(fieldValue);
                         }
                         return exists;
                     }
@@ -361,7 +361,7 @@ function createVariablesMixin(Base) {
                         const exists = fieldValue !== undefined && fieldValue !== null;
                         // If type-qualified check, verify type matches
                         if (exists && typeRef !== null) {
-                            return matchesType(fieldValue);
+                            return await matchesType(fieldValue);
                         }
                         return exists;
                     }
@@ -388,7 +388,7 @@ function createVariablesMixin(Base) {
                         const exists = fieldValue !== undefined && fieldValue !== null;
                         // If type-qualified check, verify type matches
                         if (exists && typeRef !== null) {
-                            return matchesType(fieldValue);
+                            return await matchesType(fieldValue);
                         }
                         return exists;
                     }
@@ -552,7 +552,7 @@ function createVariablesMixin(Base) {
             if (node.typeRef !== null) {
                 // Resolve TypeRef and validate against the declared type
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const resolved = this.resolveTypeRef(node.typeRef, (name) => getVariable(this.ctx, name));
+                const resolved = await this.resolveTypeRef(node.typeRef, (name) => getVariable(this.ctx, name));
                 this.setVariable(node.name, input, resolved.structure, node.span.start);
             }
             else {
@@ -578,4 +578,3 @@ function createVariablesMixin(Base) {
 // TypeScript can't generate declarations for functions returning classes with protected members
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const VariablesMixin = createVariablesMixin;
-//# sourceMappingURL=variables.js.map

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

@@ -38,4 +38,3 @@ export type EvaluatorConstructor<TBase extends EvaluatorBase = EvaluatorBase> =
  * ```
  */
 export type Mixin<TBase extends EvaluatorBase = EvaluatorBase, TExtension extends TBase = TBase> = (Base: EvaluatorConstructor<TBase>) => EvaluatorConstructor<TExtension>;
-//# sourceMappingURL=types.d.ts.map

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

@@ -7,4 +7,3 @@
  * @internal
  */
 export {};
-//# sourceMappingURL=types.js.map

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

@@ -23,4 +23,3 @@ export declare function execute(script: ScriptNode, context: RuntimeContext): Pr
  * @returns A stepper for step-by-step execution
  */
 export declare function createStepper(script: ScriptNode, context: RuntimeContext): ExecutionStepper;
-//# sourceMappingURL=execute.d.ts.map

package/dist/runtime/core/execute.js

@@ -171,4 +171,3 @@ function isRecoveryErrorNode(stmt) {
 function getInnerStatement(stmt) {
     return stmt.type === 'AnnotatedStatement' ? stmt.statement : stmt;
 }
-//# sourceMappingURL=execute.js.map