@rcrsr/rill 0.14.0 → 0.16.0

package/dist/parser/parser-types.js

@@ -5,7 +5,7 @@
  * @internal
  */
 import { TOKEN_TYPES, ParseError, } from '../types.js';
-import { check, advance, expect, current, peek, } from './state.js';
+import { check, advance, expect, current, peek, skipNewlines, } from './state.js';
 import { VALID_TYPE_NAMES, parseTypeName } from './helpers.js';
 /**
  * Parse a type reference from the current position in the token stream.
@@ -33,7 +33,7 @@ import { VALID_TYPE_NAMES, parseTypeName } from './helpers.js';
  * @internal
  */
 export function parseTypeRef(state, opts) {
-    const first = parseSingleType(state);
+    const first = parseSingleType(state, opts);
     // Union accumulation: collect additional members after each "|"
     if (!check(state, TOKEN_TYPES.PIPE_BAR)) {
         return first;
@@ -75,7 +75,7 @@ export function parseTypeRef(state, opts) {
             throw new ParseError('RILL-P011', "Expected type name after '|'", current(state).span.start);
         }
         advance(state); // consume "|"
-        const next = parseSingleType(state);
+        const next = parseSingleType(state, opts);
         // Flatten nested unions
         if (next.kind === 'union') {
             members.push(...next.members);
@@ -97,7 +97,7 @@ export function parseTypeRef(state, opts) {
  * Grammar: `single-type = "$" identifier | type-name [ "(" type-ref-arg-list ")" ]`
  * @internal
  */
-function parseSingleType(state) {
+function parseSingleType(state, opts) {
     if (check(state, TOKEN_TYPES.DOLLAR)) {
         advance(state); // consume $
         const nameToken = expect(state, TOKEN_TYPES.IDENTIFIER, 'Expected variable name after $');
@@ -109,7 +109,39 @@ function parseSingleType(state) {
         return { kind: 'static', typeName };
     }
     advance(state); // consume "("
+    const args = parseFieldArgList(state, opts?.parseLiteral ? { parseLiteral: opts.parseLiteral } : undefined);
+    advance(state); // consume ")"
+    return { kind: 'static', typeName, args };
+}
+// ============================================================
+// FIELD ARG LIST PARSING
+// ============================================================
+/**
+ * Parse a comma-separated list of field arguments between `(` and `)`.
+ *
+ * Caller has already consumed the opening `(`. This function parses zero
+ * or more arguments up to the closing `)` but does NOT consume it.
+ *
+ * Supports:
+ * - Named args:      `name: type`  → `{ name, value }`
+ * - Positional args: `type`        → `{ value }`
+ * - Default values:  `= literal`   → `{ ..., defaultValue }` (when parseLiteral provided)
+ * - Union types in value position via `parseTypeRef`
+ * - Trailing commas before `)`
+ *
+ * Named arg detection: IDENTIFIER followed by COLON lookahead.
+ *
+ * @param state - Parser state (positioned after opening paren)
+ * @param opts  - Optional parseLiteral callback for default value support
+ *
+ * @throws ParseError RILL-P014 if token after arg is not `,` or `)`  (EC-1)
+ * @throws ParseError RILL-P014 if missing closing `)`                (EC-2)
+ *
+ * @internal
+ */
+export function parseFieldArgList(state, opts) {
     const args = [];
+    skipNewlines(state);
     // Parse arg list: allow empty "()" and trailing commas
     while (!check(state, TOKEN_TYPES.RPAREN)) {
         // Check for named arg: identifier ":" type-ref
@@ -120,28 +152,47 @@ function parseSingleType(state) {
             const name = tok.value;
             advance(state); // consume identifier
             advance(state); // consume ":"
-            const ref = parseTypeRef(state);
-            args.push({ name, ref });
+            skipNewlines(state);
+            const typeRefOpts = opts?.parseLiteral
+                ? { parseLiteral: opts.parseLiteral }
+                : undefined;
+            const value = parseTypeRef(state, typeRefOpts);
+            const arg = { name, value };
+            if (opts?.parseLiteral && check(state, TOKEN_TYPES.ASSIGN)) {
+                advance(state); // consume =
+                skipNewlines(state);
+                arg.defaultValue = opts.parseLiteral();
+            }
+            args.push(arg);
         }
         else {
             // Positional arg: type-ref
-            const ref = parseTypeRef(state);
-            args.push({ ref });
+            const typeRefOpts = opts?.parseLiteral
+                ? { parseLiteral: opts.parseLiteral }
+                : undefined;
+            const value = parseTypeRef(state, typeRefOpts);
+            const arg = { value };
+            if (opts?.parseLiteral && check(state, TOKEN_TYPES.ASSIGN)) {
+                advance(state); // consume =
+                skipNewlines(state);
+                arg.defaultValue = opts.parseLiteral();
+            }
+            args.push(arg);
         }
+        skipNewlines(state);
         // Consume trailing or separating comma
         if (check(state, TOKEN_TYPES.COMMA)) {
             advance(state);
+            skipNewlines(state);
         }
         else if (!check(state, TOKEN_TYPES.RPAREN)) {
-            // Neither comma nor closing paren — malformed arg list (EC-14)
+            // Neither comma nor closing paren — malformed arg list (EC-1)
             throw new ParseError('RILL-P014', "Expected ',' or ')' in type argument list", current(state).span.start);
         }
     }
-    // Consume ")"
+    // Verify closing ")" is present (EC-2)
     if (!check(state, TOKEN_TYPES.RPAREN)) {
         throw new ParseError('RILL-P014', "Expected ')' to close type argument list", current(state).span.start);
     }
-    advance(state); // consume ")"
-    return { kind: 'static', typeName, args };
+    return args;
 }
-//# sourceMappingURL=parser-types.js.map

package/dist/parser/parser-use.d.ts

@@ -8,4 +8,3 @@ declare module './parser.js' {
         parseUseExpr(): UseExprNode;
     }
 }
-//# sourceMappingURL=parser-use.d.ts.map

package/dist/parser/parser-use.js

@@ -93,4 +93,3 @@ Parser.prototype.parseUseExpr = function () {
         span: makeSpan(start, current(this.state).span.end),
     };
 };
-//# sourceMappingURL=parser-use.js.map

package/dist/parser/parser-variables.d.ts

@@ -17,4 +17,3 @@ declare module './parser.js' {
         parseDefaultValue(): BodyNode;
     }
 }
-//# sourceMappingURL=parser-variables.d.ts.map

package/dist/parser/parser-variables.js

@@ -175,4 +175,3 @@ Parser.prototype.parseDefaultValue = function () {
     }
     return this.parsePipeChain();
 };
-//# sourceMappingURL=parser-variables.js.map

package/dist/parser/parser.d.ts

@@ -46,4 +46,3 @@ export declare class Parser {
      */
     get errors(): ParseError[];
 }
-//# sourceMappingURL=parser.d.ts.map

package/dist/parser/parser.js

@@ -51,4 +51,3 @@ export class Parser {
         return this.state.errors;
     }
 }
-//# sourceMappingURL=parser.js.map

package/dist/parser/state.d.ts

@@ -43,4 +43,3 @@ export declare function skipNewlines(state: ParserState): void;
 export declare function skipNewlinesIfFollowedBy(state: ParserState, tokenType: string): boolean;
 /** @internal */
 export declare function makeSpan(start: SourceLocation, end: SourceLocation): SourceSpan;
-//# sourceMappingURL=state.d.ts.map

package/dist/parser/state.js

@@ -150,4 +150,3 @@ function generateHint(expectedType, actualToken) {
 export function makeSpan(start, end) {
     return { start, end };
 }
-//# sourceMappingURL=state.js.map

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

@@ -17,7 +17,7 @@
  *
  * [ASSUMPTION] validateDefaultValueType _functionName Parameter
  * - Parameter accepted but unused (prefixed with _ to satisfy eslint)
- * - Kept for API consistency with validateCallableArgs signature
+ * - Kept for API consistency with marshalArgs signature
  */
 import type { BodyNode, SourceLocation } from '../../types.js';
 import type { RillType, RillTypeValue, RillValue } from './values.js';
@@ -31,7 +31,7 @@ interface RuntimeContextLike {
  * Callable function signature.
  * Used for both host-provided functions and runtime callables.
  */
-export type CallableFn = (args: RillValue[], ctx: RuntimeContextLike, location?: SourceLocation) => RillValue | Promise<RillValue>;
+export type CallableFn = (args: Record<string, RillValue>, ctx: RuntimeContextLike, location?: SourceLocation) => RillValue | Promise<RillValue>;
 /**
  * Unified parameter definition for all callable types (script closures and host functions).
  *
@@ -154,19 +154,46 @@ export declare function paramsToStructuralType(params: readonly RillParam[]): Ri
  */
 export declare function validateDefaultValueType(param: RillParam, _functionName: string): void;
 /**
- * Validate arguments against RillParam[] using structural type matching.
+ * Options for marshalArgs error reporting.
+ */
+export interface MarshalOptions {
+    /** Function name included in error messages */
+    readonly functionName: string;
+    /** Source location for error reporting */
+    readonly location: SourceLocation | undefined;
+}
+/**
+ * Hydrate missing dict/ordered field-level defaults into a value.
+ *
+ * When a param has type `dict(a: string = "x", b: number)` and the caller
+ * passes `[b: 2]`, this fills in `a` with its default `"x"`. Fields without
+ * defaults are left absent so Stage 3 catches them with RILL-R001.
+ *
+ * Pure function: no class context, no evaluator, no side effects.
+ */
+export declare function hydrateFieldDefaults(value: RillValue, type: RillType): RillValue;
+/**
+ * Unified marshaling entry point for all 3 invocation paths.
+ *
+ * Builds a named argument map from positional args, hydrates defaults,
+ * type-checks each field, and returns a Record<string, RillValue>.
+ *
+ * Stages:
+ * 1. Excess args check (RILL-R045)
+ * 2. Default hydration + missing required check (RILL-R044)
+ * 2.5. Dict/ordered field-level default hydration
+ * 3. Type check per field (RILL-R001)
  *
- * Single validation path for all callable kinds (host, built-in, script).
- * Uses structuralTypeMatches for type checking when param.type is defined.
- * Skips type check when param.type is undefined (any-typed).
- * Applies defaultValue in-place on the args array before validation.
+ * Preconditions (enforced by caller):
+ * - args contains already-evaluated RillValue[]
+ * - pipe value already inserted as first element by caller
+ * - boundDict already prepended as first element by caller
+ * - params is defined (caller skips marshalArgs for untyped callables)
  *
- * @param args - Arguments array (mutated in-place when defaults applied)
+ * @param args - Positional arguments (already evaluated)
  * @param params - Parameter definitions
- * @param functionName - Function name for error messages
- * @param location - Source location for error reporting
- * @throws RuntimeError with RILL-R001 on validation failure
+ * @param options - Error context: functionName and location
+ * @returns Named argument map keyed by param name
  */
-export declare function validateCallableArgs(args: RillValue[], params: readonly RillParam[], functionName: string, location?: SourceLocation): void;
+export declare function marshalArgs(args: RillValue[], params: readonly RillParam[], options?: MarshalOptions): Record<string, RillValue>;
 export {};
-//# sourceMappingURL=callable.d.ts.map

package/dist/runtime/core/callable.js

@@ -17,11 +17,11 @@
  *
  * [ASSUMPTION] validateDefaultValueType _functionName Parameter
  * - Parameter accepted but unused (prefixed with _ to satisfy eslint)
- * - Kept for API consistency with validateCallableArgs signature
+ * - Kept for API consistency with marshalArgs signature
  */
 import { RuntimeError } from '../../types.js';
 import { astEquals } from './equals.js';
-import { formatValue, formatStructuralType, inferType, isTuple, structuralTypeEquals, structuralTypeMatches, anyTypeValue, } from './values.js';
+import { formatValue, formatStructuralType, inferType, isOrdered, createOrdered, deepCopyRillValue, isTuple, paramToFieldDef, structuralTypeEquals, structuralTypeMatches, anyTypeValue, hasCollectionFields, emptyForType, } from './values.js';
 /** Type guard for any callable */
 export function isCallable(value) {
     return (typeof value === 'object' &&
@@ -159,10 +159,7 @@ export function callableEquals(a, b, valueEquals = (x, y) => formatValue(x) ===
  * @returns Frozen RillType with closure variant
  */
 export function paramsToStructuralType(params) {
-    const closureParams = params.map((param) => {
-        const paramType = param.type ?? { type: 'any' };
-        return [param.name, paramType];
-    });
+    const closureParams = params.map((param) => paramToFieldDef(param.name, param.type ?? { type: 'any' }, param.defaultValue));
     return Object.freeze({
         type: 'closure',
         params: closureParams,
@@ -192,54 +189,162 @@ export function validateDefaultValueType(param, _functionName) {
     }
 }
 /**
- * Validate arguments against RillParam[] using structural type matching.
+ * Hydrate missing dict/ordered field-level defaults into a value.
  *
- * Single validation path for all callable kinds (host, built-in, script).
- * Uses structuralTypeMatches for type checking when param.type is defined.
- * Skips type check when param.type is undefined (any-typed).
- * Applies defaultValue in-place on the args array before validation.
+ * When a param has type `dict(a: string = "x", b: number)` and the caller
+ * passes `[b: 2]`, this fills in `a` with its default `"x"`. Fields without
+ * defaults are left absent so Stage 3 catches them with RILL-R001.
  *
- * @param args - Arguments array (mutated in-place when defaults applied)
+ * Pure function: no class context, no evaluator, no side effects.
+ */
+export function hydrateFieldDefaults(value, type) {
+    if (type.type === 'dict' && type.fields && isDict(value)) {
+        const dictValue = value;
+        // Seed with all input entries so extra keys survive (structural match allows extras)
+        const result = { ...dictValue };
+        for (const [fieldName, fieldDef] of Object.entries(type.fields)) {
+            if (fieldName in dictValue) {
+                result[fieldName] = hydrateFieldDefaults(dictValue[fieldName], fieldDef.type);
+            }
+            else if (fieldDef.defaultValue !== undefined) {
+                result[fieldName] = hydrateFieldDefaults(deepCopyRillValue(fieldDef.defaultValue), fieldDef.type);
+            }
+            else if (hasCollectionFields(fieldDef.type)) {
+                result[fieldName] = hydrateFieldDefaults(emptyForType(fieldDef.type), fieldDef.type);
+            }
+            // Missing without default and not collection: leave absent for Stage 3
+        }
+        return result;
+    }
+    if (type.type === 'ordered' && type.fields && isOrdered(value)) {
+        const lookup = new Map(value.entries.map(([k, v]) => [k, v]));
+        const fieldNames = new Set(type.fields.map((f) => f.name ?? ''));
+        const resultEntries = [];
+        for (const field of type.fields) {
+            const name = field.name ?? '';
+            if (lookup.has(name)) {
+                resultEntries.push([
+                    name,
+                    hydrateFieldDefaults(lookup.get(name), field.type),
+                ]);
+            }
+            else if (field.defaultValue !== undefined) {
+                resultEntries.push([
+                    name,
+                    hydrateFieldDefaults(deepCopyRillValue(field.defaultValue), field.type),
+                ]);
+            }
+            else if (hasCollectionFields(field.type)) {
+                resultEntries.push([
+                    name,
+                    hydrateFieldDefaults(emptyForType(field.type), field.type),
+                ]);
+            }
+            // Missing without default and not collection: leave absent for Stage 3
+        }
+        // Append extra entries not declared in type.fields (structural match allows extras)
+        for (const [k, v] of value.entries) {
+            if (!fieldNames.has(k)) {
+                resultEntries.push([k, v]);
+            }
+        }
+        return createOrdered(resultEntries);
+    }
+    if (type.type === 'tuple' && type.elements && isTuple(value)) {
+        const elements = type.elements;
+        const entries = value.entries;
+        // All fields present: recurse into nested types for present positions
+        if (entries.length >= elements.length) {
+            const resultEntries = elements.map((el, i) => hydrateFieldDefaults(entries[i], el.type));
+            // Preserve any extra trailing entries beyond the type definition
+            for (let i = elements.length; i < entries.length; i++) {
+                resultEntries.push(entries[i]);
+            }
+            return { __rill_tuple: true, entries: resultEntries };
+        }
+        // Value shorter: fill missing trailing positions with defaults
+        const resultEntries = [];
+        for (let i = 0; i < elements.length; i++) {
+            const el = elements[i];
+            if (i < entries.length) {
+                resultEntries.push(hydrateFieldDefaults(entries[i], el.type));
+            }
+            else if (el.defaultValue !== undefined) {
+                resultEntries.push(hydrateFieldDefaults(deepCopyRillValue(el.defaultValue), el.type));
+            }
+            else if (hasCollectionFields(el.type)) {
+                resultEntries.push(hydrateFieldDefaults(emptyForType(el.type), el.type));
+            }
+            // Missing without default and not collection: leave absent (shorter tuple) for Stage 3
+        }
+        return { __rill_tuple: true, entries: resultEntries };
+    }
+    return value;
+}
+/**
+ * Unified marshaling entry point for all 3 invocation paths.
+ *
+ * Builds a named argument map from positional args, hydrates defaults,
+ * type-checks each field, and returns a Record<string, RillValue>.
+ *
+ * Stages:
+ * 1. Excess args check (RILL-R045)
+ * 2. Default hydration + missing required check (RILL-R044)
+ * 2.5. Dict/ordered field-level default hydration
+ * 3. Type check per field (RILL-R001)
+ *
+ * Preconditions (enforced by caller):
+ * - args contains already-evaluated RillValue[]
+ * - pipe value already inserted as first element by caller
+ * - boundDict already prepended as first element by caller
+ * - params is defined (caller skips marshalArgs for untyped callables)
+ *
+ * @param args - Positional arguments (already evaluated)
  * @param params - Parameter definitions
- * @param functionName - Function name for error messages
- * @param location - Source location for error reporting
- * @throws RuntimeError with RILL-R001 on validation failure
+ * @param options - Error context: functionName and location
+ * @returns Named argument map keyed by param name
  */
-export function validateCallableArgs(args, params, functionName, location) {
-    // Check for excess arguments
+export function marshalArgs(args, params, options) {
+    const functionName = options?.functionName ?? '<anonymous>';
+    const location = options?.location;
+    // Stage 1: Excess args check
     if (args.length > params.length) {
-        throw new RuntimeError('RILL-R001', `Function '${functionName}' expects ${params.length} arguments, got ${args.length}`, location, {
+        throw new RuntimeError('RILL-R045', `Function expects ${params.length} arguments, got ${args.length}`, location, {
             functionName,
             expectedCount: params.length,
             actualCount: args.length,
         });
     }
-    // Validate each parameter
+    const result = {};
+    // Stage 2 + 3: Hydrate defaults, check required, type-check
     for (let i = 0; i < params.length; i++) {
         const param = params[i];
         if (param === undefined)
             continue;
-        let arg = args[i];
-        // Apply defaultValue in-place for missing arguments
-        if (arg === undefined) {
+        let value = args[i];
+        // Hydrate default when no positional arg was supplied
+        if (value === undefined) {
             if (param.defaultValue !== undefined) {
-                arg = param.defaultValue;
-                args[i] = arg;
+                value = param.defaultValue;
             }
             else {
-                // Missing required argument
-                throw new RuntimeError('RILL-R001', `Missing required argument '${param.name}' for function '${functionName}'`, location, {
+                // Stage 2: Missing required parameter
+                throw new RuntimeError('RILL-R044', `Missing argument for parameter '${param.name}'`, location, {
                     functionName,
                     paramName: param.name,
                 });
             }
         }
-        // Type check via structuralTypeMatches when param.type is defined
+        // Stage 2.5: Hydrate dict/ordered field-level defaults
+        if (param.type !== undefined) {
+            value = hydrateFieldDefaults(value, param.type);
+        }
+        // Stage 3: Type check when param.type is defined
         if (param.type !== undefined) {
-            if (!structuralTypeMatches(arg, param.type)) {
+            if (!structuralTypeMatches(value, param.type)) {
                 const expectedType = formatStructuralType(param.type);
-                const actualType = inferType(arg);
-                throw new RuntimeError('RILL-R001', `Type mismatch in ${functionName}: parameter '${param.name}' expects ${expectedType}, got ${actualType}`, location, {
+                const actualType = inferType(value);
+                throw new RuntimeError('RILL-R001', `Parameter type mismatch: ${param.name} expects ${expectedType}, got ${actualType}`, location, {
                     functionName,
                     paramName: param.name,
                     expectedType,
@@ -247,6 +352,7 @@ export function validateCallableArgs(args, params, functionName, location) {
                 });
             }
         }
+        result[param.name] = value;
     }
+    return result;
 }
-//# sourceMappingURL=callable.js.map

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

@@ -62,4 +62,3 @@ export declare function pushCallFrame(ctx: RuntimeContext, frame: import('../../
  * Pop frame from call stack after function/closure returns.
  */
 export declare function popCallFrame(ctx: RuntimeContext): void;
-//# sourceMappingURL=context.d.ts.map

package/dist/runtime/core/context.js

@@ -14,7 +14,7 @@ import { callable, validateDefaultValueType, } from './callable.js';
 // chain: pipe form sends 1 arg when signature declares 2 (pipeValue is the first).
 const UNTYPED_BUILTINS = new Set(['log', 'chain']);
 // Built-in methods that do their own internal arg validation with specific error
-// messages expected by protected language tests. Generic validateCallableArgs
+// messages expected by protected language tests. Generic marshalArgs
 // must not fire before the method body's own check.
 export const UNVALIDATED_METHOD_PARAMS = new Set(['has', 'has_any', 'has_all']);
 // Built-in methods that perform their own receiver type checking with specific
@@ -319,4 +319,3 @@ export function popCallFrame(ctx) {
         ctx.callStack.pop();
     }
 }
-//# sourceMappingURL=context.js.map

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

@@ -6,4 +6,3 @@
  */
 import type { ASTNode } from '../../types.js';
 export declare function astEquals(a: ASTNode, b: ASTNode): boolean;
-//# sourceMappingURL=equals.d.ts.map

package/dist/runtime/core/equals.js

@@ -544,7 +544,7 @@ function typeRefStaticEquals(a, b) {
     return typeRefArgListEquals(a.args, b.args);
 }
 /**
- * Compare two optional TypeRefArg arrays for structural equality.
+ * Compare two optional FieldArg arrays for structural equality.
  */
 function typeRefArgListEquals(a, b) {
     const aArgs = a ?? [];
@@ -556,7 +556,9 @@ function typeRefArgListEquals(a, b) {
         const bArg = bArgs[i];
         if (aArg.name !== bArg.name)
             return false;
-        if (!typeRefEquals(aArg.ref, bArg.ref))
+        if (!typeRefEquals(aArg.value, bArg.value))
+            return false;
+        if (!literalNodeEquals(aArg.defaultValue, bArg.defaultValue))
             return false;
     }
     return true;
@@ -578,4 +580,34 @@ function typeRefEquals(a, b) {
     }
     return false;
 }
-//# sourceMappingURL=equals.js.map
+/**
+ * Compare two optional LiteralNode values for structural equality.
+ * Both-undefined returns true. One-undefined returns false.
+ * Complex nodes (ListLiteral, Dict, Closure) return false defensively.
+ */
+function literalNodeEquals(a, b) {
+    if (a === undefined && b === undefined)
+        return true;
+    if (a === undefined || b === undefined)
+        return false;
+    if (a.type !== b.type)
+        return false;
+    switch (a.type) {
+        case 'NumberLiteral':
+            return a.value === b.value;
+        case 'BoolLiteral':
+            return a.value === b.value;
+        case 'StringLiteral': {
+            const bStr = b;
+            if (a.parts.length !== 1 || bStr.parts.length !== 1)
+                return false;
+            return a.parts[0] === bStr.parts[0];
+        }
+        case 'ListLiteral':
+        case 'Dict':
+        case 'Closure':
+            return false;
+        default:
+            return false;
+    }
+}

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

@@ -62,4 +62,3 @@ export declare class EvaluatorBase {
      */
     protected accessDictField(value: RillValue, field: string, location?: SourceLocation, allowMissing?: boolean): Promise<RillValue>;
 }
-//# sourceMappingURL=base.d.ts.map

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

@@ -112,4 +112,3 @@ export class EvaluatorBase {
         return dictValue;
     }
 }
-//# sourceMappingURL=base.js.map

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

@@ -122,4 +122,3 @@ export type Evaluator = InstanceType<typeof Evaluator>;
  * @internal
  */
 export declare function getEvaluator(ctx: RuntimeContext): InstanceType<typeof Evaluator>;
-//# sourceMappingURL=evaluator.d.ts.map

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

@@ -151,4 +151,3 @@ export function getEvaluator(ctx) {
     }
     return evaluator;
 }
-//# sourceMappingURL=evaluator.js.map

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

@@ -69,4 +69,3 @@ export declare function getAnnotation(ctx: RuntimeContext, key: string): RillVal
  * @param location - Optional call site location for error reporting
  */
 export declare function invokeCallable(callable: RillCallable, args: RillValue[], ctx: RuntimeContext, location?: SourceLocation): Promise<RillValue>;
-//# sourceMappingURL=index.d.ts.map

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

@@ -117,4 +117,3 @@ export async function invokeCallable(callable, args, ctx, location) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return evaluator.invokeCallable(callable, args, location);
 }
-//# sourceMappingURL=index.js.map

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

@@ -16,4 +16,3 @@
  * @internal
  */
 export declare const AnnotationsMixin: any;
-//# sourceMappingURL=annotations.d.ts.map

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

@@ -149,4 +149,3 @@ function createAnnotationsMixin(Base) {
 // TypeScript can't generate declarations for functions returning classes with protected members
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const AnnotationsMixin = createAnnotationsMixin;
-//# sourceMappingURL=annotations.js.map

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

@@ -42,4 +42,3 @@
  * @internal
  */
 export declare const ClosuresMixin: any;
-//# sourceMappingURL=closures.d.ts.map