@rcrsr/rill 0.17.0 → 0.18.0

package/dist/runtime/core/{type-registrations.d.ts → types/registrations.d.ts}

@@ -7,17 +7,18 @@
  * convertTo, serialize), and a methods record populated from BUILTIN_METHODS.
  *
  * Dispatch functions (inferType, formatValue, deepEquals, serializeValue,
- * deserializeValue, copyValue) iterate registrations and delegate to
- * per-type protocol implementations.
+ * deserializeValue) iterate registrations and delegate to per-type
+ * protocol implementations.
  *
  * Registration order:
  *   primitives -> discriminator-based -> structural -> list -> dict fallback
  *
  * @internal
  */
-import type { TypeStructure, RillValue, RillFieldDef, RillTuple, RillOrdered, RillVector, RillTypeValue, RillIterator } from './values.js';
-import type { RillFunction } from './callable.js';
-import { isTuple, isVector, isOrdered, isTypeValue, isIterator, createTuple, createOrdered, createVector } from './values.js';
+import type { TypeStructure, RillValue, RillFieldDef, RillTuple, RillOrdered, RillVector, RillTypeValue, RillIterator, RillStream } from './structures.js';
+import type { RillFunction } from '../callable.js';
+import { isStream, isTuple, isVector, isOrdered, isTypeValue, isIterator } from './guards.js';
+import { createTuple, createOrdered, createVector } from './constructors.js';
 /**
  * Protocol functions that define per-type behavior.
  * Every type must provide `format`. All other protocols are optional.
@@ -44,20 +45,20 @@ export interface TypeDefinition {
     protocol: TypeProtocol;
 }
 /**
- * All 12 built-in type registrations.
+ * All 13 built-in type registrations.
  *
  * Registration order:
  * 1. Primitives: string, number, bool
  * 2. Discriminator-based: tuple, ordered, vector, type, closure, field_descriptor
- * 3. Structural: iterator
+ * 3. Structural: iterator, stream
  * 4. list
  * 5. dict (fallback, must be last)
  *
- * AC-1: 12 registrations, one per type.
+ * AC-1: 13 registrations, one per type.
  * BC-2: Vector identity checked before dict fallback.
  * EC-3: Iterator has no protocol.eq.
  * EC-4: Bool has no protocol.compare.
- * EC-8: Non-serializable types throw plain Error.
+ * EC-8: Non-serializable types throw RuntimeError (RILL-R067).
  */
 export declare const BUILT_IN_TYPES: readonly TypeDefinition[];
 /**
@@ -102,15 +103,6 @@ export declare function serializeValue(value: RillValue): unknown;
  * EC-10: null/undefined input raises RILL-R004.
  */
 export declare function deserializeValue(data: unknown, typeName: string): RillValue;
-/**
- * Copy a Rill value.
- * Reads immutable flag from registration.
- * Immutable types return same reference.
- * Mutable types (list, dict, iterator) recurse.
- *
- * IR-9: Renamed from deepCopyRillValue.
- */
-export declare function copyValue(value: RillValue): RillValue;
 /**
  * Populate registration `methods` fields from BUILTIN_METHODS.
  *
@@ -129,8 +121,6 @@ export declare function copyValue(value: RillValue): RillValue;
  */
 export declare function populateBuiltinMethods(builtinMethods: Record<string, Record<string, RillFunction>>): void;
 export { createTuple, createOrdered, createVector };
-export { isTuple, isVector, isTypeValue, isOrdered, isIterator };
-/** @deprecated Use isIterator instead. */
-export declare const isRillIterator: typeof isIterator;
+export { isStream, isTuple, isVector, isTypeValue, isOrdered, isIterator };
 export type { TypeStructure };
-export type { RillValue, RillTuple, RillOrdered, RillVector, RillTypeValue, RillIterator, RillFieldDef, };
+export type { RillValue, RillTuple, RillOrdered, RillVector, RillTypeValue, RillIterator, RillStream, RillFieldDef, };

package/dist/runtime/core/{type-registrations.js → types/registrations.js}

@@ -7,17 +7,19 @@
  * convertTo, serialize), and a methods record populated from BUILTIN_METHODS.
  *
  * Dispatch functions (inferType, formatValue, deepEquals, serializeValue,
- * deserializeValue, copyValue) iterate registrations and delegate to
- * per-type protocol implementations.
+ * deserializeValue) iterate registrations and delegate to per-type
+ * protocol implementations.
  *
  * Registration order:
  *   primitives -> discriminator-based -> structural -> list -> dict fallback
  *
  * @internal
  */
-import { isTuple, isVector, isOrdered, isTypeValue, isIterator, createTuple, createOrdered, createVector, formatStructure, structureEquals, } from './values.js';
-import { isCallable, isDict, isScriptCallable, callableEquals, } from './callable.js';
-import { RuntimeError } from '../../types.js';
+import { isStream, isTuple, isVector, isOrdered, isTypeValue, isIterator, } from './guards.js';
+import { createTuple, createOrdered, createVector } from './constructors.js';
+import { formatStructure, structureEquals } from './operations.js';
+import { isCallable, isDict, isScriptCallable, callableEquals, } from '../callable.js';
+import { RuntimeError } from '../../../types.js';
 // ============================================================
 // IDENTITY HELPERS
 // ============================================================
@@ -72,6 +74,9 @@ function formatFieldDescriptor(_v) {
 function formatIterator(_v) {
     return 'type(iterator)';
 }
+function formatStream(_v) {
+    return 'type(stream)';
+}
 function formatList(v) {
     const arr = v;
     return `list[${arr.map(formatValue).join(', ')}]`;
@@ -93,40 +98,47 @@ function eqNumber(a, b) {
 function eqBool(a, b) {
     return a === b;
 }
-function eqTuple(a, b) {
-    if (!isTuple(a) || !isTuple(b))
-        return false;
-    if (a.entries.length !== b.entries.length)
+/**
+ * Parameterized element-wise comparison for collections.
+ * Replaces duplicated loops in eqTuple, eqList, eqOrdered.
+ *
+ * AC-40: Zero-length collections return true.
+ * AC-19: eqTuple, eqList, eqOrdered delegate loop body here.
+ */
+function compareElements(aEntries, bEntries, comparator) {
+    if (aEntries.length !== bEntries.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)) {
+    for (let i = 0; i < aEntries.length; i++) {
+        if (!comparator(aEntries[i], bEntries[i]))
             return false;
-        }
     }
     return true;
 }
+/** Element comparator for tuple and list entries: handles undefined, delegates to deepEquals. */
+function compareByDeepEquals(a, b) {
+    if (a === undefined || b === undefined)
+        return a === b;
+    return deepEquals(a, b);
+}
+/** Entry comparator for ordered: keys by identity, values by deepEquals. */
+function compareOrderedEntry(a, b) {
+    const aEntry = a;
+    const bEntry = b;
+    if (aEntry === undefined || bEntry === undefined)
+        return false;
+    if (aEntry[0] !== bEntry[0])
+        return false;
+    return deepEquals(aEntry[1], bEntry[1]);
+}
+function eqTuple(a, b) {
+    if (!isTuple(a) || !isTuple(b))
+        return false;
+    return compareElements(a.entries, b.entries, compareByDeepEquals);
+}
 function eqOrdered(a, b) {
     if (!isOrdered(a) || !isOrdered(b))
         return false;
-    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;
+    return compareElements(a.entries, b.entries, compareOrderedEntry);
 }
 function eqVector(a, b) {
     if (!isVector(a) || !isVector(b))
@@ -163,20 +175,7 @@ function eqFieldDescriptor(a, b) {
 function eqList(a, b) {
     if (!Array.isArray(a) || !Array.isArray(b))
         return false;
-    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;
+    return compareElements(a, b, compareByDeepEquals);
 }
 function eqDict(a, b) {
     const aDict = a;
@@ -228,7 +227,7 @@ const stringConvertTo = {
         const str = v;
         const parsed = Number(str);
         if (isNaN(parsed) || str.trim() === '') {
-            throw new Error(`cannot convert string "${str}" to number`);
+            throw new RuntimeError('RILL-R064', `cannot convert string "${str}" to number`);
         }
         return parsed;
     },
@@ -238,7 +237,7 @@ const stringConvertTo = {
             return true;
         if (s === 'false')
             return false;
-        throw new Error(`cannot convert string "${s}" to bool`);
+        throw new RuntimeError('RILL-R065', `cannot convert string "${s}" to bool`);
     },
 };
 /**
@@ -254,7 +253,7 @@ const numberConvertTo = {
             return false;
         if (n === 1)
             return true;
-        throw new Error(`cannot convert number ${n} to bool`);
+        throw new RuntimeError('RILL-R066', `cannot convert number ${n} to bool`);
     },
 };
 /**
@@ -333,6 +332,13 @@ const closureConvertTo = {
 const iteratorConvertTo = {
     string: (_v) => 'type(iterator)',
 };
+/**
+ * Stream convertTo targets.
+ * - stream -> string: format
+ */
+const streamConvertTo = {
+    string: (_v) => 'type(stream)',
+};
 // ============================================================
 // PROTOCOL IMPLEMENTATIONS: SERIALIZE
 // ============================================================
@@ -363,17 +369,19 @@ function serializeListElement(v) {
     if (Array.isArray(v))
         return v.map(serializeListElement);
     if (isCallable(v))
-        throw new Error('closures are not JSON-serializable');
+        throw new RuntimeError('RILL-R067', 'closures are not JSON-serializable');
     if (isTuple(v))
-        throw new Error('tuples are not JSON-serializable');
+        throw new RuntimeError('RILL-R067', 'tuples are not JSON-serializable');
     if (isOrdered(v))
-        throw new Error('ordered values are not JSON-serializable');
+        throw new RuntimeError('RILL-R067', 'ordered values are not JSON-serializable');
     if (isVector(v))
-        throw new Error('vectors are not JSON-serializable');
+        throw new RuntimeError('RILL-R067', 'vectors are not JSON-serializable');
     if (isTypeValue(v))
-        throw new Error('type values are not JSON-serializable');
+        throw new RuntimeError('RILL-R067', 'type values are not JSON-serializable');
     if (isIterator(v))
-        throw new Error('iterators are not JSON-serializable');
+        throw new RuntimeError('RILL-R067', 'iterators are not JSON-serializable');
+    if (isStream(v))
+        throw new RuntimeError('RILL-R067', 'streams are not JSON-serializable');
     // Plain dict
     const dict = v;
     const result = {};
@@ -392,27 +400,27 @@ function serializeDict(v) {
 }
 function throwNotSerializable(typeName) {
     return (_v) => {
-        throw new Error(`${typeName}s are not JSON-serializable`);
+        throw new RuntimeError('RILL-R067', `${typeName}s are not JSON-serializable`);
     };
 }
 // ============================================================
 // BUILT-IN TYPE REGISTRATIONS
 // ============================================================
 /**
- * All 12 built-in type registrations.
+ * All 13 built-in type registrations.
  *
  * Registration order:
  * 1. Primitives: string, number, bool
  * 2. Discriminator-based: tuple, ordered, vector, type, closure, field_descriptor
- * 3. Structural: iterator
+ * 3. Structural: iterator, stream
  * 4. list
  * 5. dict (fallback, must be last)
  *
- * AC-1: 12 registrations, one per type.
+ * AC-1: 13 registrations, one per type.
  * BC-2: Vector identity checked before dict fallback.
  * EC-3: Iterator has no protocol.eq.
  * EC-4: Bool has no protocol.compare.
- * EC-8: Non-serializable types throw plain Error.
+ * EC-8: Non-serializable types throw RuntimeError (RILL-R067).
  */
 export const BUILT_IN_TYPES = Object.freeze([
     // ---- Primitives ----
@@ -538,6 +546,31 @@ export const BUILT_IN_TYPES = Object.freeze([
         },
     },
     // ---- Structural ----
+    // Stream must precede iterator: streams satisfy the iterator shape
+    // (done + next + value) but have the __rill_stream discriminator.
+    {
+        name: 'stream',
+        identity: (v) => isStream(v),
+        isLeaf: false,
+        immutable: true,
+        methods: {},
+        protocol: {
+            format: formatStream,
+            convertTo: streamConvertTo,
+            serialize: throwNotSerializable('stream'),
+            structure: (v) => {
+                const raw = v;
+                const chunk = raw['__rill_stream_chunk_type'];
+                const ret = raw['__rill_stream_ret_type'];
+                const result = { kind: 'stream' };
+                if (chunk !== undefined)
+                    result.chunk = chunk;
+                if (ret !== undefined)
+                    result.ret = ret;
+                return result;
+            },
+        },
+    },
     {
         // EC-3: iterator has no protocol.eq (equality raises RILL-R002)
         name: 'iterator',
@@ -669,35 +702,6 @@ export function deserializeValue(data, typeName) {
     }
     throw new RuntimeError('RILL-R004', `Cannot deserialize as ${typeName}`);
 }
-/**
- * Copy a Rill value.
- * Reads immutable flag from registration.
- * Immutable types return same reference.
- * Mutable types (list, dict, iterator) recurse.
- *
- * IR-9: Renamed from deepCopyRillValue.
- */
-export function copyValue(value) {
-    if (value === null || typeof value !== 'object')
-        return value;
-    for (const reg of BUILT_IN_TYPES) {
-        if (reg.identity(value)) {
-            if (reg.immutable)
-                return value;
-            break;
-        }
-    }
-    // Mutable: list or dict, recurse
-    if (Array.isArray(value)) {
-        return value.map(copyValue);
-    }
-    const dict = value;
-    const copy = {};
-    for (const [k, v] of Object.entries(dict)) {
-        copy[k] = copyValue(v);
-    }
-    return copy;
-}
 // ============================================================
 // METHOD POPULATION
 // ============================================================
@@ -730,7 +734,7 @@ export function populateBuiltinMethods(builtinMethods) {
     for (const reg of BUILT_IN_TYPES) {
         if (METHOD_BEARING_TYPES.has(reg.name) && reg.name in builtinMethods) {
             if (Object.isFrozen(reg)) {
-                throw new Error(`populateBuiltinMethods: registration '${reg.name}' is frozen; cannot assign methods`);
+                throw new RuntimeError('RILL-R068', `populateBuiltinMethods: registration '${reg.name}' is frozen; cannot assign methods`);
             }
             reg.methods =
                 builtinMethods[reg.name];
@@ -744,6 +748,4 @@ export { createTuple, createOrdered, createVector };
 // ============================================================
 // RE-EXPORTED GUARD FUNCTIONS
 // ============================================================
-export { isTuple, isVector, isTypeValue, isOrdered, isIterator };
-/** @deprecated Use isIterator instead. */
-export const isRillIterator = isIterator;
+export { isStream, isTuple, isVector, isTypeValue, isOrdered, isIterator };

package/dist/runtime/core/{types.d.ts → types/runtime.d.ts}

@@ -4,10 +4,10 @@
  * Public types for runtime configuration and execution results.
  * These types are the primary interface for host applications.
  */
-import type { RillTypeName } from '../../types.js';
-import type { CallableFn, RillFunction } from './callable.js';
-import type { TypeStructure, RillValue } from './values.js';
-export type { NativeArray, NativePlainObject, NativeValue } from './values.js';
+import type { RillTypeName } from '../../../types.js';
+import type { CallableFn, RillFunction } from '../callable.js';
+import type { TypeStructure, RillValue } from './structures.js';
+export type { NativeArray, NativePlainObject, NativeValue } from '../values.js';
 /** I/O callbacks for runtime operations */
 export interface RuntimeCallbacks {
     /** Called when .log is invoked */
@@ -121,7 +121,7 @@ export interface RuntimeContext {
     /** Variable types - locked after first assignment (local to this scope) */
     readonly variableTypes: Map<string, RillTypeName | TypeStructure>;
     /** Built-in and user-defined functions (CallableFn for untyped, ApplicationCallable for typed) */
-    readonly functions: Map<string, CallableFn | import('./callable.js').ApplicationCallable>;
+    readonly functions: Map<string, CallableFn | import('../callable.js').ApplicationCallable>;
     /** I/O callbacks */
     readonly callbacks: RuntimeCallbacks;
     /** Observability callbacks */
@@ -152,7 +152,7 @@ export interface RuntimeContext {
      * Call stack for error context.
      * Managed by evaluator; pushed on function entry, popped on exit.
      */
-    readonly callStack: import('../../types.js').CallFrame[];
+    readonly callStack: import('../../../types.js').CallFrame[];
     /** Arbitrary string metadata passed from the host (e.g. request IDs, user IDs) */
     readonly metadata?: Record<string, string> | undefined;
     /**
@@ -184,7 +184,7 @@ export interface RuntimeContext {
      * Must be provided when `kind: 'source'` resolver results are expected.
      * Omit if only `kind: 'value'` resolvers are used.
      */
-    readonly parseSource?: ((text: string) => import('../../types.js').ScriptNode) | undefined;
+    readonly parseSource?: ((text: string) => import('../../../types.js').ScriptNode) | undefined;
     /** Identifies the current source file for cross-module error reporting */
     readonly sourceId?: string | undefined;
     /** Source text of the current file for cross-module error snippets */
@@ -224,7 +224,7 @@ export interface RuntimeOptions {
      * Parser function for executing resolver source results.
      * Required when resolvers may return `kind: 'source'` results.
      */
-    parseSource?: (text: string) => import('../../types.js').ScriptNode;
+    parseSource?: (text: string) => import('../../../types.js').ScriptNode;
 }
 /** Result of script execution */
 export interface ExecutionResult {

package/dist/runtime/core/{type-structures.d.ts → types/structures.d.ts}

@@ -9,7 +9,7 @@
  * `.kind` as its discriminator instead of `.type`, enabling future
  * coexistence during migration.
  */
-import type { RillTypeName } from '../../types.js';
+import type { RillTypeName } from '../../../types.js';
 import type { CallableMarker, FieldDescriptorMarker } from './markers.js';
 /**
  * Field definition - describes a single field in a structural type.
@@ -27,7 +27,7 @@ export interface RillFieldDef {
  * Structural type descriptor - describes the shape of a value in the type system.
  * Discriminated by `.kind` (not `.type`).
  *
- * Includes all 12 built-in variants plus a catch-all for types without
+ * Includes all 13 built-in variants plus a catch-all for types without
  * parameterized structure (e.g. iterator).
  */
 export type TypeStructure = {
@@ -66,6 +66,10 @@ export type TypeStructure = {
     members: TypeStructure[];
 } | {
     kind: 'iterator';
+} | {
+    kind: 'stream';
+    chunk?: TypeStructure;
+    ret?: TypeStructure;
 } | {
     kind: string;
     data?: unknown;
@@ -122,7 +126,21 @@ export interface RillIterator extends Record<string, RillValue> {
     readonly next: CallableMarker;
     readonly value?: RillValue;
 }
+/**
+ * Stream type - represents an async lazy sequence with resolution.
+ * A stream is a dict with:
+ * - __rill_stream: true - discriminator for stream detection
+ * - done: boolean - whether all chunks have been consumed
+ * - next: callable - function to advance to the next stream step
+ * - value?: any - current chunk value (present when done is false)
+ */
+export interface RillStream extends Record<string, RillValue> {
+    readonly __rill_stream: true;
+    readonly done: boolean;
+    readonly next: CallableMarker;
+    readonly value?: RillValue;
+}
 /** Any value that can flow through Rill */
 export type RillValue = string | number | boolean | null | RillValue[] | {
     [key: string]: RillValue;
-} | CallableMarker | RillTuple | RillOrdered | RillVector | FieldDescriptorMarker | RillTypeValue;
+} | CallableMarker | RillTuple | RillOrdered | RillVector | FieldDescriptorMarker | RillTypeValue | RillStream;

package/dist/runtime/core/values.d.ts

@@ -4,92 +4,26 @@
  * Core value types that flow through Rill programs.
  * Public API for host applications.
  *
+ * Structural operations (structureEquals, structureMatches, formatStructure,
+ * inferStructure, commonType) live in types/operations.ts and are re-exported.
+ *
  * Dispatch functions (inferType, formatValue, deepEquals, serializeValue,
  * copyValue) re-export from type-registrations.ts protocol implementations.
  */
 import type { RillTypeName } from '../../types.js';
-import type { RillFieldDef, RillIterator, RillOrdered, RillTuple, RillTypeValue, RillValue, RillVector, TypeStructure } from './type-structures.js';
+import type { RillCallable } from './callable.js';
+import { isDict, isIterator, isOrdered, isStream, isTuple, isTypeValue, isVector } from './types/guards.js';
+/** isCallable guard widened to narrow to full RillCallable (not just CallableMarker) */
+declare const isCallable: (value: RillValue) => value is RillCallable;
+import type { RillFieldDef, RillIterator, RillOrdered, RillTuple, RillTypeValue, RillValue, RillVector, TypeStructure } from './types/structures.js';
 export type { RillFieldDef, RillIterator, RillOrdered, RillTuple, RillTypeValue, RillValue, RillVector, TypeStructure, };
-export type DictStructure = {
-    kind: 'dict';
-    fields?: Record<string, RillFieldDef>;
-    valueType?: TypeStructure;
-};
-export type TupleStructure = {
-    kind: 'tuple';
-    elements?: RillFieldDef[];
-    valueType?: TypeStructure;
-};
-export type OrderedStructure = {
-    kind: 'ordered';
-    fields?: RillFieldDef[];
-    valueType?: TypeStructure;
-};
-/** @deprecated Use TypeStructure instead. */
-export type RillType = TypeStructure;
-/** Type guard for RillTuple (spread args) */
-export declare function isTuple(value: RillValue): value is RillTuple;
-/** Type guard for RillVector */
-export declare function isVector(value: RillValue): value is RillVector;
-/** Type guard for RillOrdered (named spread args) */
-export declare function isOrdered(value: RillValue): value is RillOrdered;
-/** Type guard for RillTypeValue */
-export declare function isTypeValue(value: RillValue): value is RillTypeValue;
-/**
- * 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 declare function createOrdered(entries: [string, RillValue, RillValue?][]): RillOrdered;
-/** Create tuple from entries array (positional, preserves order) */
-export declare function createTuple(entries: RillValue[]): RillTuple;
-/**
- * Create vector from Float32Array with model name.
- * @throws {Error} if data.length is 0 (zero-dimension vectors not allowed)
- */
-export declare function createVector(data: Float32Array, model: string): RillVector;
+export type { DictStructure, TupleStructure, OrderedStructure, } from './types/operations.js';
+export { isCallable, isDict, isIterator, isOrdered, isStream, isTuple, isTypeValue, isVector, };
+export { copyValue, createOrdered, createTuple, createVector, emptyForType, } from './types/constructors.js';
+export { commonType, compareStructuredFields, formatStructure, inferElementType, inferStructure, paramToFieldDef, structureEquals, structureMatches, } from './types/operations.js';
+export type { FieldComparisonCallbacks } from './types/operations.js';
 /** Infer the Rill type from a runtime value. Delegates to type-registrations. */
 export declare const inferType: (value: RillValue) => string;
-/**
- * Infer the element type for a homogeneous list.
- * Empty arrays return { kind: 'any' }.
- * Mixed types throw RILL-R002.
- */
-export declare function inferElementType(elements: RillValue[]): TypeStructure;
-/**
- * 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 declare function commonType(a: TypeStructure, b: TypeStructure): TypeStructure | null;
-/** Compare two structural types for equality. */
-export declare function structureEquals(a: TypeStructure, b: TypeStructure): boolean;
-/** @deprecated Use structureEquals instead. */
-export declare const structuralTypeEquals: typeof structureEquals;
-/** Infer the structural type descriptor for any Rill value. */
-export declare function inferStructure(value: RillValue): TypeStructure;
-/** @deprecated Use inferStructure instead. */
-export declare const inferStructuralType: typeof inferStructure;
-/**
- * Check if a value matches a structural type descriptor.
- * Used for runtime type checking (`:?` operator).
- */
-export declare function structureMatches(value: RillValue, type: TypeStructure): boolean;
-/** @deprecated Use structureMatches instead. */
-export declare const structuralTypeMatches: typeof structureMatches;
-/** Build a closure param field definition from name, type, and optional default. */
-export declare function paramToFieldDef(name: string, type: TypeStructure, defaultValue: RillValue | undefined): RillFieldDef;
-/** Format a structural type descriptor as a human-readable string. */
-export declare function formatStructure(type: TypeStructure): string;
-/** @deprecated Use formatStructure instead. */
-export declare const formatStructuralType: typeof formatStructure;
 /**
  * Check if a value is of the expected type.
  * Returns true if the value matches the expected type, false otherwise.
@@ -123,8 +57,6 @@ export interface NativeResult {
 }
 /** Serialize a Rill value for JSON transport. Delegates to type-registrations. */
 export declare const serializeValue: (value: RillValue) => unknown;
-/** @deprecated Use serializeValue instead. */
-export declare const valueToJSON: (value: RillValue) => unknown;
 /**
  * Convert a RillValue to a NativeResult for host consumption.
  * Non-representable types (closures, vectors, type values, iterators) produce descriptor objects.
@@ -146,32 +78,11 @@ export declare const anyTypeValue: RillTypeValue;
  * Falls back to 'any' for compound types that lack a direct RillTypeName mapping.
  */
 export declare function structureToTypeValue(type: TypeStructure): RillTypeValue;
-/** @deprecated Use structureToTypeValue instead. */
-export declare const rillTypeToTypeValue: typeof 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 declare function hasCollectionFields(type: TypeStructure): boolean;
-/**
- * Create an empty collection value matching the given TypeStructure.
- * Assumes the type is dict, ordered, or tuple.
- */
-export declare function emptyForType(type: TypeStructure): RillValue;
 /** Check if a key name is reserved */
 export declare function isReservedMethod(name: string): boolean;
-/**
- * Type guard for Rill iterator (lazy sequence).
- * An iterator is a dict with:
- * - done: boolean - whether iteration is complete
- * - next: callable - function to get next iterator
- * - value: any (only required when not done) - current element
- */
-export declare function isIterator(value: RillValue): value is RillIterator;
-/** @deprecated Use isIterator instead. */
-export declare const isRillIterator: typeof isIterator;
-/** Copy a RillValue. Delegates to type-registrations. */
-export declare const copyValue: (value: RillValue) => RillValue;
-/** @deprecated Use copyValue instead. */
-export declare const deepCopyRillValue: (value: RillValue) => RillValue;