@rcrsr/rill 0.16.0 → 0.18.0

package/dist/runtime/core/values.js

@@ -3,673 +3,28 @@
  *
  * Core value types that flow through Rill programs.
  * Public API for host applications.
- */
-import { RuntimeError } from '../../types.js';
-import { VALID_TYPE_NAMES } from '../../constants.js';
-import { callableEquals, isCallable, isDict, isScriptCallable, } from './callable.js';
-/** Type guard for RillTuple (spread args) */
-export function isTuple(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        '__rill_tuple' in value &&
-        value.__rill_tuple === true);
-}
-/** Type guard for RillVector */
-export function isVector(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        '__rill_vector' in value &&
-        value.__rill_vector === true);
-}
-/** Type guard for RillOrdered (named spread args) */
-export function isOrdered(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        '__rill_ordered' in value &&
-        value.__rill_ordered === true);
-}
-/** Type guard for RillTypeValue */
-export function isTypeValue(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        '__rill_type' in value &&
-        value.__rill_type === true);
-}
-/**
- * Create ordered from entries array (named, preserves insertion order).
- * Entries may be 2-element [name, value] or 3-element [name, value, default]
- * tuples; the third element carries a default value for `.^input` reflection.
- */
-export function createOrdered(entries) {
-    return Object.freeze({ __rill_ordered: true, entries: [...entries] });
-}
-/** Create tuple from entries array (positional, preserves order) */
-export function createTuple(entries) {
-    return Object.freeze({ __rill_tuple: true, entries: [...entries] });
-}
-/**
- * Create vector from Float32Array with model name.
- * @throws {Error} if data.length is 0 (zero-dimension vectors not allowed)
- */
-export function createVector(data, model) {
-    if (data.length === 0) {
-        throw new Error('Vector data must have at least one dimension');
-    }
-    return { __rill_vector: true, data, model };
-}
-/** Infer the Rill type from a runtime value */
-export function inferType(value) {
-    if (value === null)
-        return 'string'; // null treated as empty string
-    if (typeof value === 'string')
-        return 'string';
-    if (typeof value === 'number')
-        return 'number';
-    if (typeof value === 'boolean')
-        return 'bool';
-    if (isTuple(value))
-        return 'tuple';
-    if (isOrdered(value))
-        return 'ordered';
-    if (isVector(value))
-        return 'vector';
-    if (Array.isArray(value))
-        return 'list';
-    if (isTypeValue(value))
-        return 'type';
-    if (isRillIterator(value))
-        return 'iterator';
-    if (typeof value === 'object' &&
-        '__type' in value &&
-        value.__type === 'callable') {
-        return 'closure';
-    }
-    if (typeof value === 'object')
-        return 'dict';
-    return 'string'; // fallback
-}
-/**
- * Infer the element type for a homogeneous list.
- * Empty arrays return { type: 'any' }.
- * Mixed types throw RILL-R002.
- */
-export function inferElementType(elements) {
-    if (elements.length === 0)
-        return { type: 'any' };
-    const firstElem = elements[0];
-    let accType = inferStructuralType(firstElem);
-    for (let i = 1; i < elements.length; i++) {
-        const elem = elements[i];
-        const elemType = inferStructuralType(elem);
-        const merged = commonType(accType, elemType);
-        if (merged === null) {
-            throw new RuntimeError('RILL-R002', `List elements must be the same type: expected ${formatStructuralType(accType)}, got ${formatStructuralType(elemType)} at index ${i}`);
-        }
-        accType = merged;
-    }
-    return accType;
-}
-/**
- * Merge uniform value types from two sides of the same compound type.
- * Sub-case A: both carry valueType -> recurse commonType.
- * Sub-case B: both carry structural fields -> extract value types, merge all.
- * Returns the merged RillType on success, undefined when no uniform merge applies.
- */
-function mergeUniformValueType(aValue, bValue, aFields, bFields) {
-    // Sub-case A: both carry valueType
-    if (aValue !== undefined && bValue !== undefined) {
-        const merged = commonType(aValue, bValue);
-        if (merged !== null)
-            return merged;
-        return undefined;
-    }
-    // Sub-case B: both carry structural fields
-    if (aFields !== undefined && bFields !== undefined) {
-        const allTypes = [
-            ...aFields.map((f) => f.type),
-            ...bFields.map((f) => f.type),
-        ];
-        if (allTypes.length === 0)
-            return undefined;
-        let merged = allTypes[0];
-        for (let i = 1; i < allTypes.length; i++) {
-            const next = commonType(merged, allTypes[i]);
-            if (next === null)
-                return undefined;
-            merged = next;
-        }
-        return merged;
-    }
-    return undefined;
-}
-/**
- * Return the most specific shared type for two RillType values.
- * Returns null when types are incompatible at the top level.
  *
- * Cascade priority:
- * 1. Any-narrowing: if either side is `any`, return the other
- * 2. Structural match: delegate to structuralTypeEquals; on true, return a
- * 3. Recursive list: merge inner element types
- * 3b. Uniform valueType: merge dict/tuple/ordered value types
- * 4. Bare type fallback: same compound type but structural mismatch
- * 5. Incompatible: different top-level types return null
- */
-export function commonType(a, b) {
-    // 1. Any-narrowing
-    if (a.type === 'any')
-        return b;
-    if (b.type === 'any')
-        return a;
-    // 5. Incompatible top-level types (checked early to short-circuit)
-    if (a.type !== b.type)
-        return null;
-    // 2. Structural match
-    if (structuralTypeEquals(a, b))
-        return a;
-    // 3. Recursive list element merging
-    if (a.type === 'list' && b.type === 'list') {
-        if (a.element !== undefined && b.element !== undefined) {
-            const inner = commonType(a.element, b.element);
-            if (inner !== null)
-                return { type: 'list', element: inner };
-        }
-        return { type: 'list' };
-    }
-    // 3b. Uniform valueType merging for dict/tuple/ordered
-    if (a.type === 'dict' && b.type === 'dict') {
-        const merged = mergeUniformValueType(a.valueType, b.valueType, a.fields ? Object.values(a.fields) : undefined, b.fields ? Object.values(b.fields) : undefined);
-        if (merged !== undefined)
-            return { type: 'dict', valueType: merged };
-    }
-    if (a.type === 'tuple' && b.type === 'tuple') {
-        const merged = mergeUniformValueType(a.valueType, b.valueType, a.elements, b.elements);
-        if (merged !== undefined)
-            return { type: 'tuple', valueType: merged };
-    }
-    if (a.type === 'ordered' && b.type === 'ordered') {
-        const merged = mergeUniformValueType(a.valueType, b.valueType, a.fields, b.fields);
-        if (merged !== undefined)
-            return { type: 'ordered', valueType: merged };
-    }
-    // 4. Bare type fallback for compound types.
-    // The cast is safe for closure/dict/tuple/ordered (all sub-fields optional).
-    // For union, members is required by RillType but omitted here intentionally:
-    // bare union signals structural incompatibility without enumerating members.
-    if (a.type === 'closure' ||
-        a.type === 'dict' ||
-        a.type === 'tuple' ||
-        a.type === 'ordered' ||
-        a.type === 'union') {
-        return { type: a.type };
-    }
-    return null;
-}
-/** Compare two structural types for equality. */
-export function structuralTypeEquals(a, b) {
-    if (a.type !== b.type)
-        return false;
-    // Leaf variants compare by type alone
-    if (a.type === 'number' ||
-        a.type === 'string' ||
-        a.type === 'bool' ||
-        a.type === 'vector' ||
-        a.type === 'type' ||
-        a.type === 'any') {
-        return true;
-    }
-    if (a.type === 'list' && b.type === 'list') {
-        if (a.element === undefined && b.element === undefined)
-            return true;
-        if (a.element === undefined || b.element === undefined)
-            return false;
-        return structuralTypeEquals(a.element, b.element);
-    }
-    if (a.type === 'dict' && b.type === 'dict') {
-        // Uniform valueType comparison (mirrors list element at line 308)
-        const aHasValue = a.valueType !== undefined;
-        const bHasValue = b.valueType !== undefined;
-        if (aHasValue || bHasValue) {
-            if (!aHasValue || !bHasValue)
-                return false;
-            return structuralTypeEquals(a.valueType, b.valueType);
-        }
-        // Structural fields comparison
-        if (a.fields === undefined && b.fields === undefined)
-            return true;
-        if (a.fields === undefined || b.fields === undefined)
-            return false;
-        const aKeys = Object.keys(a.fields).sort();
-        const bKeys = Object.keys(b.fields).sort();
-        if (aKeys.length !== bKeys.length)
-            return false;
-        for (let i = 0; i < aKeys.length; i++) {
-            const key = aKeys[i];
-            if (key !== bKeys[i])
-                return false;
-            const aField = a.fields[key];
-            const bField = b.fields[key];
-            const aHasDefault = aField.defaultValue !== undefined;
-            const bHasDefault = bField.defaultValue !== undefined;
-            if (aHasDefault !== bHasDefault)
-                return false;
-            if (!structuralTypeEquals(aField.type, bField.type))
-                return false;
-            if (aHasDefault && bHasDefault) {
-                if (!deepEquals(aField.defaultValue, bField.defaultValue))
-                    return false;
-            }
-        }
-        return true;
-    }
-    if (a.type === 'tuple' && b.type === 'tuple') {
-        // Uniform valueType comparison (mirrors list element at line 308)
-        const aHasValue = a.valueType !== undefined;
-        const bHasValue = b.valueType !== undefined;
-        if (aHasValue || bHasValue) {
-            if (!aHasValue || !bHasValue)
-                return false;
-            return structuralTypeEquals(a.valueType, b.valueType);
-        }
-        // Structural elements comparison
-        if (a.elements === undefined && b.elements === undefined)
-            return true;
-        if (a.elements === undefined || b.elements === undefined)
-            return false;
-        if (a.elements.length !== b.elements.length)
-            return false;
-        for (let i = 0; i < a.elements.length; i++) {
-            const aElem = a.elements[i];
-            const bElem = b.elements[i];
-            if (!structuralTypeEquals(aElem.type, bElem.type))
-                return false;
-            const aDefault = aElem.defaultValue;
-            const bDefault = bElem.defaultValue;
-            if (aDefault === undefined && bDefault === undefined)
-                continue;
-            if (aDefault === undefined || bDefault === undefined)
-                return false;
-            if (!deepEquals(aDefault, bDefault))
-                return false;
-        }
-        return true;
-    }
-    if (a.type === 'ordered' && b.type === 'ordered') {
-        // Uniform valueType comparison (mirrors list element at line 308)
-        const aHasValue = a.valueType !== undefined;
-        const bHasValue = b.valueType !== undefined;
-        if (aHasValue || bHasValue) {
-            if (!aHasValue || !bHasValue)
-                return false;
-            return structuralTypeEquals(a.valueType, b.valueType);
-        }
-        // Structural fields comparison
-        if (a.fields === undefined && b.fields === undefined)
-            return true;
-        if (a.fields === undefined || b.fields === undefined)
-            return false;
-        if (a.fields.length !== b.fields.length)
-            return false;
-        for (let i = 0; i < a.fields.length; i++) {
-            const aField = a.fields[i];
-            const bField = b.fields[i];
-            if (aField.name !== bField.name)
-                return false;
-            if (!structuralTypeEquals(aField.type, bField.type))
-                return false;
-            const aDefault = aField.defaultValue;
-            const bDefault = bField.defaultValue;
-            if (aDefault === undefined && bDefault === undefined)
-                continue;
-            if (aDefault === undefined || bDefault === undefined)
-                return false;
-            if (!deepEquals(aDefault, bDefault))
-                return false;
-        }
-        return true;
-    }
-    if (a.type === 'union' && b.type === 'union') {
-        if (a.members.length !== b.members.length)
-            return false;
-        for (let i = 0; i < a.members.length; i++) {
-            if (!structuralTypeEquals(a.members[i], b.members[i]))
-                return false;
-        }
-        return true;
-    }
-    if (a.type === 'closure' && b.type === 'closure') {
-        if (a.params === undefined && b.params === undefined) {
-            // Both absent: compare ret
-        }
-        else if (a.params === undefined || b.params === undefined) {
-            return false;
-        }
-        else {
-            if (a.params.length !== b.params.length)
-                return false;
-            for (let i = 0; i < a.params.length; i++) {
-                const aParam = a.params[i];
-                const bParam = b.params[i];
-                if (aParam.name !== bParam.name)
-                    return false;
-                if (!structuralTypeEquals(aParam.type, bParam.type))
-                    return false;
-                const aDefault = aParam.defaultValue;
-                const bDefault = bParam.defaultValue;
-                if (aDefault === undefined && bDefault === undefined)
-                    continue;
-                if (aDefault === undefined || bDefault === undefined)
-                    return false;
-                if (!deepEquals(aDefault, bDefault))
-                    return false;
-            }
-        }
-        if (a.ret === undefined && b.ret === undefined)
-            return true;
-        if (a.ret === undefined || b.ret === undefined)
-            return false;
-        return structuralTypeEquals(a.ret, b.ret);
-    }
-    return false;
-}
-/** Infer the structural type descriptor for any Rill value. */
-export function inferStructuralType(value) {
-    if (value === null || typeof value === 'string') {
-        return { type: 'string' };
-    }
-    if (typeof value === 'number') {
-        return { type: 'number' };
-    }
-    if (typeof value === 'boolean') {
-        return { type: 'bool' };
-    }
-    if (isTypeValue(value)) {
-        return { type: 'type' };
-    }
-    if (Array.isArray(value)) {
-        return { type: 'list', element: inferElementType(value) };
-    }
-    if (isTuple(value)) {
-        return {
-            type: 'tuple',
-            elements: value.entries.map((e) => ({
-                type: inferStructuralType(e),
-            })),
-        };
-    }
-    if (isOrdered(value)) {
-        return {
-            type: 'ordered',
-            fields: value.entries.map(([k, v]) => ({
-                name: k,
-                type: inferStructuralType(v),
-            })),
-        };
-    }
-    if (isVector(value)) {
-        return { type: 'vector' };
-    }
-    if (isCallable(value)) {
-        const params = (value.params ?? []).map((p) => paramToFieldDef(p.name, p.type ?? { type: 'any' }, p.defaultValue));
-        const ret = value.returnType.structure;
-        return { type: 'closure', params, ret };
-    }
-    if (typeof value === 'object') {
-        const dict = value;
-        const fields = {};
-        for (const [k, v] of Object.entries(dict)) {
-            fields[k] = { type: inferStructuralType(v) };
-        }
-        return { type: 'dict', fields };
-    }
-    throw new RuntimeError('RILL-R004', `Cannot infer structural type for ${formatValue(value)}`);
-}
-/**
- * Check if a value matches a structural type descriptor.
- * Used for runtime type checking (`:?` operator).
+ * Structural operations (structureEquals, structureMatches, formatStructure,
+ * inferStructure, commonType) live in types/operations.ts and are re-exported.
+ *
+ * Dispatch functions (inferType, formatValue, deepEquals, serializeValue,
+ * copyValue) re-export from type-registrations.ts protocol implementations.
  */
-export function structuralTypeMatches(value, type) {
-    if (typeof value === 'undefined') {
-        throw new RuntimeError('RILL-R004', 'Cannot type-check non-value');
-    }
-    if (type.type === 'any')
-        return true;
-    // Leaf primitive variants: match by inferred type name
-    if (type.type === 'number' ||
-        type.type === 'string' ||
-        type.type === 'bool' ||
-        type.type === 'vector' ||
-        type.type === 'type') {
-        return inferType(value) === type.type;
-    }
-    if (type.type === 'list') {
-        if (!Array.isArray(value))
-            return false;
-        // Absent element sub-field: matches any list value
-        if (type.element === undefined)
-            return true;
-        if (type.element.type === 'any')
-            return true;
-        return value.every((elem) => structuralTypeMatches(elem, type.element));
-    }
-    if (type.type === 'dict') {
-        if (!isDict(value))
-            return false;
-        // Uniform value type check: every value must match valueType
-        if (type.valueType !== undefined) {
-            const vals = Object.values(value);
-            return vals.every((v) => structuralTypeMatches(v, type.valueType));
-        }
-        // Absent fields sub-field: matches any dict value
-        if (type.fields === undefined)
-            return true;
-        const dictKeys = Object.keys(type.fields);
-        // Empty fields object matches any dict
-        if (dictKeys.length === 0)
-            return true;
-        const dict = value;
-        for (const key of dictKeys) {
-            if (!(key in dict)) {
-                const field = type.fields[key];
-                if (field.defaultValue !== undefined)
-                    continue;
-                return false;
-            }
-            const field = type.fields[key];
-            if (!structuralTypeMatches(dict[key], field.type))
-                return false;
-        }
-        return true;
-    }
-    if (type.type === 'tuple') {
-        if (!isTuple(value))
-            return false;
-        // Uniform value type check: every entry must match valueType
-        if (type.valueType !== undefined) {
-            return value.entries.every((v) => structuralTypeMatches(v, type.valueType));
-        }
-        // Absent elements sub-field: matches any tuple value
-        if (type.elements === undefined)
-            return true;
-        if (type.elements.length === 0)
-            return value.entries.length === 0;
-        // Reject if value has more entries than type elements
-        if (value.entries.length > type.elements.length)
-            return false;
-        // Reject if value is shorter and any trailing missing element lacks a default
-        if (value.entries.length < type.elements.length) {
-            for (let i = value.entries.length; i < type.elements.length; i++) {
-                const field = type.elements[i];
-                if (field.defaultValue === undefined)
-                    return false;
-            }
-        }
-        for (let i = 0; i < value.entries.length; i++) {
-            if (!structuralTypeMatches(value.entries[i], type.elements[i].type))
-                return false;
-        }
-        return true;
-    }
-    if (type.type === 'ordered') {
-        if (!isOrdered(value))
-            return false;
-        // Uniform value type check: every entry value must match valueType
-        if (type.valueType !== undefined) {
-            return value.entries.every(([, v]) => structuralTypeMatches(v, type.valueType));
-        }
-        // Absent fields sub-field: matches any ordered value
-        if (type.fields === undefined)
-            return true;
-        if (type.fields.length === 0)
-            return value.entries.length === 0;
-        // Reject if value has more entries than type fields
-        if (value.entries.length > type.fields.length)
-            return false;
-        // Reject if value is shorter and any trailing missing field lacks a default
-        if (value.entries.length < type.fields.length) {
-            for (let i = value.entries.length; i < type.fields.length; i++) {
-                const field = type.fields[i];
-                if (field.defaultValue === undefined)
-                    return false;
-            }
-        }
-        for (let i = 0; i < value.entries.length; i++) {
-            const field = type.fields[i];
-            const [actualName, actualValue] = value.entries[i];
-            if (actualName !== field.name)
-                return false;
-            if (!structuralTypeMatches(actualValue, field.type))
-                return false;
-        }
-        return true;
-    }
-    if (type.type === 'closure') {
-        if (!isCallable(value))
-            return false;
-        // Absent params sub-field: matches any closure value of that compound type
-        if (type.params === undefined)
-            return true;
-        const valueParams = value.params ?? [];
-        if (valueParams.length !== type.params.length)
-            return false;
-        for (let i = 0; i < type.params.length; i++) {
-            const field = type.params[i];
-            const param = valueParams[i];
-            if (param.name !== field.name)
-                return false;
-            const paramType = param.type ?? { type: 'any' };
-            if (!structuralTypeEquals(paramType, field.type))
-                return false;
-        }
-        const retType = value.returnType.structure;
-        if (type.ret === undefined)
-            return true;
-        return structuralTypeEquals(retType, type.ret);
-    }
-    if (type.type === 'union') {
-        return type.members.some((member) => structuralTypeMatches(value, member));
-    }
-    return false;
-}
-/** Build a closure param field definition from name, type, and optional default. */
-export function paramToFieldDef(name, type, defaultValue) {
-    const field = { name, type };
-    if (defaultValue !== undefined)
-        field.defaultValue = defaultValue;
-    return field;
-}
-/** Format a RillValue as a rill literal for use in type signatures. */
-function formatRillLiteral(value) {
-    if (typeof value === 'string') {
-        const escaped = value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
-        return `"${escaped}"`;
-    }
-    if (typeof value === 'number')
-        return String(value);
-    if (typeof value === 'boolean')
-        return value ? 'true' : 'false';
-    if (value === null)
-        return 'null';
-    return formatValue(value);
-}
-/** Format a structural type descriptor as a human-readable string. */
-export function formatStructuralType(type) {
-    if (type.type === 'any' ||
-        type.type === 'number' ||
-        type.type === 'string' ||
-        type.type === 'bool' ||
-        type.type === 'vector' ||
-        type.type === 'type') {
-        return type.type;
-    }
-    if (type.type === 'list') {
-        if (type.element === undefined)
-            return 'list';
-        return `list(${formatStructuralType(type.element)})`;
-    }
-    if (type.type === 'dict') {
-        if (type.valueType !== undefined && type.fields === undefined) {
-            return `dict(${formatStructuralType(type.valueType)})`;
-        }
-        if (type.fields === undefined)
-            return 'dict';
-        const parts = Object.keys(type.fields)
-            .sort()
-            .map((k) => {
-            const field = type.fields[k];
-            const base = `${k}: ${formatStructuralType(field.type)}`;
-            if (field.defaultValue === undefined)
-                return base;
-            return `${base} = ${formatRillLiteral(field.defaultValue)}`;
-        });
-        return `dict(${parts.join(', ')})`;
-    }
-    if (type.type === 'tuple') {
-        if (type.valueType !== undefined && type.elements === undefined) {
-            return `tuple(${formatStructuralType(type.valueType)})`;
-        }
-        if (type.elements === undefined)
-            return 'tuple';
-        const parts = type.elements.map((field) => {
-            const base = formatStructuralType(field.type);
-            if (field.defaultValue === undefined)
-                return base;
-            return `${base} = ${formatRillLiteral(field.defaultValue)}`;
-        });
-        return `tuple(${parts.join(', ')})`;
-    }
-    if (type.type === 'ordered') {
-        if (type.valueType !== undefined && type.fields === undefined) {
-            return `ordered(${formatStructuralType(type.valueType)})`;
-        }
-        if (type.fields === undefined)
-            return 'ordered';
-        const parts = type.fields.map((field) => {
-            const base = `${field.name}: ${formatStructuralType(field.type)}`;
-            if (field.defaultValue === undefined)
-                return base;
-            return `${base} = ${formatRillLiteral(field.defaultValue)}`;
-        });
-        return `ordered(${parts.join(', ')})`;
-    }
-    if (type.type === 'closure') {
-        if (type.params === undefined)
-            return 'closure';
-        const params = type.params
-            .map((field) => {
-            const base = `${field.name}: ${formatStructuralType(field.type)}`;
-            if (field.defaultValue === undefined)
-                return base;
-            return `${base} = ${formatRillLiteral(field.defaultValue)}`;
-        })
-            .join(', ');
-        const ret = type.ret !== undefined ? formatStructuralType(type.ret) : 'any';
-        return `|${params}| :${ret}`;
-    }
-    if (type.type === 'union') {
-        return type.members.map(formatStructuralType).join('|');
-    }
-    return 'any';
-}
+import { VALID_TYPE_NAMES } from '../../constants.js';
+import { isCallable as _isCallableGuard, isDict, isIterator, isOrdered, isStream, isTuple, isTypeValue, isVector, } from './types/guards.js';
+/** isCallable guard widened to narrow to full RillCallable (not just CallableMarker) */
+const isCallable = _isCallableGuard;
+import { inferType as registryInferType, formatValue as registryFormatValue, deepEquals as registryDeepEquals, serializeValue as registrySerializeValue, } from './types/registrations.js';
+// Re-export guards from canonical source (types/guards.ts)
+export { isCallable, isDict, isIterator, isOrdered, isStream, isTuple, isTypeValue, isVector, };
+// Value constructors re-exported from canonical source (types/constructors.ts)
+export { copyValue, createOrdered, createTuple, createVector, emptyForType, } from './types/constructors.js';
+// Structural operations re-exported from types/operations.ts
+export { commonType, compareStructuredFields, formatStructure, inferElementType, inferStructure, paramToFieldDef, structureEquals, structureMatches, } from './types/operations.js';
+// Re-import for local use (toNative, structureToTypeValue)
+import { formatStructure, inferStructure } from './types/operations.js';
+/** Infer the Rill type from a runtime value. Delegates to type-registrations. */
+export const inferType = registryInferType;
 /**
  * Check if a value is of the expected type.
  * Returns true if the value matches the expected type, false otherwise.
@@ -706,88 +61,10 @@ export function isTruthy(value) {
 export function isEmpty(value) {
     return !isTruthy(value);
 }
-/** Format a value for display */
-export function formatValue(value) {
-    if (value === null)
-        return 'type(null)';
-    if (typeof value === 'string')
-        return value;
-    if (typeof value === 'number')
-        return String(value);
-    if (typeof value === 'boolean')
-        return value ? 'true' : 'false';
-    if (isCallable(value)) {
-        return 'type(closure)';
-    }
-    if (isTuple(value)) {
-        return `tuple[${value.entries.map(formatValue).join(', ')}]`;
-    }
-    if (isOrdered(value)) {
-        const parts = value.entries.map(([k, v]) => `${k}: ${formatValue(v)}`);
-        return `ordered[${parts.join(', ')}]`;
-    }
-    if (isRillIterator(value)) {
-        return 'type(iterator)';
-    }
-    if (Array.isArray(value)) {
-        return `list[${value.map(formatValue).join(', ')}]`;
-    }
-    if (isVector(value)) {
-        return `vector(${value.model}, ${value.data.length}d)`;
-    }
-    if (isTypeValue(value)) {
-        return formatStructuralType(value.structure);
-    }
-    // Plain dict
-    if (typeof value === 'object') {
-        const dict = value;
-        const parts = Object.entries(dict).map(([k, v]) => `${k}: ${formatValue(v)}`);
-        return `dict[${parts.join(', ')}]`;
-    }
-    return String(value);
-}
-/**
- * Convert a RillValue to a JSON-serializable value.
- * @throws {Error} plain Error (not RuntimeError) for non-serializable types
- */
-export function valueToJSON(value) {
-    if (value === null)
-        return null;
-    if (typeof value === 'string')
-        return value;
-    if (typeof value === 'number')
-        return value;
-    if (typeof value === 'boolean')
-        return value;
-    if (Array.isArray(value)) {
-        return value.map(valueToJSON);
-    }
-    if (isCallable(value)) {
-        throw new Error('closures are not JSON-serializable');
-    }
-    if (isTuple(value)) {
-        throw new Error('tuples are not JSON-serializable');
-    }
-    if (isOrdered(value)) {
-        throw new Error('ordered values are not JSON-serializable');
-    }
-    if (isVector(value)) {
-        throw new Error('vectors are not JSON-serializable');
-    }
-    if (isTypeValue(value)) {
-        throw new Error('type values are not JSON-serializable');
-    }
-    if (isRillIterator(value)) {
-        throw new Error('iterators are not JSON-serializable');
-    }
-    // Plain dict
-    const dict = value;
-    const result = {};
-    for (const [k, v] of Object.entries(dict)) {
-        result[k] = valueToJSON(v);
-    }
-    return result;
-}
+/** Format a value for display. Delegates to type-registrations. */
+export const formatValue = registryFormatValue;
+/** Serialize a Rill value for JSON transport. Delegates to type-registrations. */
+export const serializeValue = registrySerializeValue;
 /**
  * Convert a RillValue to a NativeResult for host consumption.
  * Non-representable types (closures, vectors, type values, iterators) produce descriptor objects.
@@ -795,7 +72,7 @@ export function valueToJSON(value) {
  */
 export function toNative(value) {
     const rillTypeName = inferType(value);
-    const rillTypeSignature = formatStructuralType(inferStructuralType(value));
+    const rillTypeSignature = formatStructure(inferStructure(value));
     const nativeValue = toNativeValue(value);
     return { rillTypeName, rillTypeSignature, value: nativeValue };
 }
@@ -812,7 +89,7 @@ function toNativeValue(value) {
         return value.map(toNativeValue);
     }
     if (isCallable(value)) {
-        return { signature: formatStructuralType(inferStructuralType(value)) };
+        return { signature: formatStructure(inferStructure(value)) };
     }
     if (isTuple(value)) {
         return value.entries.map(toNativeValue);
@@ -830,10 +107,21 @@ function toNativeValue(value) {
     if (isTypeValue(value)) {
         return {
             name: value.typeName,
-            signature: formatStructuralType(value.structure),
+            signature: formatStructure(value.structure),
+        };
+    }
+    if (isStream(value)) {
+        const descriptor = {
+            __type: 'stream',
+            done: value.done,
         };
+        const chunkType = value['__rill_stream_chunk_type'];
+        const retType = value['__rill_stream_ret_type'];
+        descriptor['chunkType'] = chunkType ? formatStructure(chunkType) : null;
+        descriptor['resolutionType'] = retType ? formatStructure(retType) : null;
+        return descriptor;
     }
-    if (isRillIterator(value)) {
+    if (isIterator(value)) {
         return { done: value.done };
     }
     // Plain dict
@@ -844,152 +132,8 @@ function toNativeValue(value) {
     }
     return result;
 }
-/**
- * Deep structural equality for all Rill values.
- * - Primitives: value equality
- * - Tuples: length + recursive element equality
- * - Dicts: same keys + recursive value equality (order-independent)
- */
-export function deepEquals(a, b) {
-    // Handle primitives and null
-    if (a === b)
-        return true;
-    if (a === null || b === null)
-        return false;
-    if (typeof a !== typeof b)
-        return false;
-    // Primitives (string, number, boolean) - covered by === above
-    if (typeof a !== 'object' || typeof b !== 'object')
-        return false;
-    // Both are non-null objects at this point
-    const aObj = a;
-    const bObj = b;
-    // Check for tuples (positional spread args)
-    const aIsTuple = isTuple(a);
-    const bIsTuple = isTuple(b);
-    if (aIsTuple !== bIsTuple)
-        return false;
-    if (aIsTuple && bIsTuple) {
-        if (a.entries.length !== b.entries.length)
-            return false;
-        for (let i = 0; i < a.entries.length; i++) {
-            const aVal = a.entries[i];
-            const bVal = b.entries[i];
-            if (aVal === undefined || bVal === undefined) {
-                if (aVal !== bVal)
-                    return false;
-            }
-            else if (!deepEquals(aVal, bVal)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    // Check for ordered (named spread args)
-    const aIsOrdered = isOrdered(a);
-    const bIsOrdered = isOrdered(b);
-    if (aIsOrdered !== bIsOrdered)
-        return false;
-    if (aIsOrdered && bIsOrdered) {
-        if (a.entries.length !== b.entries.length)
-            return false;
-        for (let i = 0; i < a.entries.length; i++) {
-            const aEntry = a.entries[i];
-            const bEntry = b.entries[i];
-            if (aEntry === undefined || bEntry === undefined)
-                return false;
-            if (aEntry[0] !== bEntry[0])
-                return false;
-            if (!deepEquals(aEntry[1], bEntry[1]))
-                return false;
-        }
-        return true;
-    }
-    // Check for vectors
-    const aIsVector = isVector(a);
-    const bIsVector = isVector(b);
-    if (aIsVector !== bIsVector)
-        return false;
-    if (aIsVector && bIsVector) {
-        // Vectors equal when model matches AND all float elements match
-        if (a.model !== b.model)
-            return false;
-        if (a.data.length !== b.data.length)
-            return false;
-        for (let i = 0; i < a.data.length; i++) {
-            const aVal = a.data[i];
-            const bVal = b.data[i];
-            if (aVal !== bVal)
-                return false;
-        }
-        return true;
-    }
-    // Check for type values (first-class type names)
-    const aIsTypeValue = isTypeValue(a);
-    const bIsTypeValue = isTypeValue(b);
-    if (aIsTypeValue !== bIsTypeValue)
-        return false;
-    if (aIsTypeValue && bIsTypeValue) {
-        return structuralTypeEquals(a.structure, b.structure);
-    }
-    // Check for arrays (lists)
-    const aIsArray = Array.isArray(a);
-    const bIsArray = Array.isArray(b);
-    if (aIsArray !== bIsArray)
-        return false;
-    if (aIsArray && bIsArray) {
-        if (a.length !== b.length)
-            return false;
-        for (let i = 0; i < a.length; i++) {
-            const aElem = a[i];
-            const bElem = b[i];
-            if (aElem === undefined || bElem === undefined) {
-                if (aElem !== bElem)
-                    return false;
-            }
-            else if (!deepEquals(aElem, bElem)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    // Both are dicts (plain objects) or callables
-    // For script callables, use structural equality (params + body AST + captured values)
-    // For runtime/application callables, use reference equality
-    if ('__type' in aObj || '__type' in bObj) {
-        // Both must be callables to be equal
-        if (!('__type' in aObj) || !('__type' in bObj))
-            return false;
-        if (aObj.__type !== 'callable' || bObj.__type !== 'callable')
-            return false;
-        // Script callables: structural equality
-        if (isScriptCallable(a) && isScriptCallable(b)) {
-            return callableEquals(a, b, deepEquals);
-        }
-        // Runtime/application callables: reference equality
-        return a === b;
-    }
-    const aDict = a;
-    const bDict = b;
-    const aKeys = Object.keys(aDict);
-    const bKeys = Object.keys(bDict);
-    if (aKeys.length !== bKeys.length)
-        return false;
-    for (const key of aKeys) {
-        if (!(key in bDict))
-            return false;
-        const aVal = aDict[key];
-        const bVal = bDict[key];
-        if (aVal === undefined || bVal === undefined) {
-            if (aVal !== bVal)
-                return false;
-        }
-        else if (!deepEquals(aVal, bVal)) {
-            return false;
-        }
-    }
-    return true;
-}
+/** Deep structural equality for all Rill values. Delegates to type-registrations. */
+export const deepEquals = registryDeepEquals;
 /** Reserved dict method names that cannot be overridden */
 export const RESERVED_DICT_METHODS = ['keys', 'values', 'entries'];
 /**
@@ -999,19 +143,19 @@ export const RESERVED_DICT_METHODS = ['keys', 'values', 'entries'];
 export const anyTypeValue = Object.freeze({
     __rill_type: true,
     typeName: 'any',
-    structure: { type: 'any' },
+    structure: { kind: 'any' },
 });
 /**
- * Convert a RillType structural descriptor to a RillTypeValue.
- * Uses the RillType's `type` field as the `typeName`.
+ * Convert a TypeStructure descriptor to a RillTypeValue.
+ * Uses the TypeStructure's `kind` field as the `typeName`.
  * Falls back to 'any' for compound types that lack a direct RillTypeName mapping.
  */
-export function rillTypeToTypeValue(type) {
+export function structureToTypeValue(type) {
     const validNames = VALID_TYPE_NAMES;
     return Object.freeze({
         __rill_type: true,
-        typeName: (validNames.includes(type.type)
-            ? type.type
+        typeName: (validNames.includes(type.kind)
+            ? type.kind
             : 'any'),
         structure: type,
     });
@@ -1022,73 +166,17 @@ export function rillTypeToTypeValue(type) {
  * synthesized and hydrated.
  */
 export function hasCollectionFields(type) {
-    return ((type.type === 'dict' && (!!type.fields || !!type.valueType)) ||
-        (type.type === 'ordered' && (!!type.fields || !!type.valueType)) ||
-        (type.type === 'tuple' && (!!type.elements || !!type.valueType)));
-}
-/**
- * Create an empty collection value matching the given RillType.
- * Assumes the type is dict, ordered, or tuple.
- */
-export function emptyForType(type) {
-    if (type.type === 'dict')
-        return {};
-    if (type.type === 'ordered')
-        return createOrdered([]);
-    if (type.type === 'tuple')
-        return createTuple([]);
-    return {};
+    return ((type.kind === 'dict' &&
+        (!!type.fields ||
+            !!type.valueType)) ||
+        (type.kind === 'ordered' &&
+            (!!type.fields ||
+                !!type.valueType)) ||
+        (type.kind === 'tuple' &&
+            (!!type.elements ||
+                !!type.valueType)));
 }
 /** Check if a key name is reserved */
 export function isReservedMethod(name) {
     return RESERVED_DICT_METHODS.includes(name);
 }
-/**
- * Type guard for Rill iterator (lazy sequence).
- * An iterator is a dict with:
- * - done: boolean - whether iteration is complete
- * - next: callable - function to get next iterator
- * - value: any (only required when not done) - current element
- */
-export function isRillIterator(value) {
-    if (!isDict(value))
-        return false;
-    const dict = value;
-    if (!('done' in dict && typeof dict['done'] === 'boolean'))
-        return false;
-    if (!('next' in dict && isCallable(dict['next'])))
-        return false;
-    // 'value' field only required when not done
-    if (!dict['done'] && !('value' in dict))
-        return false;
-    return true;
-}
-/**
- * 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.
- */
-export 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;
-}