@rcrsr/rill 0.17.0 → 0.18.0

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,21 +5,7 @@
 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, 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 { 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 { type HighlightCategory, TOKEN_HIGHLIGHT_MAP, } from './highlight-map.js';

package/dist/index.js

@@ -4,20 +4,7 @@
  */
 export { LexerError, tokenize } from './lexer/index.js';
 export { parse, parseWithRecovery } from './parser/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';
+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
 // ============================================================

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-use.js

@@ -55,12 +55,18 @@ 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.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, ...|
@@ -72,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 ,
                 }
@@ -85,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 { TypeStructure, 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>;
@@ -99,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 */
@@ -124,8 +125,7 @@ export declare function callable(fn: CallableFn, isProperty?: boolean): Applicat
  * @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>;
+export { isDict };
 /** Format a callable for display */
 export declare function formatCallable(callable: RillCallable): string;
 /**
@@ -208,4 +208,3 @@ export declare function hydrateFieldDefaults(value: RillValue, type: TypeStructu
  * @returns Named argument map keyed by param name
  */
 export declare function marshalArgs(args: RillValue[], params: readonly RillParam[], options?: MarshalOptions): Record<string, RillValue>;
-export {};

package/dist/runtime/core/callable.js

@@ -21,14 +21,13 @@
  */
 import { RuntimeError } from '../../types.js';
 import { astEquals } from './equals.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' &&
-        value !== null &&
-        '__type' in value &&
-        value.__type === 'callable');
-}
+import { isCallable as _isCallableGuard, isDict, isOrdered, isTuple, } from './types/guards.js';
+import { formatValue, inferType } from './types/registrations.js';
+import { formatStructure, paramToFieldDef, structureEquals, structureMatches, } from './types/operations.js';
+import { createOrdered, copyValue, emptyForType, } from './types/constructors.js';
+import { anyTypeValue, hasCollectionFields } from './values.js';
+/** Type guard for any callable (delegates to types/guards.ts) */
+export const isCallable = _isCallableGuard;
 /** Type guard for script callable */
 export function isScriptCallable(value) {
     return isCallable(value) && value.kind === 'script';
@@ -90,14 +89,8 @@ export function toCallable(def, isProperty = false) {
         annotations: def.annotations ?? {},
     };
 }
-/** Type guard for dict (plain object, not array, not callable, not tuple) */
-export function isDict(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        !Array.isArray(value) &&
-        !isCallable(value) &&
-        !isTuple(value));
-}
+// isDict imported from ./types/guards.js and re-exported
+export { isDict };
 /** Format a callable for display */
 export function formatCallable(callable) {
     if (callable.kind === 'script') {
@@ -214,7 +207,7 @@ export function validateDefaultValueType(param, _functionName) {
     if (!structureMatches(param.defaultValue, param.type)) {
         const actualType = inferType(param.defaultValue);
         const expectedType = formatStructure(param.type);
-        throw new Error(`Invalid defaultValue for parameter '${param.name}': expected ${expectedType}, got ${actualType}`);
+        throw new RuntimeError('RILL-R077', `Invalid defaultValue for parameter '${param.name}': expected ${expectedType}, got ${actualType}`);
     }
 }
 /**

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

@@ -4,8 +4,8 @@
  * Creates and configures the runtime context for script execution.
  * Public API for host applications.
  */
-import type { RuntimeContext, RuntimeOptions } from './types.js';
-import { type RillValue } from './values.js';
+import type { RuntimeContext, RuntimeOptions } from './types/runtime.js';
+import type { RillValue } from './types/structures.js';
 export declare const UNVALIDATED_METHOD_PARAMS: Set<string>;
 /**
  * Create a runtime context for script execution.

package/dist/runtime/core/context.js

@@ -6,9 +6,9 @@
  */
 import { RuntimeError } from '../../types.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 { BUILT_IN_TYPES } from './types/registrations.js';
+import { bindDictCallables } from './types/runtime.js';
+import { inferType } from './types/registrations.js';
 import { callable, validateDefaultValueType, } from './callable.js';
 // Built-in functions that are genuinely variadic and must skip arg validation.
 // log: tests call log("msg", extraValue) — extra args are silently ignored.
@@ -93,7 +93,7 @@ export function createRuntimeContext(options = {}) {
                 if (description === undefined ||
                     typeof description !== 'string' ||
                     description.trim().length === 0) {
-                    throw new Error(`Function '${name}' requires description (requireDescriptions enabled)`);
+                    throw new RuntimeError('RILL-R069', `Function '${name}' requires description (requireDescriptions enabled)`);
                 }
                 // Check parameter descriptions (EC-11)
                 for (const param of params) {
@@ -101,7 +101,7 @@ export function createRuntimeContext(options = {}) {
                     if (paramDesc === undefined ||
                         typeof paramDesc !== 'string' ||
                         paramDesc.trim().length === 0) {
-                        throw new Error(`Parameter '${param.name}' of function '${name}' requires description (requireDescriptions enabled)`);
+                        throw new RuntimeError('RILL-R070', `Parameter '${param.name}' of function '${name}' requires description (requireDescriptions enabled)`);
                     }
                 }
             }
@@ -138,14 +138,14 @@ export function createRuntimeContext(options = {}) {
     const seenTypeNames = new Set();
     for (const reg of BUILT_IN_TYPES) {
         if (seenTypeNames.has(reg.name)) {
-            throw new Error(`Duplicate type registration '${reg.name}'`);
+            throw new RuntimeError('RILL-R071', `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`);
+            throw new RuntimeError('RILL-R072', `Type '${reg.name}' missing required format protocol`);
         }
     }
     // Derive typeNames from registrations (replaces VALID_TYPE_NAMES in context).
@@ -170,7 +170,7 @@ export function createRuntimeContext(options = {}) {
         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}'`);
+                throw new RuntimeError('RILL-R073', `Duplicate method '${name}' on type '${reg.name}'`);
             }
             seen.add(name);
             const appCallable = {

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

@@ -7,8 +7,8 @@
  * @internal
  */
 import type { ASTNode, CaptureNode, SourceLocation } from '../../../types.js';
-import type { RuntimeContext } from '../types.js';
-import type { RillValue } from '../values.js';
+import type { RuntimeContext } from '../types/runtime.js';
+import type { RillValue } from '../types/structures.js';
 /**
  * Base class for the evaluator.
  * Contains shared utilities used by all mixins.

package/dist/runtime/core/eval/base.js

@@ -74,6 +74,8 @@ export class EvaluatorBase {
      * Phase 1-3 use the functional evaluator which has its own handleCapture.
      */
     handleCapture(_capture, _value) {
+        // AC-13: Intentional raw throw - internal mixin guard, not user-reachable.
+        // This stub only runs if mixin composition is incomplete (programming error).
         throw new Error('handleCapture requires full Evaluator composition with VariablesMixin');
     }
     /**

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

@@ -100,7 +100,7 @@
  *
  * @internal
  */
-import type { RuntimeContext } from '../types.js';
+import type { RuntimeContext } from '../types/runtime.js';
 /**
  * Complete Evaluator class composed from all mixins.
  *

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

@@ -8,8 +8,8 @@
  */
 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, TypeStructure } from '../values.js';
+import type { RuntimeContext } from '../types/runtime.js';
+import type { RillValue, TypeStructure } from '../types/structures.js';
 /**
  * Capture information returned by handleCapture.
  */