@rcrsr/rill 0.16.0 → 0.18.0

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

@@ -25,7 +25,10 @@
  * @internal
  */
 import { RuntimeError } from '../../../../types.js';
-import { anyTypeValue, deepEquals, formatValue, inferElementType, isReservedMethod, isTypeValue, isVector, } from '../../values.js';
+import { deepEquals, formatValue } from '../../types/registrations.js';
+import { isTypeValue, isVector } from '../../types/guards.js';
+import { inferElementType } from '../../types/operations.js';
+import { anyTypeValue, isReservedMethod } from '../../values.js';
 import { isCallable, } from '../../callable.js';
 import { getVariable } from '../../context.js';
 /**
@@ -642,13 +645,13 @@ function createLiteralsMixin(Base) {
                 if (resolvedType === undefined && defaultValue !== undefined) {
                     const defaultKind = typeof defaultValue;
                     if (defaultKind === 'string') {
-                        resolvedType = { type: 'string' };
+                        resolvedType = { kind: 'string' };
                     }
                     else if (defaultKind === 'number') {
-                        resolvedType = { type: 'number' };
+                        resolvedType = { kind: 'number' };
                     }
                     else if (defaultKind === 'boolean') {
-                        resolvedType = { type: 'bool' };
+                        resolvedType = { kind: 'bool' };
                     }
                 }
                 // Evaluate per-param annotations inline
@@ -667,12 +670,20 @@ function createLiteralsMixin(Base) {
             }
             const isProperty = rillParams.length === 0;
             // Evaluate returnTypeTarget at closure creation time (IR-4).
+            // TypeConstructorNode → resolve via evaluateTypeConstructor() (e.g., stream(T):R).
             // TypeRef → resolve via resolveTypeRef() — returns RillTypeValue.
             // Absent → returnType defaults to anyTypeValue (omission implies :any, AC-17, AC-18, AC-19).
             let returnType = anyTypeValue;
             if (node.returnTypeTarget !== undefined) {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                returnType = await this.resolveTypeRef(node.returnTypeTarget, (name) => getVariable(this.ctx, name));
+                if ('type' in node.returnTypeTarget &&
+                    node.returnTypeTarget.type === 'TypeConstructor') {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    returnType = await this.evaluateTypeConstructor(node.returnTypeTarget);
+                }
+                else {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    returnType = await this.resolveTypeRef(node.returnTypeTarget, (name) => getVariable(this.ctx, name));
+                }
             }
             return {
                 __type: 'callable',

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

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

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

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

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

@@ -5,7 +5,7 @@
  * Provides both full execution and step-by-step execution.
  */
 import type { ScriptNode } from '../../types.js';
-import type { ExecutionResult, ExecutionStepper, RuntimeContext } from './types.js';
+import type { ExecutionResult, ExecutionStepper, RuntimeContext } from './types/runtime.js';
 /**
  * Execute a parsed Rill script.
  *

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

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

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

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

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

@@ -4,8 +4,8 @@
  * Functions for inspecting runtime context at runtime.
  * These enable host applications to discover available functions and their signatures.
  */
-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';
 /**
  * Metadata describing a function's signature and documentation.
  * Returned by introspection APIs like getFunctions().

package/dist/runtime/core/introspection.js

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

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

@@ -4,7 +4,7 @@
  * moduleResolver — reads Rill source files from the filesystem.
  * extResolver    — returns extension values from a host-provided config map.
  */
-import type { SchemeResolver } from './types.js';
+import type { SchemeResolver } from './types/runtime.js';
 /**
  * Resolves a module ID to Rill source text by reading a file.
  *

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

@@ -5,7 +5,7 @@
  * These are part of the public API for host applications that
  * need to catch and handle control flow.
  */
-import type { RillValue } from './values.js';
+import type { RillValue } from './types/structures.js';
 /** Signal thrown by `break` to exit loops */
 export declare class BreakSignal extends Error {
     readonly value: RillValue;
@@ -16,3 +16,8 @@ export declare class ReturnSignal extends Error {
     readonly value: RillValue;
     constructor(value: RillValue);
 }
+/** Signal thrown when a stream yields a chunk value */
+export declare class YieldSignal extends Error {
+    readonly value: RillValue;
+    constructor(value: RillValue);
+}

package/dist/runtime/core/signals.js

@@ -23,3 +23,12 @@ export class ReturnSignal extends Error {
         this.name = 'ReturnSignal';
     }
 }
+/** Signal thrown when a stream yields a chunk value */
+export class YieldSignal extends Error {
+    value;
+    constructor(value) {
+        super('yield');
+        this.value = value;
+        this.name = 'YieldSignal';
+    }
+}

package/dist/runtime/core/types/constructors.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Value Constructors
+ *
+ * Factory functions for creating Rill compound values (tuples, ordered,
+ * vectors) and collection utilities (emptyForType, copyValue).
+ *
+ * Import constraints:
+ * - Imports from ./structures.js and ./guards.js
+ * - No imports from values.ts or callable.ts
+ */
+import type { RillOrdered, RillStream, RillTuple, RillValue, RillVector, TypeStructure } from './structures.js';
+/**
+ * Create ordered from entries array (named, preserves insertion order).
+ * Entries may be 2-element [name, value] or 3-element [name, value, default]
+ * tuples; the third element carries a default value for `.^input` reflection.
+ */
+export declare function createOrdered(entries: [string, RillValue, RillValue?][]): RillOrdered;
+/** Create tuple from entries array (positional, preserves order) */
+export declare function createTuple(entries: RillValue[]): RillTuple;
+/**
+ * Create vector from Float32Array with model name.
+ * @throws {RuntimeError} RILL-R074 if data.length is 0 (zero-dimension vectors not allowed)
+ */
+export declare function createVector(data: Float32Array, model: string): RillVector;
+/**
+ * Create an empty collection value matching the given TypeStructure.
+ * Assumes the type is dict, ordered, or tuple.
+ */
+export declare function emptyForType(type: TypeStructure): RillValue;
+/**
+ * Create a RillStream from an AsyncIterable of chunks and a resolve function.
+ *
+ * The stream is a linked-list of steps. Each `.next` call advances to the
+ * next chunk. Once exhausted, `done` becomes true and re-iteration throws
+ * RILL-R002. The `resolve` function is called after chunk exhaustion (or on
+ * direct invocation) and caches its result for idempotent access.
+ *
+ * @throws {RuntimeError} RILL-R003 if chunks is not an AsyncIterable
+ * @throws {RuntimeError} RILL-R003 if resolve is not a function
+ */
+export declare function createRillStream(options: {
+    chunks: AsyncIterable<RillValue>;
+    resolve: () => Promise<RillValue>;
+    dispose?: (() => void) | undefined;
+    chunkType?: TypeStructure | undefined;
+    retType?: TypeStructure | undefined;
+}): RillStream;
+/**
+ * Copy a RillValue.
+ * Primitives and immutable compound values return the same reference.
+ * Mutable values (list, dict) copy recursively.
+ * Iterators return the same reference (not meaningfully copyable).
+ */
+export declare function copyValue(value: RillValue): RillValue;