@rcrsr/rill 0.16.0 → 0.18.0

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

@@ -21,7 +21,8 @@
  * @internal
  */
 import { RuntimeError } from '../../../../types.js';
-import { inferType, isRillIterator, isVector } from '../../values.js';
+import { inferType } from '../../types/registrations.js';
+import { isIterator, isStream, isVector } from '../../types/guards.js';
 import { createChildContext, getVariable } from '../../context.js';
 import { BreakSignal } from '../../signals.js';
 import { isCallable, isDict, marshalArgs } from '../../callable.js';
@@ -35,7 +36,7 @@ const DEFAULT_MAX_ITERATIONS = 10000;
  * CollectionsMixin implementation.
  *
  * Evaluates collection operators: each, map, fold, filter.
- * Handles iteration over lists, strings, dicts, and iterators.
+ * Handles iteration over lists, strings, dicts, iterators, and streams.
  *
  * Depends on:
  * - EvaluatorBase: ctx, checkAborted(), getNodeLocation()
@@ -55,17 +56,18 @@ const DEFAULT_MAX_ITERATIONS = 10000;
  * - getIterableElements(input) -> Promise<RillValue[]> (helper)
  * - evaluateIteratorBody(body, element, accumulator) -> Promise<RillValue> (helper)
  * - expandIterator(iterator, limit?) -> Promise<RillValue[]> (helper)
+ * - expandStream(stream, node, limit?) -> Promise<RillValue[]> (helper)
  */
 function createCollectionsMixin(Base) {
     return class CollectionsEvaluator extends Base {
         /**
-         * Get elements from an iterable value (list, string, dict, or iterator).
+         * Get elements from an iterable value (list, string, dict, iterator, or stream).
          * Throws RuntimeError if value is not iterable.
          */
         async getIterableElements(input, node) {
             // Vector guard [EC-32]
             if (isVector(input)) {
-                throw new RuntimeError('RILL-R003', 'Collection operators require list, string, dict, or iterator, got vector', node.span.start);
+                throw new RuntimeError('RILL-R003', 'Collection operators require list, string, dict, iterator, or stream, got vector', node.span.start);
             }
             if (Array.isArray(input)) {
                 return input;
@@ -73,8 +75,12 @@ function createCollectionsMixin(Base) {
             if (typeof input === 'string') {
                 return [...input];
             }
+            // Check for stream BEFORE iterator (streams satisfy iterator shape)
+            if (isStream(input)) {
+                return this.expandStream(input, node);
+            }
             // Check for iterator protocol BEFORE generic dict handling
-            if (isRillIterator(input)) {
+            if (isIterator(input)) {
                 return this.expandIterator(input, node);
             }
             if (isDict(input)) {
@@ -85,7 +91,7 @@ function createCollectionsMixin(Base) {
                     value: input[key],
                 }));
             }
-            throw new RuntimeError('RILL-R002', `Collection operators require list, string, dict, or iterator, got ${inferType(input)}`, node.span.start);
+            throw new RuntimeError('RILL-R002', `Collection operators require list, string, dict, iterator, or stream, got ${inferType(input)}`, node.span.start);
         }
         /**
          * Expand an iterator to a list of values.
@@ -119,6 +125,75 @@ function createCollectionsMixin(Base) {
             }
             return elements;
         }
+        /**
+         * Expand a stream to a list of chunk values.
+         * Consumes async chunks by repeatedly calling the stream's next callable.
+         * Respects iteration limits to prevent unbounded expansion.
+         *
+         * On BreakSignal, calls the stream's dispose callable (if present)
+         * before re-throwing (NFR-STREAM-2).
+         */
+        async expandStream(stream, node, limit = DEFAULT_MAX_ITERATIONS) {
+            const elements = [];
+            let current = stream;
+            let count = 0;
+            let expectedType;
+            try {
+                while (!current.done && count < limit) {
+                    this.checkAborted();
+                    const val = current['value'];
+                    if (val !== undefined) {
+                        const actualType = inferType(val);
+                        if (expectedType === undefined) {
+                            expectedType = actualType;
+                        }
+                        else if (actualType !== expectedType) {
+                            throw new RuntimeError('RILL-R004', `Stream chunk type mismatch: expected ${expectedType}, got ${actualType}`, node.span.start);
+                        }
+                        elements.push(val);
+                    }
+                    count++;
+                    // Invoke next() to advance the stream
+                    const nextClosure = current['next'];
+                    if (nextClosure === undefined || !isCallable(nextClosure)) {
+                        throw new RuntimeError('RILL-R002', 'Stream .next must be a closure', node.span.start);
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const nextStep = await this.invokeCallable(nextClosure, [], this.ctx, node.span.start);
+                    if (typeof nextStep !== 'object' || nextStep === null) {
+                        throw new RuntimeError('RILL-R002', 'Stream .next must return a stream step', node.span.start);
+                    }
+                    current = nextStep;
+                }
+            }
+            catch (e) {
+                if (e instanceof BreakSignal) {
+                    // Dispose stream resources before re-throwing (IR-14)
+                    // Access __rill_stream_dispose on the original stream object
+                    // (step objects don't carry dispose; it lives on the root stream)
+                    const disposeFn = stream['__rill_stream_dispose'];
+                    if (typeof disposeFn === 'function') {
+                        try {
+                            disposeFn();
+                        }
+                        catch (disposeErr) {
+                            // Propagate dispose errors as RILL-R002 (EC-15)
+                            if (disposeErr instanceof RuntimeError)
+                                throw disposeErr;
+                            throw new RuntimeError('RILL-R002', disposeErr instanceof Error
+                                ? disposeErr.message
+                                : String(disposeErr), node.span.start);
+                        }
+                    }
+                    throw e;
+                }
+                throw e;
+            }
+            if (count >= limit) {
+                throw new RuntimeError('RILL-R010', `Stream expansion exceeded ${limit} iterations`, node.span.start, { limit, iterations: count });
+            }
+            return elements;
+        }
         /**
          * Evaluate collection body for a single element.
          * Handles all body forms: closure, block, grouped, variable, postfix, spread.

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

@@ -24,7 +24,7 @@
  * @internal
  */
 import { RuntimeError } from '../../../../types.js';
-import { inferType } from '../../values.js';
+import { inferType } from '../../types/registrations.js';
 import { createChildContext } from '../../context.js';
 import { BreakSignal, ReturnSignal } from '../../signals.js';
 /**

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

@@ -27,8 +27,12 @@
  * @internal
  */
 import { RuntimeError } from '../../../../types.js';
-import { inferType, isTuple, isOrdered, isTypeValue, createOrdered, createTuple, formatValue, deepCopyRillValue, hasCollectionFields, emptyForType, } from '../../values.js';
+import { inferType } from '../../types/registrations.js';
+import { isTuple, isOrdered, isTypeValue } from '../../types/guards.js';
+import { createOrdered, createTuple, copyValue, emptyForType, } from '../../types/constructors.js';
+import { hasCollectionFields } from '../../values.js';
 import { isDict } from '../../callable.js';
+import { BUILT_IN_TYPES } from '../../types/registrations.js';
 import { getVariable } from '../../context.js';
 /**
  * ConversionMixin implementation.
@@ -106,7 +110,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);
@@ -114,105 +126,36 @@ 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);
+            // IR-11: :>stream is not supported — stream type cannot be a conversion target
+            if (targetType === 'stream') {
+                throw new RuntimeError('RILL-R003', 'Type conversion not supported for stream type', this.getNodeLocation(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 RuntimeError (RILL-R064/R065/R066);
+                // wrap with evaluator-level error codes for user-facing messages.
+                // 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;
+                // 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 === '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);
-            }
-            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.
@@ -238,7 +181,7 @@ function createConversionMixin(Base) {
             // 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 entries = [];
@@ -252,7 +195,7 @@ function createConversionMixin(Base) {
                 else if (field.defaultValue !== undefined) {
                     entries.push([
                         fieldName,
-                        this.hydrateNested(deepCopyRillValue(field.defaultValue), field.type, node),
+                        this.hydrateNested(copyValue(field.defaultValue), field.type, node),
                     ]);
                 }
                 else if (hasCollectionFields(field.type)) {
@@ -292,7 +235,7 @@ function createConversionMixin(Base) {
             // 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 result = {};
@@ -314,7 +257,7 @@ function createConversionMixin(Base) {
                     // Field missing from input: use default if available, else error
                     if (resolvedField !== undefined &&
                         resolvedField.defaultValue !== undefined) {
-                        result[fieldName] = this.hydrateNested(deepCopyRillValue(resolvedField.defaultValue), resolvedField.type, node);
+                        result[fieldName] = this.hydrateNested(copyValue(resolvedField.defaultValue), resolvedField.type, node);
                     }
                     else if (resolvedField !== undefined &&
                         hasCollectionFields(resolvedField.type)) {
@@ -345,7 +288,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
@@ -360,7 +303,7 @@ function createConversionMixin(Base) {
                 }
                 else if (element.defaultValue !== undefined) {
                     // Missing trailing element with default: deep copy and hydrate
-                    result.push(this.hydrateNested(deepCopyRillValue(element.defaultValue), element.type, node));
+                    result.push(this.hydrateNested(copyValue(element.defaultValue), element.type, node));
                 }
                 else if (hasCollectionFields(element.type)) {
                     // Missing element with collection type: seed empty and hydrate
@@ -379,17 +322,20 @@ function createConversionMixin(Base) {
          * Returns the value unchanged if the type has no fields or the value type does not match.
          */
         hydrateNested(value, fieldType, node) {
-            if (fieldType.type === 'dict' && fieldType.fields && isDict(value)) {
+            if (fieldType.kind === 'dict' &&
+                fieldType.fields &&
+                isDict(value)) {
+                const ft = fieldType;
                 const dictValue = value;
                 const result = {};
-                for (const [fieldName, resolvedField] of Object.entries(fieldType.fields)) {
+                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);
+                            result[fieldName] = this.hydrateNested(copyValue(resolvedField.defaultValue), resolvedField.type, node);
                         }
                         else if (hasCollectionFields(resolvedField.type)) {
                             result[fieldName] = this.hydrateNested(emptyForType(resolvedField.type), resolvedField.type, node);
@@ -401,7 +347,9 @@ function createConversionMixin(Base) {
                 }
                 return result;
             }
-            else if (fieldType.type === 'ordered' && fieldType.fields) {
+            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;
@@ -412,7 +360,7 @@ function createConversionMixin(Base) {
                     ? value.entries.map(([k, v]) => [k, v])
                     : Object.entries(value));
                 const resultEntries = [];
-                for (const field of fieldType.fields) {
+                for (const field of ft.fields) {
                     const name = field.name;
                     if (lookup.has(name)) {
                         const fieldValue = this.hydrateNested(lookup.get(name), field.type, node);
@@ -421,7 +369,7 @@ function createConversionMixin(Base) {
                     else if (field.defaultValue !== undefined) {
                         resultEntries.push([
                             name,
-                            this.hydrateNested(deepCopyRillValue(field.defaultValue), field.type, node),
+                            this.hydrateNested(copyValue(field.defaultValue), field.type, node),
                         ]);
                     }
                     else if (hasCollectionFields(field.type)) {
@@ -436,21 +384,23 @@ function createConversionMixin(Base) {
                 }
                 return createOrdered(resultEntries);
             }
-            else if (fieldType.type === 'tuple' && fieldType.elements) {
+            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 < fieldType.elements.length; i++) {
-                    const element = fieldType.elements[i];
+                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));
+                        resultEntries.push(this.hydrateNested(copyValue(element.defaultValue), element.type, node));
                     }
                     else if (hasCollectionFields(element.type)) {
                         resultEntries.push(this.hydrateNested(emptyForType(element.type), element.type, node));
@@ -463,10 +413,6 @@ function createConversionMixin(Base) {
             }
             return value;
         }
-        /** 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 });
-        }
     };
 }
 /**

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

@@ -21,7 +21,7 @@
  * @internal
  */
 import { RuntimeError } from '../../../../types.js';
-import { isTuple } from '../../values.js';
+import { isTuple } from '../../types/guards.js';
 import { isCallable, isDict, isScriptCallable } from '../../callable.js';
 import { BreakSignal, ReturnSignal } from '../../signals.js';
 /**
@@ -102,7 +102,7 @@ function createCoreMixin(Base) {
                 value = await this.evaluatePipeTarget(target, value);
                 this.ctx.pipeValue = value; // OK: flows within chain
             }
-            // Handle chain terminator (capture, break, return)
+            // Handle chain terminator (capture, break, return, yield)
             if (chain.terminator) {
                 if (chain.terminator.type === 'Break') {
                     // Restore parent's $ before throwing (cleanup)
@@ -114,6 +114,19 @@ function createCoreMixin(Base) {
                     this.ctx.pipeValue = savedPipeValue;
                     throw new ReturnSignal(value);
                 }
+                if (chain.terminator.type === 'Yield') {
+                    // Restore parent's $ before throwing (cleanup)
+                    this.ctx.pipeValue = savedPipeValue;
+                    // Delegate to evaluateYield for chunk type validation + YieldSignal.
+                    // When inside a stream closure body, evaluateYield pushes to the
+                    // channel and blocks until the consumer pulls (returns Promise<void>).
+                    // When outside, it throws YieldSignal synchronously.
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    await this.evaluateYield(value, chain.terminator.span.start);
+                    // After yield resumes (stream channel case), restore pipe value
+                    // and return the yielded value as the chain result
+                    return value;
+                }
                 // Capture
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 await this.handleCapture(chain.terminator, value);
@@ -282,8 +295,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

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

@@ -18,9 +18,18 @@
  * @internal
  */
 import { RuntimeError } from '../../../../types.js';
-import { inferType, isTruthy, deepEquals } from '../../values.js';
+import { inferType } from '../../types/registrations.js';
+import { isTruthy } from '../../values.js';
+import { BUILT_IN_TYPES } from '../../types/registrations.js';
 import { createChildContext } from '../../context.js';
 import { isCallable } from '../../callable.js';
+/**
+ * Find the type registration for a value by type name.
+ * Returns undefined when no registration matches.
+ */
+function findRegistration(typeName) {
+    return BUILT_IN_TYPES.find((r) => r.name === typeName);
+}
 /**
  * ExpressionsMixin implementation.
  *
@@ -150,39 +159,39 @@ function createExpressionsMixin(Base) {
             }
         }
         /**
-         * Evaluate comparison between two values.
-         * Equality works on all types, ordering requires compatible types.
+         * Evaluate comparison between two values via protocol dispatch.
+         *
+         * - == / != dispatch to protocol.eq; absent eq raises RILL-R002.
+         * - Ordering ops dispatch to protocol.compare; absent compare raises RILL-R002.
+         *
+         * IR-5: Breaking change: bool ordering (e.g. true > false) raises RILL-R002
+         * because the bool registration has no protocol.compare.
          */
         evaluateBinaryComparison(left, right, op, node) {
+            const typeName = inferType(left);
+            const reg = findRegistration(typeName);
+            if (op === '==' || op === '!=') {
+                if (!reg || !reg.protocol.eq) {
+                    throw new RuntimeError('RILL-R002', `Cannot compare ${typeName} using ${op}`, node.span.start);
+                }
+                const eqResult = reg.protocol.eq(left, right);
+                return op === '==' ? eqResult : !eqResult;
+            }
+            // Ordering ops: <, >, <=, >=
+            const rightTypeName = inferType(right);
+            if (!reg || !reg.protocol.compare || typeName !== rightTypeName) {
+                throw new RuntimeError('RILL-R002', `Cannot compare ${typeName} with ${rightTypeName} using ${op}`, node.span.start);
+            }
+            const cmp = reg.protocol.compare(left, right);
             switch (op) {
-                case '==':
-                    return deepEquals(left, right);
-                case '!=':
-                    return !deepEquals(left, right);
                 case '<':
+                    return cmp < 0;
                 case '>':
+                    return cmp > 0;
                 case '<=':
+                    return cmp <= 0;
                 case '>=':
-                    // Ordering comparisons require compatible types
-                    if (typeof left === 'number' && typeof right === 'number') {
-                        return op === '<'
-                            ? left < right
-                            : op === '>'
-                                ? left > right
-                                : op === '<='
-                                    ? left <= right
-                                    : left >= right;
-                    }
-                    if (typeof left === 'string' && typeof right === 'string') {
-                        return op === '<'
-                            ? left < right
-                            : op === '>'
-                                ? left > right
-                                : op === '<='
-                                    ? left <= right
-                                    : left >= right;
-                    }
-                    throw new RuntimeError('RILL-R002', `Cannot compare ${inferType(left)} with ${inferType(right)} using ${op}`, node.span.start);
+                    return cmp >= 0;
             }
         }
         /**

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

@@ -7,7 +7,8 @@
  * @internal
  */
 import { RuntimeError } from '../../../../types.js';
-import { createOrdered, createTuple, inferElementType } from '../../values.js';
+import { createOrdered, createTuple } from '../../types/constructors.js';
+import { inferElementType } from '../../types/operations.js';
 import { isDict } from '../../callable.js';
 import { getVariable } from '../../context.js';
 /**
@@ -77,7 +78,6 @@ function createExtractionMixin(Base) {
                     }
                     // Note: setVariable and resolveTypeRef will be available from VariablesMixin
                     // and TypesMixin which are applied before ExtractionMixin in the composition order
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     const dictResolved = elem.typeRef !== null
                         ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
                             await this.resolveTypeRef(elem.typeRef, (name) => getVariable(this.ctx, name))
@@ -112,7 +112,6 @@ function createExtractionMixin(Base) {
                     }
                     // Note: setVariable and resolveTypeRef will be available from VariablesMixin
                     // and TypesMixin which are applied before ExtractionMixin in the composition order
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     const listResolved = elem.typeRef !== null
                         ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
                             await this.resolveTypeRef(elem.typeRef, (name) => getVariable(this.ctx, name))

package/dist/runtime/core/eval/mixins/list-dispatch.js

@@ -14,7 +14,7 @@
  * @internal
  */
 import { RuntimeError } from '../../../../types.js';
-import { inferElementType } from '../../values.js';
+import { inferElementType } from '../../types/operations.js';
 /**
  * ListDispatchMixin implementation.
  *