@rcrsr/rill 0.16.0 → 0.17.0

package/dist/runtime/core/eval/mixins/types.js

@@ -23,21 +23,8 @@
  * @internal
  */
 import { RuntimeError } from '../../../../types.js';
-import { inferType, checkType, isTypeValue, structuralTypeMatches, inferStructuralType, formatStructuralType, } from '../../values.js';
+import { inferType, checkType, isTypeValue, structureMatches, inferStructure, formatStructure, } from '../../values.js';
 import { getVariable } from '../../context.js';
-/**
- * Leaf types that reject all type arguments.
- * Extracted as module-level constant to avoid per-call allocation.
- */
-const LEAF_TYPES = new Set([
-    'string',
-    'number',
-    'bool',
-    'vector',
-    'type',
-    'any',
-    'closure',
-]);
 /**
  * TypesMixin implementation.
  *
@@ -87,7 +74,7 @@ function createTypesMixin(Base) {
                     throw new RuntimeError('RILL-R004', 'list() requires exactly 1 type argument', location);
                 }
                 const element = await resolveArg(args[0]);
-                const structure = { type: 'list', element };
+                const structure = { kind: 'list', element };
                 return Object.freeze({
                     __rill_type: true,
                     typeName: name,
@@ -107,11 +94,11 @@ function createTypesMixin(Base) {
                     // EC-B6: Default type mismatch on uniform single-arg path
                     if (positional[0].defaultValue !== undefined) {
                         const defaultVal = await evaluateDefault(positional[0].defaultValue);
-                        if (!structuralTypeMatches(defaultVal, valueType)) {
-                            throw new RuntimeError('RILL-R004', `Default value for ${name} element must be ${formatStructuralType(valueType)}, got ${inferType(defaultVal)}`, location);
+                        if (!structureMatches(defaultVal, valueType)) {
+                            throw new RuntimeError('RILL-R004', `Default value for ${name} element must be ${formatStructure(valueType)}, got ${inferType(defaultVal)}`, location);
                         }
                     }
-                    const structure = { type: name, valueType };
+                    const structure = { kind: name, valueType };
                     return Object.freeze({
                         __rill_type: true,
                         typeName: name,
@@ -131,14 +118,14 @@ function createTypesMixin(Base) {
                         if (arg.defaultValue !== undefined) {
                             const defaultVal = await evaluateDefault(arg.defaultValue);
                             // EC-B6: Default type mismatch
-                            if (!structuralTypeMatches(defaultVal, resolvedType)) {
-                                throw new RuntimeError('RILL-R004', `Default value for field '${arg.name}' must be ${formatStructuralType(resolvedType)}, got ${inferType(defaultVal)}`, location);
+                            if (!structureMatches(defaultVal, resolvedType)) {
+                                throw new RuntimeError('RILL-R004', `Default value for field '${arg.name}' must be ${formatStructure(resolvedType)}, got ${inferType(defaultVal)}`, location);
                             }
                             fieldDef.defaultValue = defaultVal;
                         }
                         fields[arg.name] = fieldDef;
                     }
-                    const structure = { type: 'dict', fields };
+                    const structure = { kind: 'dict', fields };
                     return Object.freeze({
                         __rill_type: true,
                         typeName: name,
@@ -156,14 +143,17 @@ function createTypesMixin(Base) {
                     if (arg.defaultValue !== undefined) {
                         const defaultVal = await evaluateDefault(arg.defaultValue);
                         // EC-B6: Default type mismatch
-                        if (!structuralTypeMatches(defaultVal, resolvedType)) {
-                            throw new RuntimeError('RILL-R004', `Default value for field '${arg.name}' must be ${formatStructuralType(resolvedType)}, got ${inferType(defaultVal)}`, location);
+                        if (!structureMatches(defaultVal, resolvedType)) {
+                            throw new RuntimeError('RILL-R004', `Default value for field '${arg.name}' must be ${formatStructure(resolvedType)}, got ${inferType(defaultVal)}`, location);
                         }
                         fieldDef.defaultValue = defaultVal;
                     }
                     orderedFields.push(fieldDef);
                 }
-                const structure = { type: 'ordered', fields: orderedFields };
+                const structure = {
+                    kind: 'ordered',
+                    fields: orderedFields,
+                };
                 return Object.freeze({
                     __rill_type: true,
                     typeName: name,
@@ -183,11 +173,11 @@ function createTypesMixin(Base) {
                 // EC-B6: Default type mismatch on uniform single-arg path
                 if (args[0].defaultValue !== undefined) {
                     const defaultVal = await evaluateDefault(args[0].defaultValue);
-                    if (!structuralTypeMatches(defaultVal, valueType)) {
-                        throw new RuntimeError('RILL-R004', `Default value for tuple element must be ${formatStructuralType(valueType)}, got ${inferType(defaultVal)}`, location);
+                    if (!structureMatches(defaultVal, valueType)) {
+                        throw new RuntimeError('RILL-R004', `Default value for tuple element must be ${formatStructure(valueType)}, got ${inferType(defaultVal)}`, location);
                     }
                 }
-                const structure = { type: 'tuple', valueType };
+                const structure = { kind: 'tuple', valueType };
                 return Object.freeze({
                     __rill_type: true,
                     typeName: 'tuple',
@@ -202,8 +192,8 @@ function createTypesMixin(Base) {
                 if (arg.defaultValue !== undefined) {
                     const defaultVal = await evaluateDefault(arg.defaultValue);
                     // EC-B6: Default type mismatch
-                    if (!structuralTypeMatches(defaultVal, resolvedType)) {
-                        throw new RuntimeError('RILL-R004', `Default value for tuple element must be ${formatStructuralType(resolvedType)}, got ${inferType(defaultVal)}`, location);
+                    if (!structureMatches(defaultVal, resolvedType)) {
+                        throw new RuntimeError('RILL-R004', `Default value for tuple element must be ${formatStructure(resolvedType)}, got ${inferType(defaultVal)}`, location);
                     }
                     fieldDef.defaultValue = defaultVal;
                 }
@@ -221,7 +211,7 @@ function createTypesMixin(Base) {
                     throw new RuntimeError('RILL-R004', `tuple() default values must be trailing: element at position ${i} has no default but a preceding element does`, location);
                 }
             }
-            const structure = { type: 'tuple', elements };
+            const structure = { kind: 'tuple', elements };
             return Object.freeze({
                 __rill_type: true,
                 typeName: 'tuple',
@@ -254,11 +244,11 @@ function createTypesMixin(Base) {
                     return Object.freeze({
                         __rill_type: true,
                         typeName,
-                        structure: { type: typeName },
+                        structure: { kind: typeName },
                     });
                 }
-                // EC-B1: Leaf types reject all type arguments
-                if (LEAF_TYPES.has(typeName)) {
+                // EC-B1: Leaf types reject all type arguments (AC-4: derived from registrations)
+                if (this.ctx.leafTypes.has(typeName)) {
                     throw new RuntimeError('RILL-R004', `${typeName} does not accept type arguments`);
                 }
                 // Delegate to buildCollectionType with recursive resolveTypeRef
@@ -271,7 +261,7 @@ function createTypesMixin(Base) {
                 });
             }
             // Union type ref: (A | B) -- resolve each member recursively and
-            // return a RillTypeValue with structure: { type: 'union', members: [...] }.
+            // return a RillTypeValue with structure: { kind: 'union', members: [...] }.
             // typeName is set to a display string for error messages; the structure
             // field carries the authoritative type shape for validation (DR-1).
             if (typeRef.kind === 'union') {
@@ -280,9 +270,9 @@ function createTypesMixin(Base) {
                     const resolved = await this.resolveTypeRef(member, getVariableFn);
                     members.push(resolved.structure);
                 }
-                const structure = { type: 'union', members };
+                const structure = { kind: 'union', members };
                 const displayName = members
-                    .map(formatStructuralType)
+                    .map(formatStructure)
                     .join('|');
                 return Object.freeze({
                     __rill_type: true,
@@ -301,13 +291,13 @@ function createTypesMixin(Base) {
         /**
          * Assert that a value is of the expected type.
          * Returns the value unchanged if assertion passes, throws on mismatch.
-         * Accepts a bare RillTypeName or a full RillType.
-         * When expected is a RillType with sub-fields (element, fields, elements),
-         * dispatches to structuralTypeMatches for deep validation.
+         * Accepts a bare RillTypeName or a full TypeStructure.
+         * When expected is a TypeStructure with sub-fields (element, fields, elements),
+         * dispatches to structureMatches for deep validation.
          * Exported for use by type assertion evaluation.
          */
         assertType(value, expected, location) {
-            // Structural path: expected is a RillType object
+            // Structural path: expected is a TypeStructure object
             if (typeof expected !== 'string') {
                 const hasSubFields = 'element' in expected ||
                     'fields' in expected ||
@@ -315,15 +305,15 @@ function createTypesMixin(Base) {
                     'members' in expected ||
                     'valueType' in expected;
                 if (hasSubFields) {
-                    if (!structuralTypeMatches(value, expected)) {
-                        const expectedStr = formatStructuralType(expected);
-                        const actualStr = formatStructuralType(inferStructuralType(value));
+                    if (!structureMatches(value, expected)) {
+                        const expectedStr = formatStructure(expected);
+                        const actualStr = formatStructure(inferStructure(value));
                         throw new RuntimeError('RILL-R004', `Type assertion failed: expected ${expectedStr}, got ${actualStr}`, location, { expectedType: expectedStr, actualType: actualStr });
                     }
                     return value;
                 }
                 // Bare structural type (no sub-fields): fall through using type name
-                expected = expected.type;
+                expected = expected.kind;
             }
             // Bare type name path
             if (expected === 'any')
@@ -366,7 +356,7 @@ function createTypesMixin(Base) {
                 'members' in resolved.structure ||
                 'valueType' in resolved.structure;
             if (hasSubFields) {
-                return structuralTypeMatches(value, resolved.structure);
+                return structureMatches(value, resolved.structure);
             }
             return checkType(value, resolved.typeName);
         }
@@ -409,9 +399,9 @@ function createTypesMixin(Base) {
             const location = node.span.start;
             return this.buildCollectionType(name, node.args, async (arg) => {
                 const resolved = await this.resolveTypeRef(arg.value, (varName) => getVariable(this.ctx, varName));
-                return resolved.structure.type === 'any' &&
+                return resolved.structure.kind === 'any' &&
                     resolved.typeName !== 'any'
-                    ? { type: resolved.typeName }
+                    ? { kind: resolved.typeName }
                     : resolved.structure;
             }, async (node) => {
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -422,7 +412,7 @@ function createTypesMixin(Base) {
          * Evaluate a closure signature literal into a RillTypeValue [IR-8].
          *
          * Creates a closure type value from |param: T, ...|: R syntax.
-         * Each parameter produces a [name, RillType] entry.
+         * Each parameter produces a [name, TypeStructure] entry.
          *
          * Error contracts:
          * - EC-8: missing return type -> RILL-R004 (enforced at parse time; node always has returnType)
@@ -430,14 +420,14 @@ function createTypesMixin(Base) {
          */
         async evaluateClosureSigLiteral(node) {
             const location = node.span.start;
-            // Helper: evaluate a type expression and extract RillType
+            // Helper: evaluate a type expression and extract TypeStructure
             const resolveTypeExpr = async (argVal) => {
                 if (!isTypeValue(argVal)) {
                     throw new RuntimeError('RILL-R004', `Parameter type must be a type value, got ${inferType(argVal)}`, location);
                 }
-                return argVal.structure.type === 'any' &&
+                return argVal.structure.kind === 'any' &&
                     argVal.typeName !== 'any'
-                    ? { type: argVal.typeName }
+                    ? { kind: argVal.typeName }
                     : argVal.structure;
             };
             // Evaluate parameter types
@@ -456,11 +446,11 @@ function createTypesMixin(Base) {
             if (!isTypeValue(retVal)) {
                 throw new RuntimeError('RILL-R004', `Closure type literal requires return type after |, got ${inferType(retVal)}`, location);
             }
-            const ret = retVal.structure.type === 'any' &&
+            const ret = retVal.structure.kind === 'any' &&
                 retVal.typeName !== 'any'
-                ? { type: retVal.typeName }
+                ? { kind: retVal.typeName }
                 : retVal.structure;
-            const structure = { type: 'closure', params, ret };
+            const structure = { kind: 'closure', params, ret };
             return Object.freeze({
                 __rill_type: true,
                 typeName: 'closure',

package/dist/runtime/core/eval/mixins/variables.js

@@ -31,7 +31,7 @@
  * @internal
  */
 import { RuntimeError } from '../../../../types.js';
-import { formatStructuralType, inferType, isTypeValue, structuralTypeMatches, } from '../../values.js';
+import { formatStructure, inferType, isTypeValue, structureMatches, } from '../../values.js';
 import { getVariable, hasVariable } from '../../context.js';
 import { isDict, isCallable } from '../../callable.js';
 /**
@@ -69,8 +69,8 @@ function createVariablesMixin(Base) {
             if (explicitType !== undefined) {
                 if (typeof explicitType === 'object') {
                     // Structural type check
-                    if (!structuralTypeMatches(value, explicitType)) {
-                        const expectedLabel = formatStructuralType(explicitType);
+                    if (!structureMatches(value, explicitType)) {
+                        const expectedLabel = formatStructure(explicitType);
                         throw new RuntimeError('RILL-R001', `Type mismatch: cannot assign ${valueType} to $${name}:${expectedLabel}`, location, {
                             variableName: name,
                             expectedType: expectedLabel,
@@ -98,8 +98,8 @@ function createVariablesMixin(Base) {
             if (lockedType !== undefined && lockedType !== 'any') {
                 if (typeof lockedType === 'object') {
                     // Structural locked type — validate full shape
-                    if (!structuralTypeMatches(value, lockedType)) {
-                        const expectedLabel = formatStructuralType(lockedType);
+                    if (!structureMatches(value, lockedType)) {
+                        const expectedLabel = formatStructure(lockedType);
                         throw new RuntimeError('RILL-R001', `Type mismatch: cannot assign ${valueType} to $${name} (locked as ${expectedLabel})`, location, {
                             variableName: name,
                             expectedType: expectedLabel,
@@ -120,7 +120,9 @@ function createVariablesMixin(Base) {
             if (!this.ctx.variableTypes.has(name)) {
                 // Store structural type (object) directly so re-assignment checks
                 // validate the full shape. Fall back to valueType when no annotation.
-                const lockType = explicitType !== undefined ? explicitType : valueType;
+                const lockType = explicitType !== undefined
+                    ? explicitType
+                    : valueType;
                 this.ctx.variableTypes.set(name, lockType);
             }
         }
@@ -260,7 +262,7 @@ function createVariablesMixin(Base) {
                             value = value.typeName;
                         }
                         else if (field === 'signature') {
-                            value = formatStructuralType(value.structure);
+                            value = formatStructure(value.structure);
                         }
                         else {
                             throw new RuntimeError('RILL-R003', `Type value has no property "${field}"`, this.getNodeLocation(node));
@@ -322,7 +324,7 @@ function createVariablesMixin(Base) {
                         return true;
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     const resolved = await this.resolveTypeRef(typeRef, (name) => getVariable(this.ctx, name));
-                    return structuralTypeMatches(fieldValue, resolved.structure);
+                    return structureMatches(fieldValue, resolved.structure);
                 };
                 if (finalAccess.kind === 'literal') {
                     // Check if literal field exists in dict

package/dist/runtime/core/field-descriptor.d.ts

@@ -8,7 +8,7 @@
  * @internal
  */
 import type { SourceLocation } from '../../types.js';
-import type { RillFieldDef, RillType } from './values.js';
+import type { RillFieldDef, TypeStructure } from './values.js';
 /**
  * Field descriptor — carries field name and structural type when accessing a
  * dict-kind RillType field.
@@ -23,6 +23,6 @@ export interface RillFieldDescriptor {
  *
  * EC-1: Throws RILL-R003 when fieldName is absent from structuralType.fields.
  */
-export declare function buildFieldDescriptor(structuralType: RillType & {
-    type: 'dict';
+export declare function buildFieldDescriptor(structuralType: TypeStructure & {
+    kind: 'dict';
 }, fieldName: string, location: SourceLocation): RillFieldDescriptor;

package/dist/runtime/core/field-descriptor.js

@@ -14,7 +14,8 @@ import { RuntimeError } from '../../types.js';
  * EC-1: Throws RILL-R003 when fieldName is absent from structuralType.fields.
  */
 export function buildFieldDescriptor(structuralType, fieldName, location) {
-    const fieldType = structuralType.fields?.[fieldName];
+    const fields = structuralType.fields;
+    const fieldType = fields?.[fieldName];
     if (fieldType === undefined) {
         throw new RuntimeError('RILL-R003', `Shape has no field "${fieldName}"`, location);
     }

package/dist/runtime/core/introspection.js

@@ -4,7 +4,7 @@
  * Functions for inspecting runtime context at runtime.
  * These enable host applications to discover available functions and their signatures.
  */
-import { formatStructuralType, formatValue } from './values.js';
+import { formatStructure, formatValue } from './values.js';
 import { isApplicationCallable, isRuntimeCallable, isScriptCallable, } from './callable.js';
 import { LANGUAGE_REFERENCE } from '../../generated/introspection-data.js';
 import { BUILTIN_FUNCTIONS } from '../ext/builtins.js';
@@ -40,7 +40,7 @@ export function getFunctions(ctx) {
                 if (callable.params) {
                     const params = callable.params.map((p) => ({
                         name: p.name,
-                        type: p.type !== undefined ? formatStructuralType(p.type) : 'any',
+                        type: p.type !== undefined ? formatStructure(p.type) : 'any',
                         description: typeof p.annotations['description'] === 'string'
                             ? p.annotations['description']
                             : '',
@@ -50,7 +50,7 @@ export function getFunctions(ctx) {
                         name,
                         description: callable.annotations?.['description'] ?? '',
                         params,
-                        returnType: formatStructuralType(callable.returnType.structure),
+                        returnType: formatStructure(callable.returnType.structure),
                     });
                 }
                 else {
@@ -93,7 +93,7 @@ export function getFunctions(ctx) {
                 // Convert params to ParamMetadata using RillParam.type (IC-5)
                 const params = value.params.map((p) => ({
                     name: p.name,
-                    type: p.type !== undefined ? formatStructuralType(p.type) : 'any',
+                    type: p.type !== undefined ? formatStructure(p.type) : 'any',
                     description: typeof p.annotations['description'] === 'string'
                         ? p.annotations['description']
                         : '',
@@ -131,7 +131,7 @@ function serializeParam(p) {
         parts.push(`^(description: "${desc}") `);
     }
     // Name and type
-    const typeName = p.type !== undefined ? formatStructuralType(p.type) : 'any';
+    const typeName = p.type !== undefined ? formatStructure(p.type) : 'any';
     parts.push(`${p.name}: ${typeName}`);
     // Default value
     if (p.defaultValue !== undefined) {
@@ -189,7 +189,7 @@ export function generateManifest(ctx) {
         if (!isApplicationCallable(callable) || callable.params === undefined) {
             continue;
         }
-        const signature = serializeClosureSignature(callable.params, formatStructuralType(callable.returnType.structure), callable.annotations?.['description'] ?? undefined);
+        const signature = serializeClosureSignature(callable.params, formatStructure(callable.returnType.structure), callable.annotations?.['description'] ?? undefined);
         entries.push(`  "${name}": ${signature}`);
     }
     if (entries.length === 0) {

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

@@ -0,0 +1,12 @@
+/**
+ * Shared marker interfaces for forward declarations.
+ *
+ * These interfaces break circular dependencies between values.ts,
+ * type-structures.ts, and callable.ts. Actual types are defined in callable.ts.
+ */
+export interface CallableMarker {
+    readonly __type: 'callable';
+}
+export interface FieldDescriptorMarker {
+    readonly __rill_field_descriptor: true;
+}

package/dist/runtime/core/markers.js

@@ -0,0 +1,7 @@
+/**
+ * Shared marker interfaces for forward declarations.
+ *
+ * These interfaces break circular dependencies between values.ts,
+ * type-structures.ts, and callable.ts. Actual types are defined in callable.ts.
+ */
+export {};

package/dist/runtime/core/type-registrations.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Type Registration Definitions
+ *
+ * Defines the TypeDefinition interface, TypeProtocol interface, and
+ * BUILT_IN_TYPES registration array. Each of the 12 built-in types
+ * carries identity predicates, protocol functions (format, eq, compare,
+ * 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.
+ *
+ * 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';
+/**
+ * Protocol functions that define per-type behavior.
+ * Every type must provide `format`. All other protocols are optional.
+ */
+export interface TypeProtocol {
+    format: (v: RillValue) => string;
+    structure?: ((v: RillValue) => TypeStructure) | undefined;
+    eq?: ((a: RillValue, b: RillValue) => boolean) | undefined;
+    compare?: ((a: RillValue, b: RillValue) => number) | undefined;
+    convertTo?: Record<string, (v: RillValue) => RillValue> | undefined;
+    serialize?: ((v: RillValue) => unknown) | undefined;
+    deserialize?: ((data: unknown) => RillValue) | undefined;
+}
+/**
+ * A single type registration record. Each of the 12 built-in types
+ * has exactly one TypeDefinition in the BUILT_IN_TYPES array.
+ */
+export interface TypeDefinition {
+    name: string;
+    identity: (v: RillValue) => boolean;
+    isLeaf: boolean;
+    immutable: boolean;
+    methods: Record<string, RillFunction>;
+    protocol: TypeProtocol;
+}
+/**
+ * All 12 built-in type registrations.
+ *
+ * Registration order:
+ * 1. Primitives: string, number, bool
+ * 2. Discriminator-based: tuple, ordered, vector, type, closure, field_descriptor
+ * 3. Structural: iterator
+ * 4. list
+ * 5. dict (fallback, must be last)
+ *
+ * AC-1: 12 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.
+ */
+export declare const BUILT_IN_TYPES: readonly TypeDefinition[];
+/**
+ * Infer the Rill type name from a runtime value.
+ * Iterates registrations in order; returns first matching name.
+ * Returns 'string' as fallback (BC-1: null IS type string, not a coercion).
+ *
+ * IR-2: Return type widens from RillTypeName to string for extensibility.
+ */
+export declare function inferType(value: RillValue): string;
+/**
+ * Format a value as a human-readable string.
+ * Determines type via inferType, then calls protocol.format.
+ * Falls back to String(value) when no registration matches.
+ *
+ * IR-3: Protocol dispatcher for formatting.
+ */
+export declare function formatValue(value: RillValue): string;
+/**
+ * Deep equality comparison for two Rill values.
+ * Short-circuit: a === b returns true.
+ * Dispatches to left operand's protocol.eq.
+ * No protocol.eq returns false.
+ *
+ * IR-4: Container protocol.eq calls deepEquals recursively.
+ */
+export declare function deepEquals(a: RillValue, b: RillValue): boolean;
+/**
+ * Serialize a Rill value for JSON transport.
+ * Dispatches to protocol.serialize; container types recurse.
+ *
+ * IR-7: Renamed from valueToJSON.
+ */
+export declare function serializeValue(value: RillValue): unknown;
+/**
+ * Deserialize raw data into a Rill value.
+ * Dispatches to protocol.deserialize for the given type name.
+ * Falls back to raw value when no protocol.deserialize exists (primitives).
+ *
+ * IR-8: Raw value fallback rejects null/undefined inputs with RILL-R004.
+ * EC-9: Invalid data raises RILL-R004.
+ * 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.
+ *
+ * Called after builtins.ts finishes initialization to avoid circular
+ * dependency at module load time. The 6 method-bearing types (string,
+ * number, bool, list, dict, vector) receive their methods records;
+ * other types keep `methods: {}`.
+ *
+ * AC-3: Consolidates method data into registrations.
+ *
+ * MUTATION NOTE: BUILT_IN_TYPES is shallow-frozen (the array), but each
+ * registration object is mutable. This function relies on that mutability.
+ * If registration objects are ever deep-frozen (e.g. Object.freeze(reg)),
+ * this assignment will throw in strict mode. The runtime guard below catches
+ * that condition early with a clear error rather than a silent no-op.
+ */
+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 type { TypeStructure };
+export type { RillValue, RillTuple, RillOrdered, RillVector, RillTypeValue, RillIterator, RillFieldDef, };