@rcrsr/rill 0.15.0 → 0.17.0

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,8 +27,9 @@
  * @internal
  */
 import { RuntimeError } from '../../../../types.js';
-import { inferType, isTuple, isOrdered, isTypeValue, createOrdered, createTuple, formatValue, isFieldTypeWithDefault, } from '../../values.js';
+import { inferType, isTuple, isOrdered, isTypeValue, createOrdered, createTuple, deepCopyRillValue, hasCollectionFields, emptyForType, } from '../../values.js';
 import { isDict } from '../../callable.js';
+import { BUILT_IN_TYPES } from '../../type-registrations.js';
 import { getVariable } from '../../context.js';
 /**
  * ConversionMixin implementation.
@@ -54,16 +55,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);
-                }
-                if (typeRef.constructorName === 'dict') {
-                    return this.convertToDictWithSig(input, typeRef, node);
-                }
-                if (typeRef.constructorName === 'tuple') {
+                // 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-dict/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);
@@ -91,7 +107,15 @@ function createConversionMixin(Base) {
         }
         /**
          * Apply conversion from source value to target type name.
-         * Implements the compatibility matrix from IR-9.
+         * Dispatches to protocol.convertTo on the source type's registration.
+         *
+         * IR-6: Replaces the hardcoded conversion matrix with protocol dispatch.
+         *
+         * Special cases preserved:
+         * - Same type = no-op (short-circuit)
+         * - dict -> :>ordered without structural sig raises RILL-R037 (EC-11)
+         * - String-to-number parse failure raises RILL-R038 (EC-12)
+         * - Missing convertTo target raises RILL-R036 (EC-10)
          */
         applyConversion(input, targetType, node) {
             const sourceType = inferType(input);
@@ -99,105 +123,34 @@ function createConversionMixin(Base) {
             if (sourceType === targetType) {
                 return input;
             }
-            // Apply compatibility matrix
-            switch (targetType) {
-                case 'list':
-                    return this.convertToList(input, sourceType, node);
-                case 'dict':
-                    return this.convertToDict(input, sourceType, node);
-                case 'tuple':
-                    return this.convertToTuple(input, sourceType, node);
-                case 'ordered':
-                    // dict -> :>ordered without structural sig is always a runtime error (EC-11)
-                    if (sourceType === 'dict') {
-                        throw new RuntimeError('RILL-R037', 'dict to ordered conversion requires structural type signature', this.getNodeLocation(node));
-                    }
-                    return this.convertToOrdered(input, sourceType, node);
-                case 'number':
-                    return this.convertToNumber(input, sourceType, node);
-                case 'string':
-                    return this.convertToString(input, sourceType, node);
-                case 'bool':
-                    return this.convertToBoolean(input, sourceType, node);
-                default:
-                    this.throwIncompatible(sourceType, targetType, node);
-            }
-            // TypeScript exhaustiveness
-            return input;
-        }
-        /** Convert to list type. Valid source: tuple. */
-        convertToList(input, sourceType, node) {
-            if (isTuple(input)) {
-                return input.entries;
+            // dict -> :>ordered without structural sig is always RILL-R037 (EC-11)
+            if (sourceType === 'dict' && targetType === 'ordered') {
+                throw new RuntimeError('RILL-R037', 'dict to ordered conversion requires structural type signature', this.getNodeLocation(node));
             }
-            this.throwIncompatible(sourceType, 'list', node);
-            return input;
-        }
-        /** Convert to dict type. Valid source: ordered. */
-        convertToDict(input, sourceType, node) {
-            if (isOrdered(input)) {
-                const result = {};
-                for (const [key, value] of input.entries) {
-                    result[key] = value;
-                }
-                return result;
+            // Find source type registration and dispatch via protocol.convertTo
+            const reg = BUILT_IN_TYPES.find((r) => r.name === sourceType);
+            const converter = reg?.protocol.convertTo?.[targetType];
+            if (!converter) {
+                throw new RuntimeError('RILL-R036', `cannot convert ${sourceType} to ${targetType}`, this.getNodeLocation(node), { source: sourceType, target: targetType });
             }
-            this.throwIncompatible(sourceType, 'dict', node);
-            return input;
-        }
-        /** Convert to tuple type. Valid source: list. */
-        convertToTuple(input, sourceType, node) {
-            if (Array.isArray(input) && !isTuple(input) && !isOrdered(input)) {
-                return createTuple(input);
+            try {
+                return converter(input);
             }
-            this.throwIncompatible(sourceType, 'tuple', node);
-            return input;
-        }
-        /** Convert to ordered type. Valid source: dict (with sig, handled separately). */
-        convertToOrdered(input, sourceType, node) {
-            // Only dict -> ordered is valid, but it requires a sig (checked by caller)
-            this.throwIncompatible(sourceType, 'ordered', node);
-            return input;
-        }
-        /** Convert to number type. Valid source: string (parseable) or bool. */
-        convertToNumber(input, sourceType, node) {
-            if (sourceType === 'string') {
-                const str = input;
-                const parsed = Number(str);
-                if (isNaN(parsed) || str.trim() === '') {
-                    throw new RuntimeError('RILL-R038', `cannot convert string "${str}" to number`, this.getNodeLocation(node), { value: str });
+            catch (err) {
+                // Protocol converters throw plain Errors; wrap as RuntimeError
+                // with the appropriate error code.
+                if (err instanceof RuntimeError)
+                    throw err;
+                // String-to-number parse failures use RILL-R038 (EC-12)
+                // Preserve the protocol's detailed message (includes unparseable value).
+                if (sourceType === 'string' && targetType === 'number') {
+                    const message = err instanceof Error ? err.message : String(err);
+                    throw new RuntimeError('RILL-R038', message, this.getNodeLocation(node), { value: input });
                 }
-                return parsed;
-            }
-            if (sourceType === 'bool') {
-                return input ? 1 : 0;
-            }
-            this.throwIncompatible(sourceType, 'number', node);
-            return input;
-        }
-        /** Convert to bool type. Valid source: number (0 or 1) or string ("true" or "false"). */
-        convertToBoolean(input, sourceType, node) {
-            if (sourceType === 'number') {
-                const n = input;
-                if (n === 0)
-                    return false;
-                if (n === 1)
-                    return true;
-                this.throwIncompatible(sourceType, 'bool', node);
+                // All other conversion failures use RILL-R036 (EC-10)
+                // Use consistent "cannot convert X to Y" format.
+                throw new RuntimeError('RILL-R036', `cannot convert ${sourceType} to ${targetType}`, this.getNodeLocation(node), { source: sourceType, target: targetType });
             }
-            if (sourceType === 'string') {
-                const s = input;
-                if (s === 'true')
-                    return true;
-                if (s === 'false')
-                    return false;
-                this.throwIncompatible(sourceType, 'bool', node);
-            }
-            this.throwIncompatible(sourceType, 'bool', node);
-        }
-        /** Convert to string type. Valid source: any type via formatValue semantics. */
-        convertToString(input, _sourceType, _node) {
-            return formatValue(input);
         }
         /**
          * Convert dict -> :>ordered(field: type = default, ...) using structural signature.
@@ -209,28 +162,45 @@ function createConversionMixin(Base) {
          * - Extra keys not in signature: omitted from result
          */
         async convertToOrderedWithSig(input, sigNode, node) {
-            if (!isDict(input)) {
+            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 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
+            const resolvedFields = typeValue.structure.kind === 'ordered' && typeValue.structure.fields
                 ? typeValue.structure.fields
                 : [];
-            const dictInput = input;
             const entries = [];
             for (const field of resolvedFields) {
-                const fieldName = field[0];
-                const hasDefault = field.length === 3;
+                const fieldName = field.name;
                 if (fieldName in dictInput) {
-                    entries.push([fieldName, dictInput[fieldName]]);
+                    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 (hasDefault) {
-                    entries.push([fieldName, deepCopyRillValue(field[2])]);
+                else if (hasCollectionFields(field.type)) {
+                    entries.push([
+                        fieldName,
+                        this.hydrateNested(emptyForType(field.type), field.type, node),
+                    ]);
                 }
                 else {
-                    throw new RuntimeError('RILL-R044', `cannot convert dict to ordered: missing required field '${fieldName}'`, this.getNodeLocation(node), { source: 'dict', target: 'ordered' });
+                    throw new RuntimeError('RILL-R044', `cannot convert ${sourceType} to ordered: missing required field '${fieldName}'`, this.getNodeLocation(node), { source: sourceType, target: 'ordered' });
                 }
             }
             return createOrdered(entries);
@@ -246,19 +216,26 @@ function createConversionMixin(Base) {
          * - Recurses into nested dict-typed fields for nested hydration
          */
         async convertToDictWithSig(input, sigNode, node) {
-            if (!isDict(input)) {
+            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
+            const resolvedFields = typeValue.structure.kind === 'dict' && typeValue.structure.fields
                 ? typeValue.structure.fields
                 : {};
-            const dictInput = input;
             const result = {};
             for (const arg of sigNode.args) {
-                if (arg.kind !== 'named') {
+                if (arg.name === undefined) {
                     continue;
                 }
                 const fieldName = arg.name;
@@ -267,21 +244,22 @@ function createConversionMixin(Base) {
                     // Field present in input: use it, recursing if the field type is a nested dict
                     let fieldValue = dictInput[fieldName];
                     if (resolvedField !== undefined) {
-                        const innerType = isFieldTypeWithDefault(resolvedField)
-                            ? resolvedField.type
-                            : resolvedField;
-                        fieldValue = this.hydrateNestedDict(fieldValue, innerType, node);
+                        fieldValue = this.hydrateNested(fieldValue, resolvedField.type, node);
                     }
                     result[fieldName] = fieldValue;
                 }
                 else {
                     // Field missing from input: use default if available, else error
                     if (resolvedField !== undefined &&
-                        isFieldTypeWithDefault(resolvedField)) {
-                        result[fieldName] = deepCopyRillValue(resolvedField.defaultValue);
+                        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 dict to dict: missing required field '${fieldName}'`, this.getNodeLocation(node), { source: 'dict', target: 'dict' });
+                        throw new RuntimeError('RILL-R044', `cannot convert ${sourceType} to dict: missing required field '${fieldName}'`, this.getNodeLocation(node), { source: sourceType, target: 'dict' });
                     }
                 }
             }
@@ -305,7 +283,7 @@ function createConversionMixin(Base) {
             // 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
+            const resolvedElements = typeValue.structure.kind === 'tuple' && typeValue.structure.elements
                 ? typeValue.structure.elements
                 : [];
             const inputEntries = isTupleInput
@@ -314,14 +292,17 @@ function createConversionMixin(Base) {
             const result = [];
             for (let i = 0; i < resolvedElements.length; i++) {
                 const element = resolvedElements[i];
-                const hasDefault = element.length === 2;
                 if (i < inputEntries.length) {
-                    // Element present in input: use it directly
-                    result.push(inputEntries[i]);
+                    // Element present in input: recurse into nested types
+                    result.push(this.hydrateNested(inputEntries[i], element.type, node));
                 }
-                else if (hasDefault) {
-                    // Missing trailing element with default: deep copy default
-                    result.push(deepCopyRillValue(element[1]));
+                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
@@ -331,76 +312,104 @@ function createConversionMixin(Base) {
             return createTuple(result);
         }
         /**
-         * Recursively hydrate a dict value against a nested dict RillType.
-         * Only applies when the field type is a dict with explicit fields.
-         * Returns the value unchanged if it is not a dict or the type has no fields.
+         * 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.
          */
-        hydrateNestedDict(value, fieldType, node) {
-            if (fieldType.type !== 'dict' || !fieldType.fields) {
-                return value;
-            }
-            if (!isDict(value)) {
-                return value;
+        hydrateNested(value, fieldType, node) {
+            if (fieldType.kind === 'dict' &&
+                fieldType.fields &&
+                isDict(value)) {
+                const ft = fieldType;
+                const dictValue = value;
+                const result = {};
+                for (const [fieldName, resolvedField] of Object.entries(ft.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;
             }
-            const dictValue = value;
-            const result = {};
-            for (const [fieldName, resolvedField] of Object.entries(fieldType.fields)) {
-                if (fieldName in dictValue) {
-                    let fieldValue = dictValue[fieldName];
-                    if (isFieldTypeWithDefault(resolvedField)) {
-                        fieldValue = this.hydrateNestedDict(fieldValue, resolvedField.type, node);
+            else if (fieldType.kind === 'ordered' &&
+                fieldType.fields) {
+                const ft = fieldType;
+                // 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 ft.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 {
-                        fieldValue = this.hydrateNestedDict(fieldValue, resolvedField, node);
+                        throw new RuntimeError('RILL-R044', `cannot convert ${source} to ordered: missing required field '${name}'`, this.getNodeLocation(node), { source, target: 'ordered' });
                     }
-                    result[fieldName] = fieldValue;
                 }
-                else {
-                    if (isFieldTypeWithDefault(resolvedField)) {
-                        result[fieldName] = deepCopyRillValue(resolvedField.defaultValue);
+                return createOrdered(resultEntries);
+            }
+            else if (fieldType.kind === 'tuple' &&
+                fieldType.elements) {
+                const ft = fieldType;
+                // 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 < ft.elements.length; i++) {
+                    const element = ft.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 dict to dict: missing required field '${fieldName}'`, this.getNodeLocation(node), { source: 'dict', target: 'dict' });
+                        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 result;
-        }
-        /** Throw EC-10 incompatible conversion error. */
-        throwIncompatible(source, target, node) {
-            throw new RuntimeError('RILL-R036', `cannot convert ${source} to ${target}`, this.getNodeLocation(node), { source, target });
+            return value;
         }
     };
 }
-/**
- * Deep copy a RillValue, producing a new independent value.
- * Handles primitives, arrays, plain dicts, and null.
- * Special markers (closures, tuples, ordered, vectors, type values) are returned
- * as-is since they are immutable by contract.
- */
-function deepCopyRillValue(value) {
-    if (value === null || typeof value !== 'object') {
-        return value;
-    }
-    if (Array.isArray(value)) {
-        return value.map(deepCopyRillValue);
-    }
-    // Plain dict: copy recursively. Special markers (RillTuple, RillOrdered, etc.)
-    // carry __rill_* own properties and are treated as immutable; return as-is.
-    if (!('__rill_tuple' in value) &&
-        !('__rill_ordered' in value) &&
-        !('__rill_vector' in value) &&
-        !('__rill_type' in value) &&
-        !('__type' in value) &&
-        !('__rill_field_descriptor' in value)) {
-        const copy = {};
-        for (const [k, v] of Object.entries(value)) {
-            copy[k] = deepCopyRillValue(v);
-        }
-        return copy;
-    }
-    return value;
-}
 /**
  * Type guard: check if a TypeRef | TypeConstructorNode is a TypeConstructorNode.
  */
@@ -410,4 +419,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

@@ -282,8 +282,8 @@ function createCoreMixin(Base) {
                             primary.typeName === 'ordered' ||
                             primary.typeName === 'vector' ||
                             primary.typeName === 'type'
-                            ? { type: primary.typeName }
-                            : { type: 'any' },
+                            ? { kind: primary.typeName }
+                            : { kind: 'any' },
                     });
                 case 'TypeConstructor':
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -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