@rcrsr/rill 0.16.0 → 0.17.0

package/dist/generated/version-data.d.ts

@@ -10,7 +10,7 @@ export interface VersionInfo {
 /**
  * Version string from package.json
  */
-export declare const VERSION = "0.16.0";
+export declare const VERSION = "0.17.0";
 /**
  * Parsed version components
  */

package/dist/generated/version-data.js

@@ -3,13 +3,13 @@
 /**
  * Version string from package.json
  */
-export const VERSION = '0.16.0';
+export const VERSION = '0.17.0';
 /**
  * Parsed version components
  */
 export const VERSION_INFO = {
     major: 0,
-    minor: 16,
+    minor: 17,
     patch: 0,
     prerelease: undefined,
 };

package/dist/index.d.ts

@@ -5,11 +5,22 @@
 export { LexerError, tokenize, type TokenizeOptions } from './lexer/index.js';
 export { parse, parseWithRecovery } from './parser/index.js';
 export type { ParseResult, RecoveryErrorNode, ErrorNode } from './types.js';
-export { anyTypeValue, type ApplicationCallable, BreakSignal, callable, type CallableFn, type CallFrame, commonType, type CaptureEvent, type ConfigFieldDescriptor, createRuntimeContext, createStepper, createTuple, createVector, type DocumentationCoverageResult, emitExtensionEvent, contextResolver, extResolver, type ErrorEvent, execute, type ExecutionResult, type ExecutionStepper, type ExtensionConfigSchema, type ExtensionEvent, type ExtensionFactory, type ExtensionManifest, type ExtensionResult, type FsExtensionContract, type FunctionMetadata, hoistExtension, type HoistedExtension, type HostCallEvent, type FunctionReturnEvent, getCallStack, generateManifest, getDocumentationCoverage, getFunctions, getLanguageReference, buildFieldDescriptor, buildTypeMethodDicts, formatStructuralType, inferElementType, inferStructuralType, inferType, invokeCallable, isApplicationCallable, moduleResolver, isTuple, isCallable, isDict, isReservedMethod, isRillIterator, isRuntimeCallable, isScriptCallable, isTypeValue, isVector, type KvExtensionContract, type NativeArray, type NativePlainObject, type NativeResult, type NativeValue, type LlmExtensionContract, type SchemaEntry, type ObservabilityCallbacks, type ParamMetadata, paramToFieldDef, popCallFrame, prefixFunctions, pushCallFrame, RESERVED_DICT_METHODS, rillTypeToTypeValue, ReturnSignal, type RillCallable, type RillFieldDef, type RillFunction, type RillParam, type RillIterator, type RillTuple, type RillType, type RillTypeValue, type RillValue, type RillVector, type RuntimeCallable, type ResolverResult, type RuntimeCallbacks, type RuntimeContext, type RuntimeOptions, type SchemeResolver, type ScriptCallable, type StepEndEvent, type StepResult, type StepStartEvent, type VectorExtensionContract, structuralTypeEquals, structuralTypeMatches, toNative, VERSION, VERSION_INFO, type VersionInfo, } from './runtime/index.js';
-/** @deprecated Use RillType instead. Will be removed in the next major version. */
-export type { RillStructuralType } from './runtime/index.js';
+export { anyTypeValue, type ApplicationCallable, BreakSignal, buildFieldDescriptor, callable, type CallableFn, type CallFrame, commonType, type CaptureEvent, type ConfigFieldDescriptor, contextResolver, createRuntimeContext, createStepper, createTestContext, createTuple, createVector, type DocumentationCoverageResult, emitExtensionEvent, type ErrorEvent, execute, type ExecutionResult, type ExecutionStepper, ExtensionBindingError, type ExtensionConfigSchema, type ExtensionEvent, type ExtensionFactory, type ExtensionFactoryResult, type ExtensionManifest, extResolver, formatStructure, type FsExtensionContract, type FunctionMetadata, type FunctionReturnEvent, generateManifest, getCallStack, getDocumentationCoverage, getFunctions, getLanguageReference, type HostCallEvent, inferElementType, inferStructure, inferType, invokeCallable, isApplicationCallable, isCallable, isDict, isIterator, isReservedMethod, isRuntimeCallable, isScriptCallable, isTuple, isTypeValue, isVector, type KvExtensionContract, moduleResolver, type NativeArray, type NativePlainObject, type NativeResult, type NativeValue, type ObservabilityCallbacks, type ParamMetadata, paramToFieldDef, popCallFrame, pushCallFrame, RESERVED_DICT_METHODS, type ResolverResult, ReturnSignal, type RillCallable, type RillFieldDef, type RillFunction, type RillIterator, type RillParam, type RillTuple, type RillTypeValue, type RillValue, type RillVector, type RuntimeCallable, type RuntimeCallbacks, type RuntimeContext, type RuntimeOptions, type SchemaEntry, type SchemeResolver, type ScriptCallable, type StepEndEvent, type StepResult, type StepStartEvent, structureEquals, structureMatches, structureToTypeValue, toCallable, toNative, type TypeDefinition, type TypeProtocol, type TypeStructure, VERSION, VERSION_INFO, type VersionInfo, } from './runtime/index.js';
+/** @deprecated Use TypeStructure instead. Will be removed in the next major version. */
+export type { RillType } from './runtime/index.js';
+/** @deprecated Use formatStructure instead. */
+export { formatStructuralType } from './runtime/index.js';
+/** @deprecated Use inferStructure instead. */
+export { inferStructuralType } from './runtime/index.js';
+/** @deprecated Use isIterator instead. */
+export { isRillIterator } from './runtime/index.js';
+/** @deprecated Use structureToTypeValue instead. */
+export { rillTypeToTypeValue } from './runtime/index.js';
+/** @deprecated Use structureEquals instead. */
+export { structuralTypeEquals } from './runtime/index.js';
+/** @deprecated Use structureMatches instead. */
+export { structuralTypeMatches } from './runtime/index.js';
 export { type ErrorCategory, type ErrorDefinition, type ErrorSeverity, ERROR_REGISTRY, renderMessage, getHelpUrl, createError, } from './types.js';
 export { formatRillError, formatRillErrorJson, type FormatErrorOptions, type FormatErrorJsonOptions, type SourceMap, } from './error-formatter.js';
-export { VALID_TYPE_NAMES } from './constants.js';
 export { type HighlightCategory, TOKEN_HIGHLIGHT_MAP, } from './highlight-map.js';
 export * from './types.js';

package/dist/index.js

@@ -4,7 +4,20 @@
  */
 export { LexerError, tokenize } from './lexer/index.js';
 export { parse, parseWithRecovery } from './parser/index.js';
-export { anyTypeValue, BreakSignal, callable, commonType, createRuntimeContext, createStepper, createTuple, createVector, emitExtensionEvent, contextResolver, extResolver, execute, hoistExtension, getCallStack, generateManifest, getDocumentationCoverage, getFunctions, getLanguageReference, buildFieldDescriptor, buildTypeMethodDicts, formatStructuralType, inferElementType, inferStructuralType, inferType, invokeCallable, isApplicationCallable, moduleResolver, isTuple, isCallable, isDict, isReservedMethod, isRillIterator, isRuntimeCallable, isScriptCallable, isTypeValue, isVector, paramToFieldDef, popCallFrame, prefixFunctions, pushCallFrame, RESERVED_DICT_METHODS, rillTypeToTypeValue, ReturnSignal, structuralTypeEquals, structuralTypeMatches, toNative, VERSION, VERSION_INFO, } from './runtime/index.js';
+export { anyTypeValue, BreakSignal, buildFieldDescriptor, callable, commonType, contextResolver, createRuntimeContext, createStepper, createTestContext, createTuple, createVector, emitExtensionEvent, execute, ExtensionBindingError, extResolver, formatStructure, generateManifest, getCallStack, getDocumentationCoverage, getFunctions, getLanguageReference, inferElementType, inferStructure, inferType, invokeCallable, isApplicationCallable, isCallable, isDict, isIterator, isReservedMethod, isRuntimeCallable, isScriptCallable, isTuple, isTypeValue, isVector, moduleResolver, paramToFieldDef, popCallFrame, pushCallFrame, RESERVED_DICT_METHODS, ReturnSignal, structureEquals, structureMatches, structureToTypeValue, toCallable, toNative, VERSION, VERSION_INFO, } from './runtime/index.js';
+// Deprecated aliases — old names kept for one release
+/** @deprecated Use formatStructure instead. */
+export { formatStructuralType } from './runtime/index.js';
+/** @deprecated Use inferStructure instead. */
+export { inferStructuralType } from './runtime/index.js';
+/** @deprecated Use isIterator instead. */
+export { isRillIterator } from './runtime/index.js';
+/** @deprecated Use structureToTypeValue instead. */
+export { rillTypeToTypeValue } from './runtime/index.js';
+/** @deprecated Use structureEquals instead. */
+export { structuralTypeEquals } from './runtime/index.js';
+/** @deprecated Use structureMatches instead. */
+export { structuralTypeMatches } from './runtime/index.js';
 // ============================================================
 // ERROR TAXONOMY
 // ============================================================
@@ -14,10 +27,6 @@ export { ERROR_REGISTRY, renderMessage, getHelpUrl, createError, } from './types
 // ============================================================
 export { formatRillError, formatRillErrorJson, } from './error-formatter.js';
 // ============================================================
-// CONSTANTS
-// ============================================================
-export { VALID_TYPE_NAMES } from './constants.js';
-// ============================================================
 // SYNTAX HIGHLIGHTING
 // ============================================================
 export { TOKEN_HIGHLIGHT_MAP, } from './highlight-map.js';

package/dist/parser/parser-types.js

@@ -98,6 +98,18 @@ export function parseTypeRef(state, opts) {
  * @internal
  */
 function parseSingleType(state, opts) {
+    // Zero-param closure type: || :returnType or bare ||
+    if (check(state, TOKEN_TYPES.OR)) {
+        advance(state); // consume || (OR token)
+        // Check for :returnType
+        if (check(state, TOKEN_TYPES.COLON)) {
+            advance(state); // consume :
+            const ret = parseSingleType(state, opts);
+            return { kind: 'static', typeName: 'closure', args: [{ value: ret }] };
+        }
+        // Bare || without :returnType — equivalent to 'closure'
+        return { kind: 'static', typeName: 'closure' };
+    }
     if (check(state, TOKEN_TYPES.DOLLAR)) {
         advance(state); // consume $
         const nameToken = expect(state, TOKEN_TYPES.IDENTIFIER, 'Expected variable name after $');

package/dist/parser/parser-use.js

@@ -56,7 +56,13 @@ Parser.prototype.parseUseExpr = function () {
     let typeRef = null;
     let closureAnnotation = null;
     if (check(this.state, TOKEN_TYPES.COLON)) {
-        if (peek(this.state, 1).type === TOKEN_TYPES.PIPE_BAR) {
+        if (peek(this.state, 1).type === TOKEN_TYPES.OR) {
+            // Zero-param closure annotation: :||
+            advance(this.state); // consume :
+            advance(this.state); // consume || (OR token)
+            closureAnnotation = [];
+        }
+        else if (peek(this.state, 1).type === TOKEN_TYPES.PIPE_BAR) {
             // Closure annotation: :|param: type, ...|
             advance(this.state); // consume :
             advance(this.state); // consume opening |

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

@@ -20,7 +20,7 @@
  * - Kept for API consistency with marshalArgs signature
  */
 import type { BodyNode, SourceLocation } from '../../types.js';
-import type { RillType, RillTypeValue, RillValue } from './values.js';
+import type { TypeStructure, RillTypeValue, RillValue } from './values.js';
 interface RuntimeContextLike {
     readonly parent?: RuntimeContextLike | undefined;
     readonly variables: Map<string, RillValue>;
@@ -42,7 +42,7 @@ export type CallableFn = (args: Record<string, RillValue>, ctx: RuntimeContextLi
  */
 export interface RillParam {
     readonly name: string;
-    readonly type: RillType | undefined;
+    readonly type: TypeStructure | undefined;
     readonly defaultValue: RillValue | undefined;
     readonly annotations: Record<string, RillValue>;
 }
@@ -57,6 +57,8 @@ export interface RillFunction {
     readonly fn: CallableFn;
     readonly annotations?: Record<string, RillValue>;
     readonly returnType: RillTypeValue;
+    /** When true, RILL-R003 generic receiver validation is skipped for this method. */
+    readonly skipReceiverValidation?: boolean;
 }
 /** Common fields for all callable types */
 interface CallableBase {
@@ -112,6 +114,16 @@ export declare function isApplicationCallable(value: RillValue): value is Applic
  * @param isProperty If true, auto-invokes when accessed from dict (property-style)
  */
 export declare function callable(fn: CallableFn, isProperty?: boolean): ApplicationCallable;
+/**
+ * Convert a RillFunction to an ApplicationCallable.
+ *
+ * Validates the input and produces a callable value accepted by the loader.
+ * Pure function with no side effects.
+ *
+ * @param def - Host function definition to convert
+ * @returns ApplicationCallable with __type, kind, isProperty, and preserved annotations
+ */
+export declare function toCallable(def: RillFunction, isProperty?: boolean): ApplicationCallable;
 /** Type guard for dict (plain object, not array, not callable, not tuple) */
 export declare function isDict(value: RillValue): value is Record<string, RillValue>;
 /** Format a callable for display */
@@ -129,19 +141,19 @@ export declare function formatCallable(callable: RillCallable): string;
  */
 export declare function callableEquals(a: ScriptCallable, b: ScriptCallable, valueEquals?: (a: RillValue, b: RillValue) => boolean): boolean;
 /**
- * Build a RillType closure variant from a closure's parameter list.
+ * Build a TypeStructure closure variant from a closure's parameter list.
  *
  * Called at closure creation time to build the structural type for `$fn.^input`.
  * - Typed params use param.type directly when present
- * - Untyped params (type: undefined) map to { type: 'any' }
- * - Return type is always { type: 'any' }
+ * - Untyped params (type: undefined) map to { kind: 'any' }
+ * - Return type is always { kind: 'any' }
  *
  * No validation: parser already validates type names.
  *
  * @param params - Closure parameter definitions (RillParam[])
- * @returns Frozen RillType with closure variant
+ * @returns Frozen TypeStructure with closure variant
  */
-export declare function paramsToStructuralType(params: readonly RillParam[]): RillType;
+export declare function paramsToStructuralType(params: readonly RillParam[]): TypeStructure;
 /**
  * Validate defaultValue type matches declared parameter type.
  *
@@ -171,7 +183,7 @@ export interface MarshalOptions {
  *
  * Pure function: no class context, no evaluator, no side effects.
  */
-export declare function hydrateFieldDefaults(value: RillValue, type: RillType): RillValue;
+export declare function hydrateFieldDefaults(value: RillValue, type: TypeStructure): RillValue;
 /**
  * Unified marshaling entry point for all 3 invocation paths.
  *

package/dist/runtime/core/callable.js

@@ -21,7 +21,7 @@
  */
 import { RuntimeError } from '../../types.js';
 import { astEquals } from './equals.js';
-import { formatValue, formatStructuralType, inferType, isOrdered, createOrdered, deepCopyRillValue, isTuple, paramToFieldDef, structuralTypeEquals, structuralTypeMatches, anyTypeValue, hasCollectionFields, emptyForType, } from './values.js';
+import { formatValue, formatStructure, inferType, isOrdered, createOrdered, copyValue, isTuple, paramToFieldDef, structureEquals, structureMatches, anyTypeValue, hasCollectionFields, emptyForType, } from './values.js';
 /** Type guard for any callable */
 export function isCallable(value) {
     return (typeof value === 'object' &&
@@ -61,6 +61,35 @@ export function callable(fn, isProperty = false) {
         isProperty,
     };
 }
+/**
+ * Convert a RillFunction to an ApplicationCallable.
+ *
+ * Validates the input and produces a callable value accepted by the loader.
+ * Pure function with no side effects.
+ *
+ * @param def - Host function definition to convert
+ * @returns ApplicationCallable with __type, kind, isProperty, and preserved annotations
+ */
+export function toCallable(def, isProperty = false) {
+    if (def == null) {
+        throw new TypeError('RillFunction cannot be null or undefined');
+    }
+    if (typeof def.fn !== 'function') {
+        throw new TypeError('RillFunction.fn must be a function');
+    }
+    if (!Array.isArray(def.params)) {
+        throw new TypeError('RillFunction.params must be an array');
+    }
+    return {
+        __type: 'callable',
+        kind: 'application',
+        isProperty,
+        fn: def.fn,
+        params: def.params,
+        returnType: def.returnType,
+        annotations: def.annotations ?? {},
+    };
+}
 /** Type guard for dict (plain object, not array, not callable, not tuple) */
 export function isDict(value) {
     return (typeof value === 'object' &&
@@ -116,14 +145,14 @@ export function callableEquals(a, b, valueEquals = (x, y) => formatValue(x) ===
             return false;
         if (ap.name !== bp.name)
             return false;
-        // Compare type via structuralTypeEquals; absent type (any-typed) matches absent type
+        // Compare type via structureEquals; absent type (any-typed) matches absent type
         if (ap.type === undefined && bp.type !== undefined)
             return false;
         if (ap.type !== undefined && bp.type === undefined)
             return false;
         if (ap.type !== undefined &&
             bp.type !== undefined &&
-            !structuralTypeEquals(ap.type, bp.type))
+            !structureEquals(ap.type, bp.type))
             return false;
         if (!valueEquals(ap.defaultValue ?? null, bp.defaultValue ?? null)) {
             return false;
@@ -146,24 +175,24 @@ export function callableEquals(a, b, valueEquals = (x, y) => formatValue(x) ===
     return true;
 }
 /**
- * Build a RillType closure variant from a closure's parameter list.
+ * Build a TypeStructure closure variant from a closure's parameter list.
  *
  * Called at closure creation time to build the structural type for `$fn.^input`.
  * - Typed params use param.type directly when present
- * - Untyped params (type: undefined) map to { type: 'any' }
- * - Return type is always { type: 'any' }
+ * - Untyped params (type: undefined) map to { kind: 'any' }
+ * - Return type is always { kind: 'any' }
  *
  * No validation: parser already validates type names.
  *
  * @param params - Closure parameter definitions (RillParam[])
- * @returns Frozen RillType with closure variant
+ * @returns Frozen TypeStructure with closure variant
  */
 export function paramsToStructuralType(params) {
-    const closureParams = params.map((param) => paramToFieldDef(param.name, param.type ?? { type: 'any' }, param.defaultValue));
+    const closureParams = params.map((param) => paramToFieldDef(param.name, param.type ?? { kind: 'any' }, param.defaultValue));
     return Object.freeze({
-        type: 'closure',
+        kind: 'closure',
         params: closureParams,
-        ret: { type: 'any' },
+        ret: { kind: 'any' },
     });
 }
 /**
@@ -182,9 +211,9 @@ export function validateDefaultValueType(param, _functionName) {
     // Skip validation when type is undefined (any-typed, all defaults valid)
     if (param.type === undefined)
         return;
-    if (!structuralTypeMatches(param.defaultValue, param.type)) {
+    if (!structureMatches(param.defaultValue, param.type)) {
         const actualType = inferType(param.defaultValue);
-        const expectedType = formatStructuralType(param.type);
+        const expectedType = formatStructure(param.type);
         throw new Error(`Invalid defaultValue for parameter '${param.name}': expected ${expectedType}, got ${actualType}`);
     }
 }
@@ -198,16 +227,17 @@ export function validateDefaultValueType(param, _functionName) {
  * Pure function: no class context, no evaluator, no side effects.
  */
 export function hydrateFieldDefaults(value, type) {
-    if (type.type === 'dict' && type.fields && isDict(value)) {
+    if (type.kind === 'dict' && type.fields && isDict(value)) {
+        const t = type;
         const dictValue = value;
         // Seed with all input entries so extra keys survive (structural match allows extras)
         const result = { ...dictValue };
-        for (const [fieldName, fieldDef] of Object.entries(type.fields)) {
+        for (const [fieldName, fieldDef] of Object.entries(t.fields)) {
             if (fieldName in dictValue) {
                 result[fieldName] = hydrateFieldDefaults(dictValue[fieldName], fieldDef.type);
             }
             else if (fieldDef.defaultValue !== undefined) {
-                result[fieldName] = hydrateFieldDefaults(deepCopyRillValue(fieldDef.defaultValue), fieldDef.type);
+                result[fieldName] = hydrateFieldDefaults(copyValue(fieldDef.defaultValue), fieldDef.type);
             }
             else if (hasCollectionFields(fieldDef.type)) {
                 result[fieldName] = hydrateFieldDefaults(emptyForType(fieldDef.type), fieldDef.type);
@@ -216,11 +246,14 @@ export function hydrateFieldDefaults(value, type) {
         }
         return result;
     }
-    if (type.type === 'ordered' && type.fields && isOrdered(value)) {
+    if (type.kind === 'ordered' &&
+        type.fields &&
+        isOrdered(value)) {
+        const t = type;
         const lookup = new Map(value.entries.map(([k, v]) => [k, v]));
-        const fieldNames = new Set(type.fields.map((f) => f.name ?? ''));
+        const fieldNames = new Set(t.fields.map((f) => f.name ?? ''));
         const resultEntries = [];
-        for (const field of type.fields) {
+        for (const field of t.fields) {
             const name = field.name ?? '';
             if (lookup.has(name)) {
                 resultEntries.push([
@@ -231,7 +264,7 @@ export function hydrateFieldDefaults(value, type) {
             else if (field.defaultValue !== undefined) {
                 resultEntries.push([
                     name,
-                    hydrateFieldDefaults(deepCopyRillValue(field.defaultValue), field.type),
+                    hydrateFieldDefaults(copyValue(field.defaultValue), field.type),
                 ]);
             }
             else if (hasCollectionFields(field.type)) {
@@ -250,7 +283,9 @@ export function hydrateFieldDefaults(value, type) {
         }
         return createOrdered(resultEntries);
     }
-    if (type.type === 'tuple' && type.elements && isTuple(value)) {
+    if (type.kind === 'tuple' &&
+        type.elements &&
+        isTuple(value)) {
         const elements = type.elements;
         const entries = value.entries;
         // All fields present: recurse into nested types for present positions
@@ -270,7 +305,7 @@ export function hydrateFieldDefaults(value, type) {
                 resultEntries.push(hydrateFieldDefaults(entries[i], el.type));
             }
             else if (el.defaultValue !== undefined) {
-                resultEntries.push(hydrateFieldDefaults(deepCopyRillValue(el.defaultValue), el.type));
+                resultEntries.push(hydrateFieldDefaults(copyValue(el.defaultValue), el.type));
             }
             else if (hasCollectionFields(el.type)) {
                 resultEntries.push(hydrateFieldDefaults(emptyForType(el.type), el.type));
@@ -327,6 +362,11 @@ export function marshalArgs(args, params, options) {
             if (param.defaultValue !== undefined) {
                 value = param.defaultValue;
             }
+            else if (param.type !== undefined && hasCollectionFields(param.type)) {
+                // Collection-typed param with field-level defaults: synthesize empty
+                // collection so Stage 2.5 (hydrateFieldDefaults) can fill in defaults
+                value = emptyForType(param.type);
+            }
             else {
                 // Stage 2: Missing required parameter
                 throw new RuntimeError('RILL-R044', `Missing argument for parameter '${param.name}'`, location, {
@@ -341,8 +381,8 @@ export function marshalArgs(args, params, options) {
         }
         // Stage 3: Type check when param.type is defined
         if (param.type !== undefined) {
-            if (!structuralTypeMatches(value, param.type)) {
-                const expectedType = formatStructuralType(param.type);
+            if (!structureMatches(value, param.type)) {
+                const expectedType = formatStructure(param.type);
                 const actualType = inferType(value);
                 throw new RuntimeError('RILL-R001', `Parameter type mismatch: ${param.name} expects ${expectedType}, got ${actualType}`, location, {
                     functionName,

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

@@ -6,18 +6,7 @@
  */
 import type { RuntimeContext, RuntimeOptions } from './types.js';
 import { type RillValue } from './values.js';
-import { type RillFunction } from './callable.js';
 export declare const UNVALIDATED_METHOD_PARAMS: Set<string>;
-export declare const UNVALIDATED_METHOD_RECEIVERS: Set<string>;
-/**
- * Build a ReadonlyMap of frozen ApplicationCallable dicts from an array of
- * [typeName, methods] pairs. Accepts pairs (not a plain object) so the same
- * typeName can appear more than once — duplicate method names across entries
- * for the same type trigger an Error (EC-6).
- *
- * Re-exported from the public barrel index for host integration use.
- */
-export declare function buildTypeMethodDicts(pairs: Array<[string, Record<string, RillFunction>]>): ReadonlyMap<string, Readonly<Record<string, RillValue>>>;
 /**
  * Create a runtime context for script execution.
  * This is the main entry point for configuring the Rill runtime.

package/dist/runtime/core/context.js

@@ -5,7 +5,8 @@
  * Public API for host applications.
  */
 import { RuntimeError } from '../../types.js';
-import { BUILTIN_FUNCTIONS, BUILTIN_METHODS } from '../ext/builtins.js';
+import { BUILTIN_FUNCTIONS } from '../ext/builtins.js';
+import { BUILT_IN_TYPES } from './type-registrations.js';
 import { bindDictCallables } from './types.js';
 import { inferType } from './values.js';
 import { callable, validateDefaultValueType, } from './callable.js';
@@ -17,69 +18,23 @@ const UNTYPED_BUILTINS = new Set(['log', 'chain']);
 // messages expected by protected language tests. Generic marshalArgs
 // must not fire before the method body's own check.
 export const UNVALIDATED_METHOD_PARAMS = new Set(['has', 'has_any', 'has_all']);
-// Built-in methods that perform their own receiver type checking with specific
-// error messages. Generic RILL-R003 must not fire before the method body runs.
-// Mirrors the old flat-structure convention of receiverTypes: [].
-export const UNVALIDATED_METHOD_RECEIVERS = new Set([
-    'head',
-    'tail',
-    'first',
-    'at',
-    'eq',
-    'ne',
-    'keys',
-    'values',
-    'entries',
-    'has',
-    'has_any',
-    'has_all',
-    'dimensions',
-    'model',
-    'similarity',
-    'dot',
-    'distance',
-    'norm',
-    'normalize',
-]);
 /**
- * Build a ReadonlyMap of frozen ApplicationCallable dicts from an array of
- * [typeName, methods] pairs. Accepts pairs (not a plain object) so the same
- * typeName can appear more than once — duplicate method names across entries
- * for the same type trigger an Error (EC-6).
- *
- * Re-exported from the public barrel index for host integration use.
+ * Derive the set of method names that handle their own receiver type checking.
+ * Collects names from methods where skipReceiverValidation is true.
+ * Methods without the flag default to standard RILL-R003 receiver validation.
  */
-export function buildTypeMethodDicts(pairs) {
-    const registry = new Map();
-    const result = new Map();
-    for (const [typeName, methods] of pairs) {
-        const seen = registry.get(typeName) ?? new Set();
-        registry.set(typeName, seen);
-        const existing = result.get(typeName) ?? {};
-        const dict = { ...existing };
-        for (const [name, fn] of Object.entries(methods)) {
-            if (seen.has(name)) {
-                throw new Error(`Duplicate method '${name}' on type '${typeName}'`);
+function deriveUnvalidatedMethodReceivers(registrations) {
+    const bypass = new Set();
+    for (const reg of registrations) {
+        for (const [name, method] of Object.entries(reg.methods)) {
+            if (method.skipReceiverValidation) {
+                bypass.add(name);
             }
-            seen.add(name);
-            const appCallable = {
-                __type: 'callable',
-                kind: 'application',
-                params: fn.params,
-                returnType: fn.returnType,
-                annotations: fn.annotations ?? {},
-                isProperty: false,
-                fn: fn.fn,
-            };
-            dict[name] = appCallable;
         }
-        result.set(typeName, Object.freeze(dict));
     }
-    return result;
+    return Object.freeze(bypass);
 }
 const BUILTIN_FN_CACHE = new Map();
-const BUILTIN_METHOD_PARAMS_CACHE = new Map();
-const BUILTIN_METHOD_RECEIVER_TYPES_CACHE = new Map();
 function initBuiltinCaches() {
     for (const [name, entry] of Object.entries(BUILTIN_FUNCTIONS)) {
         if (UNTYPED_BUILTINS.has(name)) {
@@ -94,21 +49,6 @@ function initBuiltinCaches() {
         };
         BUILTIN_FN_CACHE.set(name, { appCallable: typedCallable });
     }
-    for (const [typeName, methods] of Object.entries(BUILTIN_METHODS)) {
-        for (const [name, impl] of Object.entries(methods)) {
-            // Accumulate receiver types across all type groups for this method name.
-            // Skip methods that perform their own receiver type checking.
-            if (!UNVALIDATED_METHOD_RECEIVERS.has(name)) {
-                const existing = BUILTIN_METHOD_RECEIVER_TYPES_CACHE.get(name);
-                BUILTIN_METHOD_RECEIVER_TYPES_CACHE.set(name, existing !== undefined ? [...existing, typeName] : [typeName]);
-            }
-            if (!UNVALIDATED_METHOD_PARAMS.has(name)) {
-                if (impl.params.length > 0) {
-                    BUILTIN_METHOD_PARAMS_CACHE.set(name, impl.params);
-                }
-            }
-        }
-    }
 }
 // Initialise once at module load.
 initBuiltinCaches();
@@ -194,15 +134,74 @@ export function createRuntimeContext(options = {}) {
     const resolverConfigs = new Map(options.configurations?.resolvers
         ? Object.entries(options.configurations.resolvers)
         : []);
-    // Build typeMethodDicts fresh per context so duplicate detection (EC-6)
-    // uses isolated state and does not leak across context instances.
-    const typeMethodDicts = buildTypeMethodDicts(Object.entries(BUILTIN_METHODS));
+    // EC-1: Validate no duplicate type names in registrations.
+    const seenTypeNames = new Set();
+    for (const reg of BUILT_IN_TYPES) {
+        if (seenTypeNames.has(reg.name)) {
+            throw new Error(`Duplicate type registration '${reg.name}'`);
+        }
+        seenTypeNames.add(reg.name);
+    }
+    // EC-2: Validate every registration has protocol.format.
+    for (const reg of BUILT_IN_TYPES) {
+        if (!reg.protocol.format) {
+            throw new Error(`Type '${reg.name}' missing required format protocol`);
+        }
+    }
+    // Derive typeNames from registrations (replaces VALID_TYPE_NAMES in context).
+    const typeNames = Object.freeze(BUILT_IN_TYPES.map((r) => r.name));
+    // Derive leafTypes from registrations where isLeaf === true, plus 'any'
+    // which has no registration but rejects type arguments (AC-4).
+    const leafTypes = Object.freeze(new Set([
+        ...BUILT_IN_TYPES.filter((r) => r.isLeaf).map((r) => r.name),
+        'any',
+    ]));
+    // Derive method dicts from registration.methods (absorbs buildTypeMethodDicts
+    // logic). Validates EC-6: duplicate method on same type.
+    const methodRegistry = new Map();
+    const typeMethodDicts = new Map();
+    for (const reg of BUILT_IN_TYPES) {
+        const methods = reg.methods;
+        if (!methods || Object.keys(methods).length === 0)
+            continue;
+        const seen = methodRegistry.get(reg.name) ?? new Set();
+        methodRegistry.set(reg.name, seen);
+        const existing = typeMethodDicts.get(reg.name) ?? {};
+        const dict = { ...existing };
+        for (const [name, fn] of Object.entries(methods)) {
+            if (seen.has(name)) {
+                throw new Error(`Duplicate method '${name}' on type '${reg.name}'`);
+            }
+            seen.add(name);
+            const appCallable = {
+                __type: 'callable',
+                kind: 'application',
+                params: fn.params,
+                returnType: fn.returnType,
+                annotations: fn.annotations ?? {},
+                isProperty: false,
+                fn: fn.fn,
+            };
+            dict[name] = appCallable;
+        }
+        typeMethodDicts.set(reg.name, Object.freeze(dict));
+    }
+    // Derive bypass set from registrations: method names that handle their own
+    // receiver type checking. Generic RILL-R003 must not fire before the method body.
+    const unvalidatedMethodReceivers = deriveUnvalidatedMethodReceivers(BUILT_IN_TYPES);
+    // BC-5: Freeze all derived collections after creation.
+    Object.freeze(typeNames);
+    Object.freeze(typeMethodDicts);
+    // Suppress unused-variable warning for typeNames (consumed in later phases).
+    void typeNames;
     return {
         parent: undefined,
         variables,
         variableTypes,
         functions,
         typeMethodDicts,
+        leafTypes,
+        unvalidatedMethodReceivers,
         callbacks: { ...defaultCallbacks, ...options.callbacks },
         observability: options.observability ?? {},
         pipeValue: null,
@@ -232,6 +231,8 @@ export function createChildContext(parent, overrides) {
         variableTypes: new Map(),
         functions: parent.functions,
         typeMethodDicts: parent.typeMethodDicts,
+        leafTypes: parent.leafTypes,
+        unvalidatedMethodReceivers: parent.unvalidatedMethodReceivers,
         callbacks: parent.callbacks,
         observability: parent.observability,
         pipeValue: parent.pipeValue,

package/dist/runtime/core/eval/index.d.ts

@@ -9,7 +9,7 @@
 import type { AnnotatedStatementNode, ASTNode, CaptureNode, ExpressionNode, RillTypeName, SourceLocation, StatementNode } from '../../../types.js';
 import type { RillCallable } from '../callable.js';
 import type { RuntimeContext } from '../types.js';
-import type { RillValue, RillType } from '../values.js';
+import type { RillValue, TypeStructure } from '../values.js';
 /**
  * Capture information returned by handleCapture.
  */
@@ -39,7 +39,7 @@ export declare function handleCapture(capture: CaptureNode | null, value: RillVa
  * Assert that a value is of the expected type.
  * Returns the value unchanged if assertion passes, throws on mismatch.
  */
-export declare function assertType(value: RillValue, expected: RillTypeName | RillType, location?: SourceLocation): RillValue;
+export declare function assertType(value: RillValue, expected: RillTypeName | TypeStructure, location?: SourceLocation): RillValue;
 /**
  * Evaluate an expression and return its value.
  * Main entry point for expression evaluation.