@rcrsr/rill 0.16.0 → 0.17.0

package/dist/runtime/core/values.js

@@ -3,10 +3,30 @@
  *
  * 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';
+/**
+ * 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' &&
@@ -57,53 +77,24 @@ 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];
-    let accType = inferStructuralType(firstElem);
+    let accType = inferStructure(firstElem);
     for (let i = 1; i < elements.length; i++) {
         const elem = elements[i];
-        const elemType = inferStructuralType(elem);
+        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 ${formatStructuralType(accType)}, got ${formatStructuralType(elemType)} at index ${i}`);
+            throw new RuntimeError('RILL-R002', `List elements must be the same type: expected ${formatStructure(accType)}, got ${formatStructure(elemType)} at index ${i}`);
         }
         accType = merged;
     }
@@ -113,7 +104,7 @@ export function inferElementType(elements) {
  * 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.
+ * Returns the merged TypeStructure on success, undefined when no uniform merge applies.
  */
 function mergeUniformValueType(aValue, bValue, aFields, bFields) {
     // Sub-case A: both carry valueType
@@ -143,12 +134,12 @@ function mergeUniformValueType(aValue, bValue, aFields, bFields) {
     return undefined;
 }
 /**
- * Return the most specific shared type for two RillType values.
+ * 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 structuralTypeEquals; on true, return a
+ * 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
@@ -156,103 +147,115 @@ function mergeUniformValueType(aValue, bValue, aFields, bFields) {
  */
 export function commonType(a, b) {
     // 1. Any-narrowing
-    if (a.type === 'any')
+    if (a.kind === 'any')
         return b;
-    if (b.type === 'any')
+    if (b.kind === 'any')
         return a;
     // 5. Incompatible top-level types (checked early to short-circuit)
-    if (a.type !== b.type)
+    if (a.kind !== b.kind)
         return null;
     // 2. Structural match
-    if (structuralTypeEquals(a, b))
+    if (structureEquals(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 (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 { type: 'list', element: inner };
+                return { kind: 'list', element: inner };
         }
-        return { type: 'list' };
+        return { kind: '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 (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 { type: 'dict', valueType: merged };
+            return { kind: 'dict', valueType: merged };
     }
-    if (a.type === 'tuple' && b.type === 'tuple') {
-        const merged = mergeUniformValueType(a.valueType, b.valueType, a.elements, b.elements);
+    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 { type: 'tuple', valueType: merged };
+            return { kind: 'tuple', valueType: merged };
     }
-    if (a.type === 'ordered' && b.type === 'ordered') {
-        const merged = mergeUniformValueType(a.valueType, b.valueType, a.fields, b.fields);
+    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 { type: 'ordered', valueType: merged };
+            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 RillType but omitted here intentionally:
+    // For union, members is required by TypeStructure 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 };
+    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') {
-        // Uniform valueType comparison (mirrors list element at line 308)
-        const aHasValue = a.valueType !== undefined;
-        const bHasValue = b.valueType !== 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 structuralTypeEquals(a.valueType, b.valueType);
+            return structureEquals(aDict.valueType, bDict.valueType);
         }
         // Structural fields comparison
-        if (a.fields === undefined && b.fields === undefined)
+        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 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 (!structuralTypeEquals(aField.type, bField.type))
+            if (!structureEquals(aField.type, bField.type))
                 return false;
             if (aHasDefault && bHasDefault) {
                 if (!deepEquals(aField.defaultValue, bField.defaultValue))
@@ -261,26 +264,28 @@ export function structuralTypeEquals(a, b) {
         }
         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 (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 structuralTypeEquals(a.valueType, b.valueType);
+            return structureEquals(aTuple.valueType, bTuple.valueType);
         }
         // Structural elements comparison
-        if (a.elements === undefined && b.elements === undefined)
+        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.type, bElem.type))
+        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;
@@ -293,28 +298,30 @@ export function structuralTypeEquals(a, b) {
         }
         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 (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 structuralTypeEquals(a.valueType, b.valueType);
+            return structureEquals(aOrd.valueType, bOrd.valueType);
         }
         // Structural fields comparison
-        if (a.fields === undefined && b.fields === undefined)
+        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];
+        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.type, bField.type))
+            if (!structureEquals(aField.type, bField.type))
                 return false;
             const aDefault = aField.defaultValue;
             const bDefault = bField.defaultValue;
@@ -327,31 +334,35 @@ 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];
+            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.type, bParam.type))
+                if (!structureEquals(aParam.type, bParam.type))
                     return false;
                 const aDefault = aParam.defaultValue;
                 const bDefault = bParam.defaultValue;
@@ -363,213 +374,213 @@ 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',
+            kind: 'tuple',
             elements: value.entries.map((e) => ({
-                type: inferStructuralType(e),
+                type: inferStructure(e),
             })),
         };
     }
     if (isOrdered(value)) {
         return {
-            type: 'ordered',
+            kind: 'ordered',
             fields: value.entries.map(([k, v]) => ({
                 name: k,
-                type: inferStructuralType(v),
+                type: inferStructure(v),
             })),
         };
     }
     if (isVector(value)) {
-        return { type: 'vector' };
+        return { kind: 'vector' };
     }
     if (isCallable(value)) {
-        const params = (value.params ?? []).map((p) => paramToFieldDef(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] = { type: 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;
-        // Uniform value type check: every value must match valueType
-        if (type.valueType !== undefined) {
+        if (t.valueType !== undefined) {
             const vals = Object.values(value);
-            return vals.every((v) => structuralTypeMatches(v, type.valueType));
+            return vals.every((v) => structureMatches(v, t.valueType));
         }
-        // Absent fields sub-field: matches any dict value
-        if (type.fields === undefined)
+        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)) {
-                const field = type.fields[key];
+                const field = t.fields[key];
                 if (field.defaultValue !== undefined)
                     continue;
                 return false;
             }
-            const field = type.fields[key];
-            if (!structuralTypeMatches(dict[key], field.type))
+            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;
-        // Uniform value type check: every entry must match valueType
-        if (type.valueType !== undefined) {
-            return value.entries.every((v) => structuralTypeMatches(v, type.valueType));
+        if (t.valueType !== undefined) {
+            return value.entries.every((v) => structureMatches(v, t.valueType));
         }
-        // Absent elements sub-field: matches any tuple value
-        if (type.elements === undefined)
+        if (t.elements === undefined)
             return true;
-        if (type.elements.length === 0)
+        if (t.elements.length === 0)
             return value.entries.length === 0;
-        // Reject if value has more entries than type elements
-        if (value.entries.length > type.elements.length)
+        if (value.entries.length > t.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 (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 (!structuralTypeMatches(value.entries[i], type.elements[i].type))
+            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;
-        // Uniform value type check: every entry value must match valueType
-        if (type.valueType !== undefined) {
-            return value.entries.every(([, v]) => structuralTypeMatches(v, type.valueType));
+        if (t.valueType !== undefined) {
+            return value.entries.every(([, v]) => structureMatches(v, t.valueType));
         }
-        // Absent fields sub-field: matches any ordered value
-        if (type.fields === undefined)
+        if (t.fields === undefined)
             return true;
-        if (type.fields.length === 0)
+        if (t.fields.length === 0)
             return value.entries.length === 0;
-        // Reject if value has more entries than type fields
-        if (value.entries.length > type.fields.length)
+        if (value.entries.length > t.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 (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 = type.fields[i];
+            const field = t.fields[i];
             const [actualName, actualValue] = value.entries[i];
             if (actualName !== field.name)
                 return false;
-            if (!structuralTypeMatches(actualValue, field.type))
+            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 field = type.params[i];
+        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 ?? { type: 'any' };
-            if (!structuralTypeEquals(paramType, field.type))
+            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;
 }
+/** @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 };
@@ -592,84 +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.valueType !== undefined && type.fields === undefined) {
-            return `dict(${formatStructuralType(type.valueType)})`;
+    if (type.kind === 'dict') {
+        const t = type;
+        if (t.valueType !== undefined && t.fields === undefined) {
+            return `dict(${formatStructure(t.valueType)})`;
         }
-        if (type.fields === undefined)
+        if (t.fields === undefined)
             return 'dict';
-        const parts = Object.keys(type.fields)
+        const parts = Object.keys(t.fields)
             .sort()
             .map((k) => {
-            const field = type.fields[k];
-            const base = `${k}: ${formatStructuralType(field.type)}`;
+            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.valueType !== undefined && type.elements === undefined) {
-            return `tuple(${formatStructuralType(type.valueType)})`;
+    if (type.kind === 'tuple') {
+        const t = type;
+        if (t.valueType !== undefined && t.elements === undefined) {
+            return `tuple(${formatStructure(t.valueType)})`;
         }
-        if (type.elements === undefined)
+        if (t.elements === undefined)
             return 'tuple';
-        const parts = type.elements.map((field) => {
-            const base = formatStructuralType(field.type);
+        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.type === 'ordered') {
-        if (type.valueType !== undefined && type.fields === undefined) {
-            return `ordered(${formatStructuralType(type.valueType)})`;
+    if (type.kind === 'ordered') {
+        const t = type;
+        if (t.valueType !== undefined && t.fields === undefined) {
+            return `ordered(${formatStructure(t.valueType)})`;
         }
-        if (type.fields === undefined)
+        if (t.fields === undefined)
             return 'ordered';
-        const parts = type.fields.map((field) => {
-            const base = `${field.name}: ${formatStructuralType(field.type)}`;
+        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.type === 'closure') {
-        if (type.params === undefined)
+    if (type.kind === 'closure') {
+        const t = type;
+        if (t.params === undefined)
             return 'closure';
-        const params = type.params
+        const params = t.params
             .map((field) => {
-            const base = `${field.name}: ${formatStructuralType(field.type)}`;
+            const base = `${field.name}: ${formatStructure(field.type)}`;
             if (field.defaultValue === undefined)
                 return base;
             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.
@@ -706,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.
@@ -795,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 };
 }
@@ -812,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);
@@ -830,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
@@ -844,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'];
 /**
@@ -999,43 +798,51 @@ 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.type === 'dict' && (!!type.fields || !!type.valueType)) ||
-        (type.type === 'ordered' && (!!type.fields || !!type.valueType)) ||
-        (type.type === 'tuple' && (!!type.elements || !!type.valueType)));
+    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 RillType.
+ * Create an empty collection value matching the given TypeStructure.
  * Assumes the type is dict, ordered, or tuple.
  */
 export function emptyForType(type) {
-    if (type.type === 'dict')
+    if (type.kind === 'dict')
         return {};
-    if (type.type === 'ordered')
+    if (type.kind === 'ordered')
         return createOrdered([]);
-    if (type.type === 'tuple')
+    if (type.kind === 'tuple')
         return createTuple([]);
     return {};
 }
@@ -1050,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;
@@ -1063,32 +870,9 @@ export function isRillIterator(value) {
         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;
-}
+/** @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;