@rcrsr/rill 0.17.0 → 0.18.0

package/dist/runtime/core/values.js

@@ -4,691 +4,27 @@
  * Core value types that flow through Rill programs.
  * Public API for host applications.
  *
+ * 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.
  */
-import { RuntimeError } from '../../types.js';
 import { VALID_TYPE_NAMES } from '../../constants.js';
-import { isCallable, isDict } from './callable.js';
-import { inferType as registryInferType, formatValue as registryFormatValue, deepEquals as registryDeepEquals, serializeValue as registrySerializeValue, copyValue as registryCopyValue, } from './type-registrations.js';
-/**
- * Normalize a TypeStructure that may use the legacy `.type` discriminator.
- * During migration, some code (builtins.ts, ext/) constructs objects with
- * `{ type: 'string' }` instead of `{ kind: 'string' }`. This function
- * converts legacy format to current format on the fly.
- */
-function normalizeStructure(ts) {
-    if (ts.kind !== undefined)
-        return ts;
-    // Legacy format: { type: 'string' } → { kind: 'string' }
-    const legacy = ts;
-    if (typeof legacy['type'] === 'string') {
-        return { ...legacy, kind: legacy['type'] };
-    }
-    return ts;
-}
-/** 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 };
-}
+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;
-/**
- * Infer the element type for a homogeneous list.
- * Empty arrays return { kind: 'any' }.
- * Mixed types throw RILL-R002.
- */
-export function inferElementType(elements) {
-    if (elements.length === 0)
-        return { kind: 'any' };
-    const firstElem = elements[0];
-    let accType = inferStructure(firstElem);
-    for (let i = 1; i < elements.length; i++) {
-        const elem = elements[i];
-        const elemType = inferStructure(elem);
-        const merged = commonType(accType, elemType);
-        if (merged === null) {
-            throw new RuntimeError('RILL-R002', `List elements must be the same type: expected ${formatStructure(accType)}, got ${formatStructure(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 TypeStructure 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 TypeStructure 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 structureEquals; 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.kind === 'any')
-        return b;
-    if (b.kind === 'any')
-        return a;
-    // 5. Incompatible top-level types (checked early to short-circuit)
-    if (a.kind !== b.kind)
-        return null;
-    // 2. Structural match
-    if (structureEquals(a, b))
-        return a;
-    // 3. Recursive list element merging
-    if (a.kind === 'list' && b.kind === 'list') {
-        const aList = a;
-        const bList = b;
-        if (aList.element !== undefined && bList.element !== undefined) {
-            const inner = commonType(aList.element, bList.element);
-            if (inner !== null)
-                return { kind: 'list', element: inner };
-        }
-        return { kind: 'list' };
-    }
-    // 3b. Uniform valueType merging for dict/tuple/ordered
-    if (a.kind === 'dict' && b.kind === 'dict') {
-        const aDict = a;
-        const bDict = b;
-        const merged = mergeUniformValueType(aDict.valueType, bDict.valueType, aDict.fields ? Object.values(aDict.fields) : undefined, bDict.fields ? Object.values(bDict.fields) : undefined);
-        if (merged !== undefined)
-            return { kind: 'dict', valueType: merged };
-    }
-    if (a.kind === 'tuple' && b.kind === 'tuple') {
-        const aTuple = a;
-        const bTuple = b;
-        const merged = mergeUniformValueType(aTuple.valueType, bTuple.valueType, aTuple.elements, bTuple.elements);
-        if (merged !== undefined)
-            return { kind: 'tuple', valueType: merged };
-    }
-    if (a.kind === 'ordered' && b.kind === 'ordered') {
-        const aOrd = a;
-        const bOrd = b;
-        const merged = mergeUniformValueType(aOrd.valueType, bOrd.valueType, aOrd.fields, bOrd.fields);
-        if (merged !== undefined)
-            return { kind: '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 TypeStructure but omitted here intentionally:
-    // bare union signals structural incompatibility without enumerating members.
-    if (a.kind === 'closure' ||
-        a.kind === 'dict' ||
-        a.kind === 'tuple' ||
-        a.kind === 'ordered' ||
-        a.kind === 'union') {
-        return { kind: a.kind };
-    }
-    return null;
-}
-/** Compare two structural types for equality. */
-export function structureEquals(a, b) {
-    if (a.kind !== b.kind)
-        return false;
-    // Leaf variants compare by kind alone
-    if (a.kind === 'number' ||
-        a.kind === 'string' ||
-        a.kind === 'bool' ||
-        a.kind === 'vector' ||
-        a.kind === 'type' ||
-        a.kind === 'any') {
-        return true;
-    }
-    if (a.kind === 'list' && b.kind === 'list') {
-        const aList = a;
-        const bList = b;
-        if (aList.element === undefined && bList.element === undefined)
-            return true;
-        if (aList.element === undefined || bList.element === undefined)
-            return false;
-        return structureEquals(aList.element, bList.element);
-    }
-    if (a.kind === 'dict' && b.kind === 'dict') {
-        const aDict = a;
-        const bDict = b;
-        // Uniform valueType comparison
-        const aHasValue = aDict.valueType !== undefined;
-        const bHasValue = bDict.valueType !== undefined;
-        if (aHasValue || bHasValue) {
-            if (!aHasValue || !bHasValue)
-                return false;
-            return structureEquals(aDict.valueType, bDict.valueType);
-        }
-        // Structural fields comparison
-        if (aDict.fields === undefined && bDict.fields === undefined)
-            return true;
-        if (aDict.fields === undefined || bDict.fields === undefined)
-            return false;
-        const aKeys = Object.keys(aDict.fields).sort();
-        const bKeys = Object.keys(bDict.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 = aDict.fields[key];
-            const bField = bDict.fields[key];
-            const aHasDefault = aField.defaultValue !== undefined;
-            const bHasDefault = bField.defaultValue !== undefined;
-            if (aHasDefault !== bHasDefault)
-                return false;
-            if (!structureEquals(aField.type, bField.type))
-                return false;
-            if (aHasDefault && bHasDefault) {
-                if (!deepEquals(aField.defaultValue, bField.defaultValue))
-                    return false;
-            }
-        }
-        return true;
-    }
-    if (a.kind === 'tuple' && b.kind === 'tuple') {
-        const aTuple = a;
-        const bTuple = b;
-        // Uniform valueType comparison
-        const aHasValue = aTuple.valueType !== undefined;
-        const bHasValue = bTuple.valueType !== undefined;
-        if (aHasValue || bHasValue) {
-            if (!aHasValue || !bHasValue)
-                return false;
-            return structureEquals(aTuple.valueType, bTuple.valueType);
-        }
-        // Structural elements comparison
-        if (aTuple.elements === undefined && bTuple.elements === undefined)
-            return true;
-        if (aTuple.elements === undefined || bTuple.elements === undefined)
-            return false;
-        if (aTuple.elements.length !== bTuple.elements.length)
-            return false;
-        for (let i = 0; i < aTuple.elements.length; i++) {
-            const aElem = aTuple.elements[i];
-            const bElem = bTuple.elements[i];
-            if (!structureEquals(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.kind === 'ordered' && b.kind === 'ordered') {
-        const aOrd = a;
-        const bOrd = b;
-        // Uniform valueType comparison
-        const aHasValue = aOrd.valueType !== undefined;
-        const bHasValue = bOrd.valueType !== undefined;
-        if (aHasValue || bHasValue) {
-            if (!aHasValue || !bHasValue)
-                return false;
-            return structureEquals(aOrd.valueType, bOrd.valueType);
-        }
-        // Structural fields comparison
-        if (aOrd.fields === undefined && bOrd.fields === undefined)
-            return true;
-        if (aOrd.fields === undefined || bOrd.fields === undefined)
-            return false;
-        if (aOrd.fields.length !== bOrd.fields.length)
-            return false;
-        for (let i = 0; i < aOrd.fields.length; i++) {
-            const aField = aOrd.fields[i];
-            const bField = bOrd.fields[i];
-            if (aField.name !== bField.name)
-                return false;
-            if (!structureEquals(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.kind === 'union' && b.kind === 'union') {
-        const aUnion = a;
-        const bUnion = b;
-        if (aUnion.members.length !== bUnion.members.length)
-            return false;
-        for (let i = 0; i < aUnion.members.length; i++) {
-            if (!structureEquals(aUnion.members[i], bUnion.members[i]))
-                return false;
-        }
-        return true;
-    }
-    if (a.kind === 'closure' && b.kind === 'closure') {
-        const aCls = a;
-        const bCls = b;
-        if (aCls.params === undefined && bCls.params === undefined) {
-            // Both absent: compare ret
-        }
-        else if (aCls.params === undefined || bCls.params === undefined) {
-            return false;
-        }
-        else {
-            if (aCls.params.length !== bCls.params.length)
-                return false;
-            for (let i = 0; i < aCls.params.length; i++) {
-                const aParam = aCls.params[i];
-                const bParam = bCls.params[i];
-                if (aParam.name !== bParam.name)
-                    return false;
-                if (!structureEquals(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 (aCls.ret === undefined && bCls.ret === undefined)
-            return true;
-        if (aCls.ret === undefined || bCls.ret === undefined)
-            return false;
-        return structureEquals(aCls.ret, bCls.ret);
-    }
-    return false;
-}
-/** @deprecated Use structureEquals instead. */
-export const structuralTypeEquals = structureEquals;
-/** Infer the structural type descriptor for any Rill value. */
-export function inferStructure(value) {
-    if (value === null || typeof value === 'string') {
-        return { kind: 'string' };
-    }
-    if (typeof value === 'number') {
-        return { kind: 'number' };
-    }
-    if (typeof value === 'boolean') {
-        return { kind: 'bool' };
-    }
-    if (isTypeValue(value)) {
-        return { kind: 'type' };
-    }
-    if (Array.isArray(value)) {
-        return { kind: 'list', element: inferElementType(value) };
-    }
-    if (isTuple(value)) {
-        return {
-            kind: 'tuple',
-            elements: value.entries.map((e) => ({
-                type: inferStructure(e),
-            })),
-        };
-    }
-    if (isOrdered(value)) {
-        return {
-            kind: 'ordered',
-            fields: value.entries.map(([k, v]) => ({
-                name: k,
-                type: inferStructure(v),
-            })),
-        };
-    }
-    if (isVector(value)) {
-        return { kind: 'vector' };
-    }
-    if (isCallable(value)) {
-        const params = (value.params ?? []).map((p) => paramToFieldDef(p.name, p.type ?? { kind: 'any' }, p.defaultValue));
-        const ret = value.returnType.structure;
-        return { kind: 'closure', params, ret };
-    }
-    if (typeof value === 'object') {
-        const dict = value;
-        const fields = {};
-        for (const [k, v] of Object.entries(dict)) {
-            fields[k] = { type: inferStructure(v) };
-        }
-        return { kind: 'dict', fields };
-    }
-    throw new RuntimeError('RILL-R004', `Cannot infer structural type for ${formatValue(value)}`);
-}
-/** @deprecated Use inferStructure instead. */
-export const inferStructuralType = inferStructure;
-/**
- * Check if a value matches a structural type descriptor.
- * Used for runtime type checking (`:?` operator).
- */
-export function structureMatches(value, type) {
-    type = normalizeStructure(type);
-    if (typeof value === 'undefined') {
-        throw new RuntimeError('RILL-R004', 'Cannot type-check non-value');
-    }
-    if (type.kind === 'any')
-        return true;
-    // Leaf primitive variants: match by inferred type name
-    if (type.kind === 'number' ||
-        type.kind === 'string' ||
-        type.kind === 'bool' ||
-        type.kind === 'vector' ||
-        type.kind === 'type') {
-        return inferType(value) === type.kind;
-    }
-    if (type.kind === 'list') {
-        const t = type;
-        if (!Array.isArray(value))
-            return false;
-        if (t.element === undefined)
-            return true;
-        if (t.element.kind === 'any')
-            return true;
-        return value.every((elem) => structureMatches(elem, t.element));
-    }
-    if (type.kind === 'dict') {
-        const t = type;
-        if (!isDict(value))
-            return false;
-        if (t.valueType !== undefined) {
-            const vals = Object.values(value);
-            return vals.every((v) => structureMatches(v, t.valueType));
-        }
-        if (t.fields === undefined)
-            return true;
-        const dictKeys = Object.keys(t.fields);
-        if (dictKeys.length === 0)
-            return true;
-        const dict = value;
-        for (const key of dictKeys) {
-            if (!(key in dict)) {
-                const field = t.fields[key];
-                if (field.defaultValue !== undefined)
-                    continue;
-                return false;
-            }
-            const field = t.fields[key];
-            if (!structureMatches(dict[key], field.type))
-                return false;
-        }
-        return true;
-    }
-    if (type.kind === 'tuple') {
-        const t = type;
-        if (!isTuple(value))
-            return false;
-        if (t.valueType !== undefined) {
-            return value.entries.every((v) => structureMatches(v, t.valueType));
-        }
-        if (t.elements === undefined)
-            return true;
-        if (t.elements.length === 0)
-            return value.entries.length === 0;
-        if (value.entries.length > t.elements.length)
-            return false;
-        if (value.entries.length < t.elements.length) {
-            for (let i = value.entries.length; i < t.elements.length; i++) {
-                const field = t.elements[i];
-                if (field.defaultValue === undefined)
-                    return false;
-            }
-        }
-        for (let i = 0; i < value.entries.length; i++) {
-            if (!structureMatches(value.entries[i], t.elements[i].type))
-                return false;
-        }
-        return true;
-    }
-    if (type.kind === 'ordered') {
-        const t = type;
-        if (!isOrdered(value))
-            return false;
-        if (t.valueType !== undefined) {
-            return value.entries.every(([, v]) => structureMatches(v, t.valueType));
-        }
-        if (t.fields === undefined)
-            return true;
-        if (t.fields.length === 0)
-            return value.entries.length === 0;
-        if (value.entries.length > t.fields.length)
-            return false;
-        if (value.entries.length < t.fields.length) {
-            for (let i = value.entries.length; i < t.fields.length; i++) {
-                const field = t.fields[i];
-                if (field.defaultValue === undefined)
-                    return false;
-            }
-        }
-        for (let i = 0; i < value.entries.length; i++) {
-            const field = t.fields[i];
-            const [actualName, actualValue] = value.entries[i];
-            if (actualName !== field.name)
-                return false;
-            if (!structureMatches(actualValue, field.type))
-                return false;
-        }
-        return true;
-    }
-    if (type.kind === 'closure') {
-        const t = type;
-        if (!isCallable(value))
-            return false;
-        if (t.params === undefined)
-            return true;
-        const valueParams = value.params ?? [];
-        if (valueParams.length !== t.params.length)
-            return false;
-        for (let i = 0; i < t.params.length; i++) {
-            const field = t.params[i];
-            const param = valueParams[i];
-            if (param.name !== field.name)
-                return false;
-            const paramType = param.type ?? { kind: 'any' };
-            if (!structureEquals(paramType, field.type))
-                return false;
-        }
-        const retType = value.returnType.structure;
-        if (t.ret === undefined)
-            return true;
-        return structureEquals(retType, t.ret);
-    }
-    if (type.kind === 'union') {
-        const t = type;
-        return t.members.some((member) => structureMatches(value, member));
-    }
-    return false;
-}
-/** @deprecated Use structureMatches instead. */
-export const structuralTypeMatches = structureMatches;
-/** 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 formatStructure(type) {
-    if (type.kind === 'any' ||
-        type.kind === 'number' ||
-        type.kind === 'string' ||
-        type.kind === 'bool' ||
-        type.kind === 'vector' ||
-        type.kind === 'type') {
-        return type.kind;
-    }
-    if (type.kind === 'list') {
-        const t = type;
-        if (t.element === undefined)
-            return 'list';
-        return `list(${formatStructure(t.element)})`;
-    }
-    if (type.kind === 'dict') {
-        const t = type;
-        if (t.valueType !== undefined && t.fields === undefined) {
-            return `dict(${formatStructure(t.valueType)})`;
-        }
-        if (t.fields === undefined)
-            return 'dict';
-        const parts = Object.keys(t.fields)
-            .sort()
-            .map((k) => {
-            const field = t.fields[k];
-            const base = `${k}: ${formatStructure(field.type)}`;
-            if (field.defaultValue === undefined)
-                return base;
-            return `${base} = ${formatRillLiteral(field.defaultValue)}`;
-        });
-        return `dict(${parts.join(', ')})`;
-    }
-    if (type.kind === 'tuple') {
-        const t = type;
-        if (t.valueType !== undefined && t.elements === undefined) {
-            return `tuple(${formatStructure(t.valueType)})`;
-        }
-        if (t.elements === undefined)
-            return 'tuple';
-        const parts = t.elements.map((field) => {
-            const base = formatStructure(field.type);
-            if (field.defaultValue === undefined)
-                return base;
-            return `${base} = ${formatRillLiteral(field.defaultValue)}`;
-        });
-        return `tuple(${parts.join(', ')})`;
-    }
-    if (type.kind === 'ordered') {
-        const t = type;
-        if (t.valueType !== undefined && t.fields === undefined) {
-            return `ordered(${formatStructure(t.valueType)})`;
-        }
-        if (t.fields === undefined)
-            return 'ordered';
-        const parts = t.fields.map((field) => {
-            const base = `${field.name}: ${formatStructure(field.type)}`;
-            if (field.defaultValue === undefined)
-                return base;
-            return `${base} = ${formatRillLiteral(field.defaultValue)}`;
-        });
-        return `ordered(${parts.join(', ')})`;
-    }
-    if (type.kind === 'closure') {
-        const t = type;
-        if (t.params === undefined)
-            return 'closure';
-        const params = t.params
-            .map((field) => {
-            const base = `${field.name}: ${formatStructure(field.type)}`;
-            if (field.defaultValue === undefined)
-                return base;
-            return `${base} = ${formatRillLiteral(field.defaultValue)}`;
-        })
-            .join(', ');
-        const ret = t.ret !== undefined ? formatStructure(t.ret) : 'any';
-        return `|${params}| :${ret}`;
-    }
-    if (type.kind === 'union') {
-        const t = type;
-        return t.members.map(formatStructure).join('|');
-    }
-    return 'any';
-}
-/** @deprecated Use formatStructure instead. */
-export const formatStructuralType = formatStructure;
 /**
  * Check if a value is of the expected type.
  * Returns true if the value matches the expected type, false otherwise.
@@ -729,8 +65,6 @@ export function isEmpty(value) {
 export const formatValue = registryFormatValue;
 /** Serialize a Rill value for JSON transport. Delegates to type-registrations. */
 export const serializeValue = registrySerializeValue;
-/** @deprecated Use serializeValue instead. */
-export const valueToJSON = serializeValue;
 /**
  * Convert a RillValue to a NativeResult for host consumption.
  * Non-representable types (closures, vectors, type values, iterators) produce descriptor objects.
@@ -776,6 +110,17 @@ function toNativeValue(value) {
             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 (isIterator(value)) {
         return { done: value.done };
     }
@@ -815,8 +160,6 @@ export function structureToTypeValue(type) {
         structure: type,
     });
 }
-/** @deprecated Use structureToTypeValue instead. */
-export const rillTypeToTypeValue = structureToTypeValue;
 /**
  * Check if a type is a collection (dict, ordered, tuple) with defined
  * fields or elements. Used to decide if an empty collection can be
@@ -833,46 +176,7 @@ export function hasCollectionFields(type) {
             (!!type.elements ||
                 !!type.valueType)));
 }
-/**
- * Create an empty collection value matching the given TypeStructure.
- * Assumes the type is dict, ordered, or tuple.
- */
-export function emptyForType(type) {
-    if (type.kind === 'dict')
-        return {};
-    if (type.kind === 'ordered')
-        return createOrdered([]);
-    if (type.kind === 'tuple')
-        return createTuple([]);
-    return {};
-}
 /** 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 isIterator(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;
-}
-/** @deprecated Use isIterator instead. */
-export const isRillIterator = isIterator;
-/** Copy a RillValue. Delegates to type-registrations. */
-export const copyValue = registryCopyValue;
-/** @deprecated Use copyValue instead. */
-export const deepCopyRillValue = copyValue;