@rcrsr/rill 0.15.0 → 0.17.0

package/dist/runtime/core/eval/mixins/use.d.ts

@@ -22,4 +22,3 @@
  * @internal
  */
 export declare const UseMixin: any;
-//# sourceMappingURL=use.d.ts.map

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

@@ -179,4 +179,3 @@ function parseSchemeString(value, node) {
 // TypeScript can't generate declarations for functions returning classes with protected members
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const UseMixin = createUseMixin;
-//# sourceMappingURL=use.js.map

package/dist/runtime/core/eval/mixins/variables.d.ts

@@ -31,4 +31,3 @@
  * @internal
  */
 export declare const VariablesMixin: any;
-//# sourceMappingURL=variables.d.ts.map

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

@@ -31,7 +31,7 @@
  * @internal
  */
 import { RuntimeError } from '../../../../types.js';
-import { formatStructuralType, inferType, isTypeValue, structuralTypeMatches, } from '../../values.js';
+import { formatStructure, inferType, isTypeValue, structureMatches, } from '../../values.js';
 import { getVariable, hasVariable } from '../../context.js';
 import { isDict, isCallable } from '../../callable.js';
 /**
@@ -69,8 +69,8 @@ function createVariablesMixin(Base) {
             if (explicitType !== undefined) {
                 if (typeof explicitType === 'object') {
                     // Structural type check
-                    if (!structuralTypeMatches(value, explicitType)) {
-                        const expectedLabel = formatStructuralType(explicitType);
+                    if (!structureMatches(value, explicitType)) {
+                        const expectedLabel = formatStructure(explicitType);
                         throw new RuntimeError('RILL-R001', `Type mismatch: cannot assign ${valueType} to $${name}:${expectedLabel}`, location, {
                             variableName: name,
                             expectedType: expectedLabel,
@@ -98,8 +98,8 @@ function createVariablesMixin(Base) {
             if (lockedType !== undefined && lockedType !== 'any') {
                 if (typeof lockedType === 'object') {
                     // Structural locked type — validate full shape
-                    if (!structuralTypeMatches(value, lockedType)) {
-                        const expectedLabel = formatStructuralType(lockedType);
+                    if (!structureMatches(value, lockedType)) {
+                        const expectedLabel = formatStructure(lockedType);
                         throw new RuntimeError('RILL-R001', `Type mismatch: cannot assign ${valueType} to $${name} (locked as ${expectedLabel})`, location, {
                             variableName: name,
                             expectedType: expectedLabel,
@@ -120,7 +120,9 @@ function createVariablesMixin(Base) {
             if (!this.ctx.variableTypes.has(name)) {
                 // Store structural type (object) directly so re-assignment checks
                 // validate the full shape. Fall back to valueType when no annotation.
-                const lockType = explicitType !== undefined ? explicitType : valueType;
+                const lockType = explicitType !== undefined
+                    ? explicitType
+                    : valueType;
                 this.ctx.variableTypes.set(name, lockType);
             }
         }
@@ -260,7 +262,7 @@ function createVariablesMixin(Base) {
                             value = value.typeName;
                         }
                         else if (field === 'signature') {
-                            value = formatStructuralType(value.structure);
+                            value = formatStructure(value.structure);
                         }
                         else {
                             throw new RuntimeError('RILL-R003', `Type value has no property "${field}"`, this.getNodeLocation(node));
@@ -317,12 +319,12 @@ function createVariablesMixin(Base) {
                 const finalAccess = node.existenceCheck.finalAccess;
                 const typeRef = node.existenceCheck.typeRef;
                 // Helper: check type match using structural resolution (EC-4: mismatch returns false)
-                const matchesType = (fieldValue) => {
+                const matchesType = async (fieldValue) => {
                     if (typeRef === null)
                         return true;
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    const resolved = this.resolveTypeRef(typeRef, (name) => getVariable(this.ctx, name));
-                    return structuralTypeMatches(fieldValue, resolved.structure);
+                    const resolved = await this.resolveTypeRef(typeRef, (name) => getVariable(this.ctx, name));
+                    return structureMatches(fieldValue, resolved.structure);
                 };
                 if (finalAccess.kind === 'literal') {
                     // Check if literal field exists in dict
@@ -331,7 +333,7 @@ function createVariablesMixin(Base) {
                         const exists = fieldValue !== undefined && fieldValue !== null;
                         // If type-qualified check, verify type matches
                         if (exists && typeRef !== null) {
-                            return matchesType(fieldValue);
+                            return await matchesType(fieldValue);
                         }
                         return exists;
                     }
@@ -361,7 +363,7 @@ function createVariablesMixin(Base) {
                         const exists = fieldValue !== undefined && fieldValue !== null;
                         // If type-qualified check, verify type matches
                         if (exists && typeRef !== null) {
-                            return matchesType(fieldValue);
+                            return await matchesType(fieldValue);
                         }
                         return exists;
                     }
@@ -388,7 +390,7 @@ function createVariablesMixin(Base) {
                         const exists = fieldValue !== undefined && fieldValue !== null;
                         // If type-qualified check, verify type matches
                         if (exists && typeRef !== null) {
-                            return matchesType(fieldValue);
+                            return await matchesType(fieldValue);
                         }
                         return exists;
                     }
@@ -552,7 +554,7 @@ function createVariablesMixin(Base) {
             if (node.typeRef !== null) {
                 // Resolve TypeRef and validate against the declared type
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const resolved = this.resolveTypeRef(node.typeRef, (name) => getVariable(this.ctx, name));
+                const resolved = await this.resolveTypeRef(node.typeRef, (name) => getVariable(this.ctx, name));
                 this.setVariable(node.name, input, resolved.structure, node.span.start);
             }
             else {
@@ -578,4 +580,3 @@ function createVariablesMixin(Base) {
 // TypeScript can't generate declarations for functions returning classes with protected members
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const VariablesMixin = createVariablesMixin;
-//# sourceMappingURL=variables.js.map

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

@@ -38,4 +38,3 @@ export type EvaluatorConstructor<TBase extends EvaluatorBase = EvaluatorBase> =
  * ```
  */
 export type Mixin<TBase extends EvaluatorBase = EvaluatorBase, TExtension extends TBase = TBase> = (Base: EvaluatorConstructor<TBase>) => EvaluatorConstructor<TExtension>;
-//# sourceMappingURL=types.d.ts.map

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

@@ -7,4 +7,3 @@
  * @internal
  */
 export {};
-//# sourceMappingURL=types.js.map

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

@@ -23,4 +23,3 @@ export declare function execute(script: ScriptNode, context: RuntimeContext): Pr
  * @returns A stepper for step-by-step execution
  */
 export declare function createStepper(script: ScriptNode, context: RuntimeContext): ExecutionStepper;
-//# sourceMappingURL=execute.d.ts.map

package/dist/runtime/core/execute.js

@@ -171,4 +171,3 @@ function isRecoveryErrorNode(stmt) {
 function getInnerStatement(stmt) {
     return stmt.type === 'AnnotatedStatement' ? stmt.statement : stmt;
 }
-//# sourceMappingURL=execute.js.map

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

@@ -8,7 +8,7 @@
  * @internal
  */
 import type { SourceLocation } from '../../types.js';
-import type { RillFieldType, RillType } from './values.js';
+import type { RillFieldDef, TypeStructure } from './values.js';
 /**
  * Field descriptor — carries field name and structural type when accessing a
  * dict-kind RillType field.
@@ -16,14 +16,13 @@ import type { RillFieldType, RillType } from './values.js';
 export interface RillFieldDescriptor {
     readonly __rill_field_descriptor: true;
     readonly fieldName: string;
-    readonly fieldType: RillFieldType;
+    readonly fieldType: RillFieldDef;
 }
 /**
  * Build a frozen RillFieldDescriptor for the given field in a structural dict type.
  *
  * 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;
-//# sourceMappingURL=field-descriptor.d.ts.map

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);
     }
@@ -24,4 +25,3 @@ export function buildFieldDescriptor(structuralType, fieldName, location) {
         fieldType,
     });
 }
-//# sourceMappingURL=field-descriptor.js.map

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

@@ -101,4 +101,3 @@ export declare function getDocumentationCoverage(ctx: RuntimeContext): Documenta
  * @returns Language reference text
  */
 export declare function getLanguageReference(): string;
-//# sourceMappingURL=introspection.d.ts.map

package/dist/runtime/core/introspection.js

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

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

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

package/dist/runtime/core/markers.js

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

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

@@ -51,4 +51,3 @@ export declare const moduleResolver: SchemeResolver;
  */
 export declare const contextResolver: SchemeResolver;
 export declare const extResolver: SchemeResolver;
-//# sourceMappingURL=resolvers.d.ts.map

package/dist/runtime/core/resolvers.js

@@ -119,4 +119,3 @@ export const extResolver = (resource, config) => {
     }
     return { kind: 'value', value };
 };
-//# sourceMappingURL=resolvers.js.map

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

@@ -16,4 +16,3 @@ export declare class ReturnSignal extends Error {
     readonly value: RillValue;
     constructor(value: RillValue);
 }
-//# sourceMappingURL=signals.d.ts.map

package/dist/runtime/core/signals.js

@@ -23,4 +23,3 @@ export class ReturnSignal extends Error {
         this.name = 'ReturnSignal';
     }
 }
-//# sourceMappingURL=signals.js.map

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

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