@rcrsr/rill 0.15.0 → 0.17.0

package/dist/runtime/core/values.js

@@ -3,18 +3,29 @@
  *
  * Core value types that flow through Rill programs.
  * Public API for host applications.
+ *
+ * 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 { callableEquals, isCallable, isDict, isScriptCallable, } from './callable.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';
 /**
- * Type guard to distinguish the `{ type, defaultValue }` form of RillFieldType
- * from a plain RillType.
+ * 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.
  */
-export function isFieldTypeWithDefault(fieldType) {
-    return (typeof fieldType === 'object' &&
-        fieldType !== null &&
-        'defaultValue' in fieldType);
+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) {
@@ -44,7 +55,11 @@ export function isTypeValue(value) {
         '__rill_type' in value &&
         value.__rill_type === true);
 }
-/** Create ordered from entries array (named, preserves insertion order) */
+/**
+ * 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] });
 }
@@ -62,98 +77,185 @@ export function createVector(data, model) {
     }
     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 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 { type: 'any' }.
+ * Empty arrays return { kind: 'any' }.
  * Mixed types throw RILL-R002.
  */
 export function inferElementType(elements) {
     if (elements.length === 0)
-        return { type: 'any' };
+        return { kind: 'any' };
     const firstElem = elements[0];
-    const firstType = inferStructuralType(firstElem);
+    let accType = inferStructure(firstElem);
     for (let i = 1; i < elements.length; i++) {
         const elem = elements[i];
-        const elemType = inferStructuralType(elem);
-        if (!structuralTypeEquals(firstType, elemType)) {
-            throw new RuntimeError('RILL-R002', `List elements must be the same type: expected ${formatStructuralType(firstType)}, got ${formatStructuralType(elemType)} at index ${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 firstType;
+    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 structuralTypeEquals(a, b) {
-    if (a.type !== b.type)
+export function structureEquals(a, b) {
+    if (a.kind !== b.kind)
         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') {
+    // 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.type === 'list' && b.type === 'list') {
-        if (a.element === undefined && b.element === undefined)
+    if (a.kind === 'list' && b.kind === 'list') {
+        const aList = a;
+        const bList = b;
+        if (aList.element === undefined && bList.element === undefined)
             return true;
-        if (a.element === undefined || b.element === undefined)
+        if (aList.element === undefined || bList.element === undefined)
             return false;
-        return structuralTypeEquals(a.element, b.element);
-    }
-    if (a.type === 'dict' && b.type === 'dict') {
-        if (a.fields === undefined && b.fields === undefined)
+        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 (a.fields === undefined || b.fields === undefined)
+        if (aDict.fields === undefined || bDict.fields === undefined)
             return false;
-        const aKeys = Object.keys(a.fields).sort();
-        const bKeys = Object.keys(b.fields).sort();
+        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 = a.fields[key];
-            const bField = b.fields[key];
-            const aHasDefault = isFieldTypeWithDefault(aField);
-            const bHasDefault = isFieldTypeWithDefault(bField);
+            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;
-            const aType = aHasDefault ? aField.type : aField;
-            const bType = bHasDefault ? bField.type : bField;
-            if (!structuralTypeEquals(aType, bType))
+            if (!structureEquals(aField.type, bField.type))
                 return false;
             if (aHasDefault && bHasDefault) {
                 if (!deepEquals(aField.defaultValue, bField.defaultValue))
@@ -162,20 +264,31 @@ export function structuralTypeEquals(a, b) {
         }
         return true;
     }
-    if (a.type === 'tuple' && b.type === 'tuple') {
-        if (a.elements === undefined && b.elements === undefined)
+    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 (a.elements === undefined || b.elements === undefined)
+        if (aTuple.elements === undefined || bTuple.elements === undefined)
             return false;
-        if (a.elements.length !== b.elements.length)
+        if (aTuple.elements.length !== bTuple.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[0], bElem[0]))
+        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[1];
-            const bDefault = bElem[1];
+            const aDefault = aElem.defaultValue;
+            const bDefault = bElem.defaultValue;
             if (aDefault === undefined && bDefault === undefined)
                 continue;
             if (aDefault === undefined || bDefault === undefined)
@@ -185,22 +298,33 @@ export function structuralTypeEquals(a, b) {
         }
         return true;
     }
-    if (a.type === 'ordered' && b.type === 'ordered') {
-        if (a.fields === undefined && b.fields === undefined)
+    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 (a.fields === undefined || b.fields === undefined)
+        if (aOrd.fields === undefined || bOrd.fields === undefined)
             return false;
-        if (a.fields.length !== b.fields.length)
+        if (aOrd.fields.length !== bOrd.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[0] !== bField[0])
+        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 (!structuralTypeEquals(aField[1], bField[1]))
+            if (!structureEquals(aField.type, bField.type))
                 return false;
-            const aDefault = aField[2];
-            const bDefault = bField[2];
+            const aDefault = aField.defaultValue;
+            const bDefault = bField.defaultValue;
             if (aDefault === undefined && bDefault === undefined)
                 continue;
             if (aDefault === undefined || bDefault === undefined)
@@ -210,34 +334,38 @@ export function structuralTypeEquals(a, b) {
         }
         return true;
     }
-    if (a.type === 'union' && b.type === 'union') {
-        if (a.members.length !== b.members.length)
+    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 < a.members.length; i++) {
-            if (!structuralTypeEquals(a.members[i], b.members[i]))
+        for (let i = 0; i < aUnion.members.length; i++) {
+            if (!structureEquals(aUnion.members[i], bUnion.members[i]))
                 return false;
         }
         return true;
     }
-    if (a.type === 'closure' && b.type === 'closure') {
-        if (a.params === undefined && b.params === undefined) {
+    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 (a.params === undefined || b.params === undefined) {
+        else if (aCls.params === undefined || bCls.params === undefined) {
             return false;
         }
         else {
-            if (a.params.length !== b.params.length)
+            if (aCls.params.length !== bCls.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[0] !== bParam[0])
+            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 (!structuralTypeEquals(aParam[1], bParam[1]))
+                if (!structureEquals(aParam.type, bParam.type))
                     return false;
-                const aDefault = aParam[2];
-                const bDefault = bParam[2];
+                const aDefault = aParam.defaultValue;
+                const bDefault = bParam.defaultValue;
                 if (aDefault === undefined && bDefault === undefined)
                     continue;
                 if (aDefault === undefined || bDefault === undefined)
@@ -246,184 +374,219 @@ export function structuralTypeEquals(a, b) {
                     return false;
             }
         }
-        if (a.ret === undefined && b.ret === undefined)
+        if (aCls.ret === undefined && bCls.ret === undefined)
             return true;
-        if (a.ret === undefined || b.ret === undefined)
+        if (aCls.ret === undefined || bCls.ret === undefined)
             return false;
-        return structuralTypeEquals(a.ret, b.ret);
+        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 inferStructuralType(value) {
+export function inferStructure(value) {
     if (value === null || typeof value === 'string') {
-        return { type: 'string' };
+        return { kind: 'string' };
     }
     if (typeof value === 'number') {
-        return { type: 'number' };
+        return { kind: 'number' };
     }
     if (typeof value === 'boolean') {
-        return { type: 'bool' };
+        return { kind: 'bool' };
     }
     if (isTypeValue(value)) {
-        return { type: 'type' };
+        return { kind: 'type' };
     }
     if (Array.isArray(value)) {
-        return { type: 'list', element: inferElementType(value) };
+        return { kind: 'list', element: inferElementType(value) };
     }
     if (isTuple(value)) {
         return {
-            type: 'tuple',
-            elements: value.entries.map((e) => [
-                inferStructuralType(e),
-            ]),
+            kind: 'tuple',
+            elements: value.entries.map((e) => ({
+                type: inferStructure(e),
+            })),
         };
     }
     if (isOrdered(value)) {
         return {
-            type: 'ordered',
-            fields: value.entries.map(([k, v]) => [
-                k,
-                inferStructuralType(v),
-            ]),
+            kind: 'ordered',
+            fields: value.entries.map(([k, v]) => ({
+                name: k,
+                type: inferStructure(v),
+            })),
         };
     }
     if (isVector(value)) {
-        return { type: 'vector' };
+        return { kind: 'vector' };
     }
     if (isCallable(value)) {
-        const params = (value.params ?? []).map((p) => paramToTypeTuple(p.name, p.type ?? { type: 'any' }, p.defaultValue));
+        const params = (value.params ?? []).map((p) => paramToFieldDef(p.name, p.type ?? { kind: 'any' }, p.defaultValue));
         const ret = value.returnType.structure;
-        return { type: 'closure', params, ret };
+        return { kind: 'closure', params, ret };
     }
     if (typeof value === 'object') {
         const dict = value;
         const fields = {};
         for (const [k, v] of Object.entries(dict)) {
-            fields[k] = inferStructuralType(v);
+            fields[k] = { type: inferStructure(v) };
         }
-        return { type: 'dict', fields };
+        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 structuralTypeMatches(value, type) {
+export function structureMatches(value, type) {
+    type = normalizeStructure(type);
     if (typeof value === 'undefined') {
         throw new RuntimeError('RILL-R004', 'Cannot type-check non-value');
     }
-    if (type.type === 'any')
+    if (type.kind === '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 (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;
-        // Absent element sub-field: matches any list value
-        if (type.element === undefined)
+        if (t.element === undefined)
             return true;
-        if (type.element.type === 'any')
+        if (t.element.kind === 'any')
             return true;
-        return value.every((elem) => structuralTypeMatches(elem, type.element));
+        return value.every((elem) => structureMatches(elem, t.element));
     }
-    if (type.type === 'dict') {
+    if (type.kind === 'dict') {
+        const t = type;
         if (!isDict(value))
             return false;
-        // Absent fields sub-field: matches any dict value
-        if (type.fields === undefined)
+        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(type.fields);
-        // Empty fields object matches any dict
+        const dictKeys = Object.keys(t.fields);
         if (dictKeys.length === 0)
             return true;
         const dict = value;
         for (const key of dictKeys) {
-            if (!(key in dict))
+            if (!(key in dict)) {
+                const field = t.fields[key];
+                if (field.defaultValue !== undefined)
+                    continue;
                 return false;
-            const fieldType = type.fields[key];
-            const resolvedType = isFieldTypeWithDefault(fieldType)
-                ? fieldType.type
-                : fieldType;
-            if (!structuralTypeMatches(dict[key], resolvedType))
+            }
+            const field = t.fields[key];
+            if (!structureMatches(dict[key], field.type))
                 return false;
         }
         return true;
     }
-    if (type.type === 'tuple') {
+    if (type.kind === 'tuple') {
+        const t = type;
         if (!isTuple(value))
             return false;
-        // Absent elements sub-field: matches any tuple value
-        if (type.elements === undefined)
+        if (t.valueType !== undefined) {
+            return value.entries.every((v) => structureMatches(v, t.valueType));
+        }
+        if (t.elements === undefined)
             return true;
-        if (type.elements.length === 0)
+        if (t.elements.length === 0)
             return value.entries.length === 0;
-        if (value.entries.length !== type.elements.length)
+        if (value.entries.length > t.elements.length)
             return false;
-        for (let i = 0; i < type.elements.length; i++) {
-            if (!structuralTypeMatches(value.entries[i], type.elements[i][0]))
+        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.type === 'ordered') {
+    if (type.kind === 'ordered') {
+        const t = type;
         if (!isOrdered(value))
             return false;
-        // Absent fields sub-field: matches any ordered value
-        if (type.fields === undefined)
+        if (t.valueType !== undefined) {
+            return value.entries.every(([, v]) => structureMatches(v, t.valueType));
+        }
+        if (t.fields === undefined)
             return true;
-        if (type.fields.length === 0)
+        if (t.fields.length === 0)
             return value.entries.length === 0;
-        if (value.entries.length !== type.fields.length)
+        if (value.entries.length > t.fields.length)
             return false;
-        for (let i = 0; i < type.fields.length; i++) {
-            const [expectedName, expectedType] = type.fields[i];
+        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 !== expectedName)
+            if (actualName !== field.name)
                 return false;
-            if (!structuralTypeMatches(actualValue, expectedType))
+            if (!structureMatches(actualValue, field.type))
                 return false;
         }
         return true;
     }
-    if (type.type === 'closure') {
+    if (type.kind === 'closure') {
+        const t = type;
         if (!isCallable(value))
             return false;
-        // Absent params sub-field: matches any closure value of that compound type
-        if (type.params === undefined)
+        if (t.params === undefined)
             return true;
         const valueParams = value.params ?? [];
-        if (valueParams.length !== type.params.length)
+        if (valueParams.length !== t.params.length)
             return false;
-        for (let i = 0; i < type.params.length; i++) {
-            const [expectedName, expectedType] = type.params[i];
+        for (let i = 0; i < t.params.length; i++) {
+            const field = t.params[i];
             const param = valueParams[i];
-            if (param.name !== expectedName)
+            if (param.name !== field.name)
                 return false;
-            const paramType = param.type ?? { type: 'any' };
-            if (!structuralTypeEquals(paramType, expectedType))
+            const paramType = param.type ?? { kind: 'any' };
+            if (!structureEquals(paramType, field.type))
                 return false;
         }
         const retType = value.returnType.structure;
-        if (type.ret === undefined)
+        if (t.ret === undefined)
             return true;
-        return structuralTypeEquals(retType, type.ret);
+        return structureEquals(retType, t.ret);
     }
-    if (type.type === 'union') {
-        return type.members.some((member) => structuralTypeMatches(value, member));
+    if (type.kind === 'union') {
+        const t = type;
+        return t.members.some((member) => structureMatches(value, member));
     }
     return false;
 }
-/** Build a closure param tuple, omitting the optional third element when no default. */
-export function paramToTypeTuple(name, type, defaultValue) {
-    return defaultValue !== undefined ? [name, type, defaultValue] : [name, type];
+/** @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) {
@@ -440,75 +603,92 @@ function formatRillLiteral(value) {
     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)
+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(${formatStructuralType(type.element)})`;
+        return `list(${formatStructure(t.element)})`;
     }
-    if (type.type === 'dict') {
-        if (type.fields === undefined)
+    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(type.fields)
+        const parts = Object.keys(t.fields)
             .sort()
             .map((k) => {
-            const fieldType = type.fields[k];
-            if (isFieldTypeWithDefault(fieldType)) {
-                return `${k}: ${formatStructuralType(fieldType.type)} = ${formatRillLiteral(fieldType.defaultValue)}`;
-            }
-            return `${k}: ${formatStructuralType(fieldType)}`;
+            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.type === 'tuple') {
-        if (type.elements === undefined)
+    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 = type.elements.map(([t, defaultVal]) => {
-            const base = formatStructuralType(t);
-            if (defaultVal === undefined)
+        const parts = t.elements.map((field) => {
+            const base = formatStructure(field.type);
+            if (field.defaultValue === undefined)
                 return base;
-            return `${base} = ${formatRillLiteral(defaultVal)}`;
+            return `${base} = ${formatRillLiteral(field.defaultValue)}`;
         });
         return `tuple(${parts.join(', ')})`;
     }
-    if (type.type === 'ordered') {
-        if (type.fields === undefined)
+    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 = type.fields.map(([k, t, defaultVal]) => {
-            const base = `${k}: ${formatStructuralType(t)}`;
-            if (defaultVal === undefined)
+        const parts = t.fields.map((field) => {
+            const base = `${field.name}: ${formatStructure(field.type)}`;
+            if (field.defaultValue === undefined)
                 return base;
-            return `${base} = ${formatRillLiteral(defaultVal)}`;
+            return `${base} = ${formatRillLiteral(field.defaultValue)}`;
         });
         return `ordered(${parts.join(', ')})`;
     }
-    if (type.type === 'closure') {
-        if (type.params === undefined)
+    if (type.kind === 'closure') {
+        const t = type;
+        if (t.params === undefined)
             return 'closure';
-        const params = type.params
-            .map(([name, t, defaultVal]) => {
-            const base = `${name}: ${formatStructuralType(t)}`;
-            if (defaultVal === undefined)
+        const params = t.params
+            .map((field) => {
+            const base = `${field.name}: ${formatStructure(field.type)}`;
+            if (field.defaultValue === undefined)
                 return base;
-            return `${base} = ${formatRillLiteral(defaultVal)}`;
+            return `${base} = ${formatRillLiteral(field.defaultValue)}`;
         })
             .join(', ');
-        const ret = type.ret !== undefined ? formatStructuralType(type.ret) : 'any';
+        const ret = t.ret !== undefined ? formatStructure(t.ret) : 'any';
         return `|${params}| :${ret}`;
     }
-    if (type.type === 'union') {
-        return type.members.map(formatStructuralType).join('|');
+    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.
@@ -545,88 +725,12 @@ 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;
+/** @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.
@@ -634,7 +738,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 };
 }
@@ -651,7 +755,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);
@@ -669,10 +773,10 @@ function toNativeValue(value) {
     if (isTypeValue(value)) {
         return {
             name: value.typeName,
-            signature: formatStructuralType(value.structure),
+            signature: formatStructure(value.structure),
         };
     }
-    if (isRillIterator(value)) {
+    if (isIterator(value)) {
         return { done: value.done };
     }
     // Plain dict
@@ -683,152 +787,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'];
 /**
@@ -838,23 +798,54 @@ 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,
     });
 }
+/** @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
+ * synthesized and hydrated.
+ */
+export function hasCollectionFields(type) {
+    return ((type.kind === 'dict' &&
+        (!!type.fields ||
+            !!type.valueType)) ||
+        (type.kind === 'ordered' &&
+            (!!type.fields ||
+                !!type.valueType)) ||
+        (type.kind === 'tuple' &&
+            (!!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);
@@ -866,7 +857,7 @@ export function isReservedMethod(name) {
  * - next: callable - function to get next iterator
  * - value: any (only required when not done) - current element
  */
-export function isRillIterator(value) {
+export function isIterator(value) {
     if (!isDict(value))
         return false;
     const dict = value;
@@ -879,4 +870,9 @@ export function isRillIterator(value) {
         return false;
     return true;
 }
-//# sourceMappingURL=values.js.map
+/** @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;