@rcrsr/rill 0.16.0 → 0.18.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.18.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.18.0';
 /**
  * Parsed version components
  */
 export const VERSION_INFO = {
     major: 0,
-    minor: 16,
+    minor: 18,
     patch: 0,
     prerelease: undefined,
 };

package/dist/highlight-map.js

@@ -24,6 +24,7 @@ export const TOKEN_HIGHLIGHT_MAP = new Map([
     ['FILTER', 'keyword'],
     ['BREAK', 'keyword'],
     ['RETURN', 'keyword'],
+    ['YIELD', 'keyword'],
     ['PASS', 'keyword'],
     ['ASSERT', 'keyword'],
     ['ERROR', 'keyword'],

package/dist/index.d.ts

@@ -5,11 +5,8 @@
 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, BUILT_IN_TYPES, BUILTIN_METHODS, buildFieldDescriptor, callable, type CallableFn, type CallFrame, commonType, compareStructuredFields, type CaptureEvent, type ConfigFieldDescriptor, contextResolver, copyValue, createOrdered, createRillStream, createRuntimeContext, createStepper, createTestContext, createTuple, createVector, deepEquals, deserializeValue, type DocumentationCoverageResult, emitExtensionEvent, type ErrorEvent, execute, type ExecutionResult, type ExecutionStepper, ExtensionBindingError, type ExtensionConfigSchema, type ExtensionEvent, type ExtensionFactory, type ExtensionFactoryResult, type ExtensionManifest, extResolver, type FieldComparisonCallbacks, formatRillLiteral, formatStructure, formatValue, type FsExtensionContract, type FunctionMetadata, type FunctionReturnEvent, generateManifest, getCallStack, getDocumentationCoverage, getFunctions, getLanguageReference, type HostCallEvent, hydrateFieldDefaults, inferElementType, inferStructure, inferType, invokeCallable, isApplicationCallable, isCallable, isDict, isEmpty, isIterator, isReservedMethod, isRillStream, isRuntimeCallable, isScriptCallable, isStream, isTruthy, isTuple, isTypeValue, isVector, type KvExtensionContract, marshalArgs, type MarshalOptions, moduleResolver, type NativeArray, type NativePlainObject, type NativeResult, type NativeValue, type ObservabilityCallbacks, type ParamMetadata, paramToFieldDef, popCallFrame, pushCallFrame, RESERVED_DICT_METHODS, type ResolverResult, ReturnSignal, YieldSignal, type RillCallable, type RillFieldDef, type RillFunction, type RillIterator, type RillParam, type RillStream, type RillTuple, type RillTypeValue, type RillValue, type RillVector, type RuntimeCallable, type RuntimeCallbacks, type RuntimeContext, type RuntimeOptions, type SchemaEntry, type SchemeResolver, type ScriptCallable, serializeValue, 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';
 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,7 @@
  */
 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, BUILT_IN_TYPES, BUILTIN_METHODS, buildFieldDescriptor, callable, commonType, compareStructuredFields, contextResolver, copyValue, createOrdered, createRillStream, createRuntimeContext, createStepper, createTestContext, createTuple, createVector, deepEquals, deserializeValue, emitExtensionEvent, execute, ExtensionBindingError, extResolver, formatRillLiteral, formatStructure, formatValue, generateManifest, getCallStack, getDocumentationCoverage, getFunctions, getLanguageReference, hydrateFieldDefaults, inferElementType, inferStructure, inferType, invokeCallable, isApplicationCallable, isCallable, isDict, isEmpty, isIterator, isReservedMethod, isRillStream, isRuntimeCallable, isScriptCallable, isStream, isTruthy, isTuple, isTypeValue, isVector, marshalArgs, moduleResolver, paramToFieldDef, popCallFrame, pushCallFrame, RESERVED_DICT_METHODS, ReturnSignal, YieldSignal, serializeValue, structureEquals, structureMatches, structureToTypeValue, toCallable, toNative, VERSION, VERSION_INFO, } from './runtime/index.js';
 // ============================================================
 // ERROR TAXONOMY
 // ============================================================
@@ -14,10 +14,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/lexer/operators.js

@@ -48,6 +48,7 @@ export const KEYWORDS = {
     false: TOKEN_TYPES.FALSE,
     break: TOKEN_TYPES.BREAK,
     return: TOKEN_TYPES.RETURN,
+    yield: TOKEN_TYPES.YIELD,
     pass: TOKEN_TYPES.PASS,
     assert: TOKEN_TYPES.ASSERT,
     error: TOKEN_TYPES.ERROR,

package/dist/parser/helpers.js

@@ -25,6 +25,7 @@ export function isIdentifierOrKeyword(token) {
         token.type === TOKEN_TYPES.FALSE ||
         token.type === TOKEN_TYPES.BREAK ||
         token.type === TOKEN_TYPES.RETURN ||
+        token.type === TOKEN_TYPES.YIELD ||
         token.type === TOKEN_TYPES.ASSERT ||
         token.type === TOKEN_TYPES.ERROR ||
         token.type === TOKEN_TYPES.EACH ||

package/dist/parser/parser-expr.js

@@ -139,6 +139,20 @@ Parser.prototype.parsePipeChain = function () {
             span: token.span,
         };
     }
+    // Handle bare yield: "yield" ≡ "$ -> yield"
+    if (check(this.state, TOKEN_TYPES.YIELD)) {
+        if (this.closureDepth === 0) {
+            throw new ParseError('RILL-P006', "'yield' is only valid inside a stream closure", current(this.state).span.start);
+        }
+        const token = advance(this.state);
+        return {
+            type: 'PipeChain',
+            head: this.implicitPipeVar(token.span),
+            pipes: [],
+            terminator: { type: 'Yield', span: token.span },
+            span: token.span,
+        };
+    }
     // Parse expression head with full precedence chain
     let head = this.parseLogicalOr();
     // Check for loop: expr @ body
@@ -214,6 +228,15 @@ Parser.prototype.parsePipeChain = function () {
             terminator = { type: 'Return', span: token.span };
             break;
         }
+        // Check for yield terminator: -> yield
+        if (check(this.state, TOKEN_TYPES.YIELD)) {
+            if (this.closureDepth === 0) {
+                throw new ParseError('RILL-P006', "'yield' is only valid inside a stream closure", current(this.state).span.start);
+            }
+            const token = advance(this.state);
+            terminator = { type: 'Yield', span: token.span };
+            break;
+        }
         // Guard against removed -> export syntax
         if (check(this.state, TOKEN_TYPES.IDENTIFIER) &&
             current(this.state).value === 'export') {
@@ -576,8 +599,14 @@ Parser.prototype.parsePrimary = function () {
     if (isMethodCall(this.state)) {
         return this.parseMethodCall(null);
     }
-    // Type constructor: list(...), dict(...), tuple(...), ordered(...)
-    const TYPE_CONSTRUCTORS = ['list', 'dict', 'tuple', 'ordered'];
+    // Type constructor: list(...), dict(...), tuple(...), ordered(...), stream(...)
+    const TYPE_CONSTRUCTORS = [
+        'list',
+        'dict',
+        'tuple',
+        'ordered',
+        'stream',
+    ];
     if (check(this.state, TOKEN_TYPES.IDENTIFIER) &&
         TYPE_CONSTRUCTORS.includes(current(this.state).value) &&
         this.state.tokens[this.state.pos + 1]?.type === TOKEN_TYPES.LPAREN) {
@@ -615,6 +644,10 @@ Parser.prototype.parsePrimary = function () {
     const common = this.parseCommonConstruct();
     if (common)
         return common;
+    // Yield keyword in expression position (not valid as identifier)
+    if (check(this.state, TOKEN_TYPES.YIELD)) {
+        throw new ParseError('RILL-P001', "Unexpected keyword 'yield'", current(this.state).span.start);
+    }
     // Detect heredoc syntax (removed feature)
     const token = current(this.state);
     if (token.type === TOKEN_TYPES.LT &&
@@ -1063,10 +1096,16 @@ Parser.prototype.parseConvert = function () {
     const start = current(this.state).span.start;
     expect(this.state, TOKEN_TYPES.COLON, 'Expected :');
     expect(this.state, TOKEN_TYPES.GT, 'Expected >');
-    // Structural convert: :>ordered(field: type, ...)
-    const TYPE_CONSTRUCTORS = ['list', 'dict', 'tuple', 'ordered'];
+    // Structural convert: :>ordered(field: type, ...), :>stream(T), etc.
+    const TYPE_CONSTRUCTORS_CONVERT = [
+        'list',
+        'dict',
+        'tuple',
+        'ordered',
+        'stream',
+    ];
     if (check(this.state, TOKEN_TYPES.IDENTIFIER) &&
-        TYPE_CONSTRUCTORS.includes(current(this.state).value) &&
+        TYPE_CONSTRUCTORS_CONVERT.includes(current(this.state).value) &&
         this.state.tokens[this.state.pos + 1]?.type === TOKEN_TYPES.LPAREN) {
         const constructorName = current(this.state).value;
         const typeRef = this.parseTypeConstructor(constructorName);

package/dist/parser/parser-literals.js

@@ -7,7 +7,7 @@ import { ParseError, TOKEN_TYPES } from '../types.js';
 import { tokenize } from '../lexer/index.js';
 import { check, advance, expect, current, peek, skipNewlines, makeSpan, } from './state.js';
 import { isDictStart, isNegativeNumber, VALID_TYPE_NAMES } from './helpers.js';
-import { parseTypeRef } from './parser-types.js';
+import { parseTypeRef, parseFieldArgList } from './parser-types.js';
 // ============================================================
 // LITERAL PARSING
 // ============================================================
@@ -384,14 +384,106 @@ Parser.prototype.parseDictEntry = function () {
 // ============================================================
 // CLOSURE PARSING
 // ============================================================
+/**
+ * Parse a stream type constructor: stream(T):R
+ *
+ * Grammar: "stream" "(" [type-ref] ")" [":" type-ref]
+ *
+ * Chunk type goes in args[0], resolution type in args[1].
+ * stream() → 0 args, stream(T) → 1 arg, stream(T):R → 2 args.
+ *
+ * @internal
+ */
+function parseStreamTypeConstructor(parser) {
+    const start = current(parser.state).span.start;
+    advance(parser.state); // consume 'stream'
+    if (!check(parser.state, TOKEN_TYPES.LPAREN)) {
+        throw new ParseError('RILL-P006', 'Expected type name in stream constructor', current(parser.state).span.start);
+    }
+    advance(parser.state); // consume '('
+    const args = parseFieldArgList(parser.state);
+    const rparen = expect(parser.state, TOKEN_TYPES.RPAREN, 'Expected )', 'RILL-P005');
+    // Check for resolution type: stream(T):R
+    if (check(parser.state, TOKEN_TYPES.COLON)) {
+        advance(parser.state); // consume ':'
+        skipNewlines(parser.state);
+        // Guard: resolution type must start with a valid type name
+        if (!check(parser.state, TOKEN_TYPES.IDENTIFIER)) {
+            throw new ParseError('RILL-P006', "Expected type name after ':' in stream type", current(parser.state).span.start);
+        }
+        // Parse the resolution type reference
+        const resolutionType = parseTypeRef(parser.state);
+        // Ensure positional alignment: args[0] = chunk, args[1] = ret.
+        // When parens are empty (no chunk type), insert an 'any' placeholder
+        // so the runtime correctly maps arg positions.
+        if (args.length === 0) {
+            args.push({ value: { kind: 'static', typeName: 'any' } });
+        }
+        args.push({ value: resolutionType });
+        return {
+            type: 'TypeConstructor',
+            constructorName: 'stream',
+            args,
+            span: makeSpan(start, current(parser.state).span.end),
+        };
+    }
+    return {
+        type: 'TypeConstructor',
+        constructorName: 'stream',
+        args,
+        span: makeSpan(start, rparen.span.end),
+    };
+}
+/**
+ * Check whether a closure body contains any yield terminators at the
+ * immediate level (not inside nested closures). Returns true if at
+ * least one yield is found.
+ * @internal
+ */
+function bodyContainsYield(body) {
+    if (body.type === 'PipeChain') {
+        if (body.terminator?.type === 'Yield')
+            return true;
+        return false;
+    }
+    if (body.type === 'Block') {
+        for (const stmt of body.statements) {
+            const expr = stmt.type === 'AnnotatedStatement'
+                ? stmt.statement.expression
+                : stmt.expression;
+            if (expr.terminator?.type === 'Yield')
+                return true;
+        }
+        return false;
+    }
+    return false;
+}
+/**
+ * Validate that yield nodes in a closure body are only present when
+ * the closure has a stream return type. Throws RILL-P006 if yield
+ * appears without :stream(T):R annotation.
+ * @internal
+ */
+function validateYieldInClosure(body, returnTypeTarget, closureStart) {
+    if (!bodyContainsYield(body))
+        return;
+    const isStream = returnTypeTarget !== undefined &&
+        'type' in returnTypeTarget &&
+        returnTypeTarget.type === 'TypeConstructor' &&
+        returnTypeTarget.constructorName === 'stream';
+    if (!isStream) {
+        throw new ParseError('RILL-P006', "'yield' is only valid inside a stream closure", closureStart);
+    }
+}
 /**
  * Parse the optional postfix `:type-target` after a closure body.
  *
  * Grammar: [ ":" , type-target ]
- * type-target = shape(...) | type-ref
+ * type-target = "stream" "(" [type-ref] ")" [":" type-ref] | type-ref
  *
- * Returns the parsed TypeRef or ShapeLiteralNode, or undefined if absent.
+ * Returns the parsed TypeRef, TypeConstructorNode, or undefined if absent.
  * Follows the same disambiguation logic as parsePostfixTypeOperation.
+ * Extended for stream(T):R return type pattern.
  */
 function parseClosureReturnTypeTarget(parser) {
     skipNewlines(parser.state);
@@ -400,6 +492,11 @@ function parseClosureReturnTypeTarget(parser) {
     }
     advance(parser.state); // consume ':'
     skipNewlines(parser.state);
+    // Stream type constructor: stream(T):R
+    if (check(parser.state, TOKEN_TYPES.IDENTIFIER) &&
+        current(parser.state).value === 'stream') {
+        return parseStreamTypeConstructor(parser);
+    }
     // Default: plain type name or dynamic type reference
     return parseTypeRef(parser.state);
 }
@@ -408,8 +505,11 @@ Parser.prototype.parseClosure = function () {
     if (check(this.state, TOKEN_TYPES.OR)) {
         advance(this.state);
         skipNewlines(this.state);
+        this.closureDepth++;
         const body = this.parseBody(true);
+        this.closureDepth--;
         const returnTypeTarget = parseClosureReturnTypeTarget(this);
+        validateYieldInClosure(body, returnTypeTarget, start);
         return {
             type: 'Closure',
             params: [],
@@ -454,8 +554,11 @@ Parser.prototype.parseClosure = function () {
         const typeRef = parseTypeRef(this.state, { allowTrailingPipe: true });
         expect(this.state, TOKEN_TYPES.PIPE_BAR, 'Expected |', 'RILL-P005');
         skipNewlines(this.state);
+        this.closureDepth++;
         const body = this.parseBody(true);
+        this.closureDepth--;
         const returnTypeTarget = parseClosureReturnTypeTarget(this);
+        validateYieldInClosure(body, returnTypeTarget, start);
         const param = {
             type: 'ClosureParam',
             name: '$',
@@ -482,8 +585,11 @@ Parser.prototype.parseClosure = function () {
     }
     expect(this.state, TOKEN_TYPES.PIPE_BAR, 'Expected |', 'RILL-P005');
     skipNewlines(this.state);
+    this.closureDepth++;
     const body = this.parseBody(true);
+    this.closureDepth--;
     const returnTypeTarget = parseClosureReturnTypeTarget(this);
+    validateYieldInClosure(body, returnTypeTarget, start);
     return {
         type: 'Closure',
         params,
@@ -500,7 +606,8 @@ Parser.prototype.parseBody = function (allowEmptyBlock) {
         return this.parseGrouped();
     }
     if (check(this.state, TOKEN_TYPES.BREAK) ||
-        check(this.state, TOKEN_TYPES.RETURN)) {
+        check(this.state, TOKEN_TYPES.RETURN) ||
+        check(this.state, TOKEN_TYPES.YIELD)) {
         return this.parsePipeChain();
     }
     return this.parsePostfixExpr();

package/dist/parser/parser-shape.js

@@ -18,9 +18,9 @@ import { parseFieldArgList } from './parser-types.js';
  * Produces TypeConstructorNode.
  */
 Parser.prototype.parseTypeConstructor = function (constructorName) {
-    const validNames = ['list', 'dict', 'tuple', 'ordered'];
+    const validNames = ['list', 'dict', 'tuple', 'ordered', 'stream'];
     if (!validNames.includes(constructorName)) {
-        throw new ParseError('RILL-P001', `Expected type constructor name (list, dict, tuple, ordered), got: ${constructorName}`, current(this.state).span.start);
+        throw new ParseError('RILL-P001', `Expected type constructor name (list, dict, tuple, ordered, stream), got: ${constructorName}`, current(this.state).span.start);
     }
     const start = current(this.state).span.start;
     // Consume the constructor name identifier token

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

@@ -55,8 +55,20 @@ Parser.prototype.parseUseExpr = function () {
     expect(this.state, TOKEN_TYPES.GT, "Expected '>' to close use<>", 'RILL-P022');
     let typeRef = null;
     let closureAnnotation = null;
+    const parseLiteral = () => this.parseLiteral();
     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 = [];
+            // Optional return type after :||
+            if (check(this.state, TOKEN_TYPES.COLON)) {
+                advance(this.state); // consume :
+                typeRef = parseTypeRef(this.state, { parseLiteral });
+            }
+        }
+        else if (peek(this.state, 1).type === TOKEN_TYPES.PIPE_BAR) {
             // Closure annotation: :|param: type, ...|
             advance(this.state); // consume :
             advance(this.state); // consume opening |
@@ -66,11 +78,17 @@ Parser.prototype.parseUseExpr = function () {
                 expect(this.state, TOKEN_TYPES.COLON, 'Expected : after parameter name in closure annotation');
                 const paramTypeRef = parseTypeRef(this.state, {
                     allowTrailingPipe: true,
+                    parseLiteral,
                 });
-                closureAnnotation.push({
+                const entry = {
                     name: nameToken.value,
                     typeRef: paramTypeRef,
-                });
+                };
+                if (check(this.state, TOKEN_TYPES.ASSIGN)) {
+                    advance(this.state); // consume =
+                    entry.defaultValue = parseLiteral();
+                }
+                closureAnnotation.push(entry);
                 if (check(this.state, TOKEN_TYPES.COMMA)) {
                     advance(this.state); // consume ,
                 }
@@ -79,6 +97,11 @@ Parser.prototype.parseUseExpr = function () {
                 }
             }
             advance(this.state); // consume closing |
+            // Optional return type after :|params|
+            if (check(this.state, TOKEN_TYPES.COLON)) {
+                advance(this.state); // consume :
+                typeRef = parseTypeRef(this.state, { parseLiteral });
+            }
         }
         else {
             advance(this.state); // consume :

package/dist/parser/parser.d.ts

@@ -33,6 +33,8 @@ import { type ParserState } from './state.js';
 export declare class Parser {
     /** Parser state including tokens, position, and error collection */
     state: ParserState;
+    /** Tracks closure nesting depth for yield validation */
+    closureDepth: number;
     constructor(tokens: Token[], options?: {
         recoveryMode?: boolean;
         source?: string;

package/dist/parser/parser.js

@@ -32,6 +32,8 @@ import { createParserState } from './state.js';
 export class Parser {
     /** Parser state including tokens, position, and error collection */
     state;
+    /** Tracks closure nesting depth for yield validation */
+    closureDepth = 0;
     constructor(tokens, options) {
         this.state = createParserState(tokens, {
             recoveryMode: options?.recoveryMode ?? false,

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

@@ -20,7 +20,8 @@
  * - Kept for API consistency with marshalArgs signature
  */
 import type { BodyNode, SourceLocation } from '../../types.js';
-import type { RillType, RillTypeValue, RillValue } from './values.js';
+import { isDict } from './types/guards.js';
+import type { TypeStructure, RillTypeValue, RillValue } from './types/structures.js';
 interface RuntimeContextLike {
     readonly parent?: RuntimeContextLike | undefined;
     readonly variables: Map<string, RillValue>;
@@ -42,7 +43,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 +58,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 {
@@ -97,8 +100,8 @@ export interface ApplicationCallable extends CallableBase {
 }
 /** Union of all callable types */
 export type RillCallable = ScriptCallable | RuntimeCallable | ApplicationCallable;
-/** Type guard for any callable */
-export declare function isCallable(value: RillValue): value is RillCallable;
+/** Type guard for any callable (delegates to types/guards.ts) */
+export declare const isCallable: (value: RillValue) => value is RillCallable;
 /** Type guard for script callable */
 export declare function isScriptCallable(value: RillValue): value is ScriptCallable;
 /** Type guard for runtime callable */
@@ -112,8 +115,17 @@ 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;
-/** Type guard for dict (plain object, not array, not callable, not tuple) */
-export declare function isDict(value: RillValue): value is Record<string, RillValue>;
+/**
+ * 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;
+export { isDict };
 /** Format a callable for display */
 export declare function formatCallable(callable: RillCallable): string;
 /**
@@ -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.
  *
@@ -196,4 +208,3 @@ export declare function hydrateFieldDefaults(value: RillValue, type: RillType):
  * @returns Named argument map keyed by param name
  */
 export declare function marshalArgs(args: RillValue[], params: readonly RillParam[], options?: MarshalOptions): Record<string, RillValue>;
-export {};