@opencode/codemode 0.0.0-beta-19296 → 0.0.0-beta-19378

package/dist/interpreter/methods.js

@@ -1,29 +1,15 @@
 import { Effect } from "effect";
-import { CodeModeFunction, CodeModeGenerator, CoercionFunction, ErrorConstructorReference, GlobalMethodReference, GlobalNamespace, IntrinsicReference, InterpreterRuntimeError, JsonMethodReference, PromiseCapabilityFunction, PromiseNamespace, UriFunction, } from "./model.js";
-import { containsOpaqueReference, isRuntimeReference, rejectCircularInsertion, typeofValue } from "./references.js";
-import { isBlockedMember } from "../tool-runtime.js";
-import { CodeModeDate, CodeModeMap, CodeModePromise, CodeModeRegExp, CodeModeSet, CodeModeURL, CodeModeURLSearchParams, isCodeModeValue, } from "../values.js";
-import { dateSetterArgumentCount, invokeDateMethod, invokeDateStatic } from "../stdlib/date.js";
-import { invokeMathMethod } from "../stdlib/math.js";
-import { invokeNumberMethod, invokeNumberStatic } from "../stdlib/number.js";
-import { invokeObjectMethod } from "../stdlib/object.js";
-import { invokeRegExpMethod, invokeRegExpStatic, matchToValue, toHostRegex } from "../stdlib/regexp.js";
-import { invokeStringStatic } from "../stdlib/string.js";
-import { invokeURLMethod, invokeURLStatic, uriArgument } from "../stdlib/url.js";
-import { boundedData, coerceToNumber, coerceToString, errorBrandName } from "../stdlib/value.js";
-import { preserveConsumerError } from "./iterator.js";
-export const isSupportedCallback = (value) => value instanceof CodeModeFunction ||
-    value instanceof CoercionFunction ||
-    value instanceof UriFunction ||
-    value instanceof PromiseCapabilityFunction ||
-    value instanceof GlobalMethodReference ||
-    value instanceof JsonMethodReference ||
-    value instanceof IntrinsicReference ||
-    value instanceof ErrorConstructorReference ||
-    // Callable namespaces dispatch like JS: Array/Object/Date/RegExp construct,
-    // new-requiring constructors throw a TypeError. Math/JSON/console stay non-callable.
-    (value instanceof GlobalNamespace && typeofValue(value) === "function") ||
-    value instanceof PromiseNamespace;
+import { isBlockedMember, toProgram } from "../data.js";
+import { dateSetterArgumentCount, invokeDateMethod } from "../stdlib/date.js";
+import { invokeNumberMethod } from "../stdlib/number.js";
+import { invokeRegExpMethod, matchToValue, toHostRegex } from "../stdlib/regexp.js";
+import { invokeURLMethod, uriArgument } from "../stdlib/url.js";
+import { coerceToNumber, coerceToString, errorBrandName } from "../stdlib/value.js";
+import { compareText } from "../tool-runtime.js";
+import { Values } from "../values.js";
+import { IntrinsicReference, InterpreterRuntimeError } from "./model.js";
+import { containsOpaqueReference, rejectCircularInsertion, typeofValue } from "./references.js";
+import { applyCollectionCallback, isSupportedCallback, toPrimitive } from "./runner.js";
 export const invokeIntrinsic = (runner, ref, args, node) => {
     if (typeof ref.receiver === "string") {
         if (ref.name === "replace" || ref.name === "replaceAll") {
@@ -41,7 +27,7 @@ export const invokeIntrinsic = (runner, ref, args, node) => {
     if (Array.isArray(ref.receiver)) {
         return invokeArrayMethod(runner, ref.receiver, ref.name, args, node);
     }
-    if (ref.receiver instanceof CodeModeDate) {
+    if (ref.receiver instanceof Values.Date) {
         const target = ref.receiver;
         const argumentCount = dateSetterArgumentCount(ref.name);
         if (argumentCount === undefined)
@@ -52,70 +38,31 @@ export const invokeIntrinsic = (runner, ref, args, node) => {
             concurrency: 1,
         }), (values) => invokeDateMethod(target, ref.name, values, node, initialTime));
     }
-    if (ref.receiver instanceof CodeModeRegExp) {
+    if (ref.receiver instanceof Values.RegExp) {
         return Effect.succeed(invokeRegExpMethod(ref.receiver, ref.name, args, node));
     }
-    if (ref.receiver instanceof CodeModeMap) {
+    if (ref.receiver instanceof Values.Map) {
         return invokeMapMethod(runner, ref.receiver, ref.name, args, node);
     }
-    if (ref.receiver instanceof CodeModeSet) {
+    if (ref.receiver instanceof Values.Set) {
         return invokeSetMethod(runner, ref.receiver, ref.name, args, node);
     }
-    if (ref.receiver instanceof CodeModeURL) {
+    if (ref.receiver instanceof Values.URL) {
         return Effect.succeed(invokeURLMethod(ref.receiver, ref.name, node));
     }
-    if (ref.receiver instanceof CodeModeURLSearchParams) {
+    if (ref.receiver instanceof Values.URLSearchParams) {
         return invokeURLSearchParamsMethod(runner, ref.receiver, ref.name, args, node);
     }
     throw new InterpreterRuntimeError(`Method '${ref.name}' is not available.`, node);
 };
-const coerceNumericArgument = (runner, value, node) => {
-    if (value === null || typeof value !== "object" || Array.isArray(value) || isCodeModeValue(value)) {
-        return Effect.succeed(coerceToNumber(value));
-    }
-    const object = value;
-    return Effect.gen(function* () {
-        if (Object.hasOwn(object, "valueOf") && typeofValue(object.valueOf) === "function") {
-            const result = yield* runner.invokeCallable(object.valueOf, [], node);
-            if (result === null || (typeof result !== "object" && typeof result !== "function")) {
-                return coerceToNumber(result);
-            }
-        }
-        if (!Object.hasOwn(object, "toString"))
-            return coerceToNumber(value);
-        if (typeofValue(object.toString) === "function") {
-            const result = yield* runner.invokeCallable(object.toString, [], node);
-            if (result === null || (typeof result !== "object" && typeof result !== "function")) {
-                return coerceToNumber(result);
-            }
-        }
-        throw new InterpreterRuntimeError("Cannot convert object to primitive value.", node).as("TypeError");
-    });
-};
-export const invokeGlobalMethod = (ref, args, node) => {
-    if (ref.namespace === "console")
-        throw new InterpreterRuntimeError(`console.${ref.name} is not available.`, node);
-    if (ref.namespace === "Object")
-        return invokeObjectMethod(ref.name, args, node);
-    if (ref.namespace === "Math")
-        return invokeMathMethod(ref.name, args, node);
-    if (ref.namespace === "Array")
-        return invokeArrayStatic(ref.name, args, node);
-    if (ref.namespace === "Number")
-        return invokeNumberStatic(ref.name, args, node);
-    if (ref.namespace === "String")
-        return invokeStringStatic(ref.name, args, node);
-    if (ref.namespace === "URL")
-        return invokeURLStatic(ref.name, args, node);
-    if (ref.namespace === "Date")
-        return invokeDateStatic(ref.name, args, node);
-    if (ref.namespace === "RegExp")
-        return invokeRegExpStatic(ref.name, args, node);
-    if (ref.namespace === "Map" || ref.namespace === "Set" || ref.namespace === "URLSearchParams") {
-        throw new InterpreterRuntimeError(`${ref.namespace}.${ref.name} is not available.`, node);
-    }
-    throw new InterpreterRuntimeError(`${ref.namespace}.${ref.name} is not available.`, node);
-};
+/**
+ * ToPrimitive: tries an object's own `valueOf`/`toString` in hint order and returns the first
+ * primitive result. Runtime values behave like their JS counterparts (Date yields its time under a
+ * number hint; the rest yield their string form). An inherited `toString` yields the default
+ * string form, so plain objects become "[object Object]" and arrays join.
+ */
+const coerceNumericArgument = (runner, value, node) => Effect.map(toPrimitive(runner, value, "number", node), coerceToNumber);
+// console is intercepted by the interpreter before reaching here.
 const requireDataArgument = (name, index, arg, node) => {
     if (containsOpaqueReference(arg)) {
         throw new InterpreterRuntimeError(`String.${name} expects argument ${index + 1} to be a data value.`, node, "InvalidDataValue");
@@ -129,7 +76,7 @@ const invokeStringMethod = (value, name, args, node) => {
     const optNum = (index) => (args[index] === undefined ? undefined : num(index));
     const optStr = (index) => (args[index] === undefined ? undefined : str(index));
     const rejectRegex = () => {
-        if (args[0] instanceof CodeModeRegExp) {
+        if (args[0] instanceof Values.RegExp) {
             throw new InterpreterRuntimeError(`String.${name} cannot take a regular expression; use regex.test(string) or String.search instead.`, node).as("TypeError");
         }
     };
@@ -172,7 +119,7 @@ const invokeStringMethod = (value, name, args, node) => {
                 result = requestedLimit !== undefined && requestedLimit >>> 0 === 0 ? [] : [value];
                 break;
             }
-            if (args[0] instanceof CodeModeRegExp) {
+            if (args[0] instanceof Values.RegExp) {
                 result = value.split(args[0].regex, optNum(1));
                 break;
             }
@@ -203,7 +150,7 @@ const invokeStringMethod = (value, name, args, node) => {
             break;
         case "replace":
         case "replaceAll": {
-            if (args[0] instanceof CodeModeRegExp) {
+            if (args[0] instanceof Values.RegExp) {
                 const pattern = args[0].regex;
                 const replacement = str(1);
                 if (name === "replaceAll" && !pattern.global) {
@@ -226,7 +173,7 @@ const invokeStringMethod = (value, name, args, node) => {
                 return null;
             // Preserve the own `index` and `groups` properties on non-global matches.
             if (pattern.global)
-                return boundedData(matched, "String.match result");
+                return toProgram(matched, "String.match result");
             return matchToValue(matched);
         }
         case "matchAll": {
@@ -278,138 +225,7 @@ const invokeStringMethod = (value, name, args, node) => {
         default:
             throw new InterpreterRuntimeError(`String method '${name}' is not available.`, node);
     }
-    return boundedData(result, `String.${name} result`);
-};
-export const arrayStatics = new Set(["isArray", "of", "from"]);
-const invokeArrayStatic = (name, args, node) => {
-    switch (name) {
-        case "isArray":
-            return Array.isArray(args[0]);
-        case "of":
-            return [...args];
-        default:
-            throw new InterpreterRuntimeError(`Array.${name} is not available.`, node);
-    }
-};
-const arrayLikeSource = (source, node) => {
-    if (source instanceof CodeModePromise) {
-        throw new InterpreterRuntimeError("Array.from received an un-awaited Promise; await it before creating the array.", node, "InvalidDataValue");
-    }
-    if (source !== null &&
-        typeof source === "object" &&
-        (Object.getPrototypeOf(source) === Object.prototype || Object.getPrototypeOf(source) === null) &&
-        typeof source.length === "number") {
-        const length = source.length;
-        const normalized = Number.isNaN(length) || length <= 0 ? 0 : Math.trunc(length);
-        if (normalized > 4_294_967_295)
-            throw new RangeError("Invalid array length");
-        return { length: normalized, source };
-    }
-    throw new InterpreterRuntimeError("Array.from expects an array, string, Map, Set, or array-like value.", node, "InvalidDataValue");
-};
-export const invokeArrayFrom = (runner, args, node) => {
-    const source = args[0];
-    const apply = args.length < 2 || args[1] === undefined ? undefined : applyCollectionCallback(runner, args[1], "Array.from", node);
-    return Effect.gen(function* () {
-        const cursor = yield* runner.syncIterator(source, node);
-        if (cursor === undefined) {
-            if (source instanceof CodeModeGenerator) {
-                throw new InterpreterRuntimeError("Array.from expects a synchronous iterable or array-like value.", node).as("TypeError");
-            }
-            const arrayLike = arrayLikeSource(source, node);
-            const values = [];
-            for (let index = 0; index < arrayLike.length; index += 1) {
-                const item = Reflect.get(arrayLike.source, index);
-                values.push(apply === undefined ? item : yield* apply([item, index]));
-            }
-            return values;
-        }
-        const values = [];
-        let index = 0;
-        while (true) {
-            const step = yield* cursor.next;
-            if (step.done)
-                return values;
-            values.push(apply === undefined ? step.value : yield* preserveConsumerError(cursor, apply([step.value, index])));
-            index += 1;
-        }
-    });
-};
-export const invokeGroupBy = (runner, namespace, args, node) => {
-    const source = args[0];
-    if (source === null || source === undefined) {
-        throw new InterpreterRuntimeError(`${namespace}.groupBy expects an iterable collection.`, node).as("TypeError");
-    }
-    const apply = applyCollectionCallback(runner, args[1], `${namespace}.groupBy`, node);
-    return Effect.gen(function* () {
-        const cursor = yield* runner.syncIterator(source, node);
-        if (cursor === undefined) {
-            throw new InterpreterRuntimeError(`${namespace}.groupBy expects an iterable collection.`, node).as("TypeError");
-        }
-        if (namespace === "Map") {
-            const result = new CodeModeMap();
-            let index = 0;
-            while (true) {
-                const step = yield* cursor.next;
-                if (step.done)
-                    return result;
-                const item = step.value;
-                const key = yield* preserveConsumerError(cursor, apply([item, index]));
-                const group = result.map.get(key);
-                if (group === undefined)
-                    result.map.set(key, [item]);
-                else
-                    group.push(item);
-                index += 1;
-            }
-        }
-        const result = Object.create(null);
-        let index = 0;
-        while (true) {
-            const step = yield* cursor.next;
-            if (step.done)
-                return result;
-            const item = step.value;
-            const key = yield* preserveConsumerError(cursor, Effect.flatMap(apply([item, index]), (value) => coerceGroupByPropertyKey(runner, value, node)));
-            if (isBlockedMember(key)) {
-                return yield* preserveConsumerError(cursor, Effect.fail(new InterpreterRuntimeError(`Property '${key}' is not available.`, node)));
-            }
-            const group = result[key];
-            if (group === undefined)
-                result[key] = [item];
-            else
-                group.push(item);
-            index += 1;
-        }
-    });
-};
-const coerceGroupByPropertyKey = (runner, value, node) => {
-    if (value === null || typeof value !== "object" || Array.isArray(value) || isCodeModeValue(value)) {
-        return Effect.succeed(coerceToString(value));
-    }
-    if (value instanceof CodeModePromise)
-        return Effect.succeed("[object Promise]");
-    if (isRuntimeReference(value)) {
-        throw new InterpreterRuntimeError("Object.groupBy callback must return a data value.", node, "InvalidDataValue");
-    }
-    const object = value;
-    if (!Object.hasOwn(object, "toString"))
-        return Effect.succeed(coerceToString(value));
-    return Effect.gen(function* () {
-        if (typeofValue(object.toString) === "function") {
-            const result = yield* runner.invokeCallable(object.toString, [], node);
-            if (result === null || (typeof result !== "object" && typeof result !== "function")) {
-                return coerceToString(result);
-            }
-        }
-        if (Object.hasOwn(object, "valueOf") && typeofValue(object.valueOf) === "function") {
-            const result = yield* runner.invokeCallable(object.valueOf, [], node);
-            if (result === null || (typeof result !== "object" && typeof result !== "function")) {
-                return coerceToString(result);
-            }
-        }
-        throw new InterpreterRuntimeError("Cannot convert object to primitive value.", node).as("TypeError");
-    });
+    return toProgram(result, `String.${name} result`);
 };
 const invokeStringReplacer = (runner, value, name, args, node) => {
     const apply = applyCollectionCallback(runner, args[1], `String.${name}`, node);
@@ -434,7 +250,7 @@ const invokeStringReplacer = (runner, value, name, args, node) => {
         return match;
     };
     const pattern = args[0];
-    if (pattern instanceof CodeModeRegExp) {
+    if (pattern instanceof Values.RegExp) {
         if (name === "replaceAll" && !pattern.regex.global) {
             throw new InterpreterRuntimeError(`String.replaceAll requires a regular expression with the global (g) flag: write /${pattern.regex.source}/${pattern.regex.flags}g, or use String.replace to replace only the first match.`, node);
         }
@@ -455,27 +271,18 @@ const invokeStringReplacer = (runner, value, name, args, node) => {
         let end = 0;
         for (const match of matches) {
             const replacement = yield* apply(match.args);
-            // Error values are branded plain objects; boundedData would strip the brand before coercion.
-            output.push(value.slice(end, match.offset), replacement instanceof CodeModePromise
+            // Error values are branded plain objects; toProgram would strip the brand before coercion.
+            output.push(value.slice(end, match.offset), replacement instanceof Values.Promise
                 ? "[object Promise]"
                 : errorBrandName(replacement)
                     ? coerceToString(replacement)
-                    : coerceToString(boundedData(replacement, `String.${name} replacer result`)));
+                    : coerceToString(toProgram(replacement, `String.${name} replacer result`)));
             end = match.offset + match.match.length;
         }
         output.push(value.slice(end));
-        return boundedData(output.join(""), `String.${name} result`);
+        return toProgram(output.join(""), `String.${name} result`);
     });
 };
-export const applyCollectionCallback = (runner, callback, name, node) => {
-    if (!isSupportedCallback(callback)) {
-        if (typeofValue(callback) === "function") {
-            throw new InterpreterRuntimeError(`${name} cannot use this callable as a callback; wrap it in an arrow function, e.g. (value) => tools.ns.tool(value).`, node);
-        }
-        throw new InterpreterRuntimeError(`${name} expects a function callback.`, node).as("TypeError");
-    }
-    return (callbackArgs) => runner.invokeCallable(callback, callbackArgs, node);
-};
 const invokeMapMethod = (runner, target, name, args, node) => {
     switch (name) {
         case "get":
@@ -562,7 +369,7 @@ const invokeSetOperation = (runner, target, name, source, node) => Effect.gen(fu
         return result;
     }
     if (name === "intersection") {
-        const result = new CodeModeSet();
+        const result = new Values.Set();
         if (target.set.size <= other.size) {
             for (const item of target.set.values()) {
                 if (yield* other.has(item))
@@ -631,27 +438,27 @@ const invokeSetOperation = (runner, target, name, source, node) => Effect.gen(fu
     return true;
 });
 const copySet = (source) => {
-    const result = new CodeModeSet();
+    const result = new Values.Set();
     for (const item of source.set.values())
         result.set.add(item);
     return result;
 };
 const loadSetRecord = (runner, source, name, node) => {
-    if (source instanceof CodeModeSet) {
+    if (source instanceof Values.Set) {
         return Effect.succeed({
             size: source.set.size,
             has: (item) => Effect.succeed(source.set.has(item)),
             keys: () => Effect.succeed(source.set.values()),
         });
     }
-    if (source instanceof CodeModeMap) {
+    if (source instanceof Values.Map) {
         return Effect.succeed({
             size: source.map.size,
             has: (item) => Effect.succeed(source.map.has(item)),
             keys: () => Effect.succeed(source.map.keys()),
         });
     }
-    if (source === null || typeof source !== "object" || isCodeModeValue(source)) {
+    if (source === null || typeof source !== "object" || Values.isValue(source)) {
         throw new InterpreterRuntimeError(`Set.${name} expects a Set-like object.`, node).as("TypeError");
     }
     const object = source;
@@ -756,7 +563,7 @@ const invokeArrayMethod = (runner, target, name, args, node) => {
             if (args.length > 1 || (args.length === 1 && typeof args[0] !== "string")) {
                 throw new InterpreterRuntimeError("Array.join expects zero arguments or one string separator.", node);
             }
-            const input = boundedData(target, "Array.join input");
+            const input = toProgram(target, "Array.join input");
             return Effect.succeed(input.map((item) => coerceToString(item ?? "")).join(args.length === 0 ? "," : args[0]));
         }
         case "includes":
@@ -992,11 +799,7 @@ const invokeArrayMethod = (runner, target, name, args, node) => {
 };
 const sortArray = (runner, target, comparator, name, node) => {
     if (comparator === undefined) {
-        return Effect.sync(() => [...target].sort((a, b) => {
-            const left = coerceToString(a);
-            const right = coerceToString(b);
-            return left < right ? -1 : left > right ? 1 : 0;
-        }));
+        return Effect.sync(() => [...target].sort((a, b) => compareText(coerceToString(a), coerceToString(b))));
     }
     const apply = applyCollectionCallback(runner, comparator, name, node);
     const mergeSort = (items) => {

package/dist/interpreter/model.d.ts

@@ -1,23 +1,10 @@
+import type { BlockStatement, Expression, Node, Pattern } from "acorn";
 import type { Effect } from "effect";
-import type { SafeObject } from "../tool-runtime.js";
-import type { CodeModePromise, CodeModeRegExp, CodeModeURL } from "../values.js";
-export type SourcePosition = {
-    line: number;
-    column: number;
-};
-export type SourceLocation = {
-    start: SourcePosition;
-    end: SourcePosition;
-};
-export type AstNode = {
-    type: string;
-    loc?: SourceLocation;
-    [key: string]: unknown;
-};
-export type ProgramNode = AstNode & {
-    type: "Program";
-    body: Array<AstNode>;
-};
+import type { DiagnosticKind } from "../codemode.js";
+import type { SafeObject } from "../data.js";
+import type { Values } from "../values.js";
+/** Any parsed node; the interpreter narrows on `type` and reads `loc` for diagnostics. */
+export type AstNode = Node;
 export type Binding = {
     mutable: boolean;
     value: unknown;
@@ -36,16 +23,16 @@ export type StatementResult = {
     label?: string;
 };
 export type MemberReference = {
-    target: SafeObject | Array<unknown> | CodeModeRegExp | CodeModeURL;
+    target: SafeObject | Array<unknown> | Values.RegExp | Values.URL;
     key: PropertyKey;
 };
 export declare class CodeModeFunction {
-    readonly parameters: ReadonlyArray<AstNode>;
-    readonly body: AstNode;
+    readonly parameters: ReadonlyArray<Pattern>;
+    readonly body: BlockStatement | Expression;
     readonly capturedScopes: ReadonlyArray<Map<string, Binding>>;
     readonly async: boolean;
     readonly generator: boolean;
-    constructor(parameters: ReadonlyArray<AstNode>, body: AstNode, capturedScopes: ReadonlyArray<Map<string, Binding>>, async: boolean, generator: boolean);
+    constructor(parameters: ReadonlyArray<Pattern>, body: BlockStatement | Expression, capturedScopes: ReadonlyArray<Map<string, Binding>>, async: boolean, generator: boolean);
 }
 export type GeneratorRequestKind = "next" | "return" | "throw";
 export declare class CodeModeGenerator {
@@ -67,51 +54,14 @@ export declare class ComputedValue {
     readonly value: unknown;
     constructor(value: unknown);
 }
-export declare class PromiseNamespace {
-}
-export declare class SymbolNamespace {
-}
 export declare const AsyncIteratorSymbol: unique symbol;
 export declare const IteratorSymbol: unique symbol;
 export declare const IteratorSymbols: readonly [typeof AsyncIteratorSymbol, typeof IteratorSymbol];
-export type PromiseMethodName = "all" | "allSettled" | "race" | "any" | "resolve" | "reject";
-export declare class PromiseMethodReference {
-    readonly name: PromiseMethodName;
-    constructor(name: PromiseMethodName);
-}
 export type PromiseInstanceMethodName = "then" | "catch" | "finally";
 export declare class PromiseInstanceMethodReference {
-    readonly promise: CodeModePromise;
+    readonly promise: Values.Promise;
     readonly name: PromiseInstanceMethodName;
-    constructor(promise: CodeModePromise, name: PromiseInstanceMethodName);
-}
-export declare class PromiseCapabilityFunction {
-    readonly settle: (value: unknown) => void;
-    constructor(settle: (value: unknown) => void);
-}
-export type GlobalNamespaceName = "Object" | "Math" | "JSON" | "Array" | "console" | "Date" | "RegExp" | "Map" | "Set" | "URL" | "URLSearchParams";
-export declare class GlobalNamespace {
-    readonly name: GlobalNamespaceName;
-    constructor(name: GlobalNamespaceName);
-}
-export declare class GlobalMethodReference {
-    readonly namespace: Exclude<GlobalNamespaceName, "JSON"> | "Number" | "String";
-    readonly name: string;
-    constructor(namespace: Exclude<GlobalNamespaceName, "JSON"> | "Number" | "String", name: string);
-}
-export declare class JsonMethodReference {
-    readonly name: "parse" | "stringify";
-    constructor(name: "parse" | "stringify");
-}
-export declare class CoercionFunction {
-    readonly name: "Number" | "String" | "Boolean" | "parseInt" | "parseFloat" | "isFinite" | "isNaN";
-    constructor(name: "Number" | "String" | "Boolean" | "parseInt" | "parseFloat" | "isFinite" | "isNaN");
-}
-export declare class UriFunction {
-    readonly name: "encodeURI" | "encodeURIComponent" | "decodeURI" | "decodeURIComponent";
-    constructor(name: "encodeURI" | "encodeURIComponent" | "decodeURI" | "decodeURIComponent");
-}
-export declare class SearchFunction {
+    constructor(promise: Values.Promise, name: PromiseInstanceMethodName);
 }
 export declare class ProgramThrow {
     readonly value: unknown;
@@ -121,11 +71,6 @@ export declare class GeneratorReturn {
     readonly value: unknown;
     constructor(value: unknown);
 }
-export declare class ErrorConstructorReference {
-    readonly name: string;
-    constructor(name: string);
-}
-export type DiagnosticKind = "ParseError" | "UnsupportedSyntax" | "UnknownTool" | "InvalidToolInput" | "InvalidToolOutput" | "InvalidDataValue" | "ToolCallLimitExceeded" | "TimeoutExceeded" | "ToolFailure" | "ExecutionFailure";
 export declare const OptionalShortCircuit: unique symbol;
 export declare const supportedSyntaxMessage = "Supported orchestration syntax: tools.* calls (they return promises - resolve them with await), data literals, destructuring, optional chaining, template literals, conditionals, switch, loops (incl. for...of and for...in over object/array/tools keys), arrow functions, spread, try/catch, array methods (map/filter/find/findIndex/some/every/reduce/flatMap/forEach/sort/slice/concat/indexOf/lastIndexOf/at/flat/reverse/includes/join), string methods (incl. match/matchAll/replace/split with regular expressions), Date/RegExp/Map/Set/URL/URLSearchParams, URI encoding helpers, Object/Math/JSON helpers, captured console.log/warn/error/dir/table, Promise.all/allSettled/race/any/resolve/reject over arrays mixing promises and plain values for parallel tool calls, promise chaining with .then/.catch/.finally, and new Promise((resolve, reject) => ...) construction.";
 export declare class InterpreterRuntimeError extends Error {
@@ -138,12 +83,6 @@ export declare class InterpreterRuntimeError extends Error {
 }
 export declare const unsupportedSyntax: (kind: string, node: AstNode) => InterpreterRuntimeError;
 export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
-export declare const asNode: (value: unknown, context: string) => AstNode;
-export declare const getArray: (node: AstNode, key: string) => Array<unknown>;
-export declare const getString: (node: AstNode, key: string) => string;
-export declare const getBoolean: (node: AstNode, key: string) => boolean;
-export declare const getOptionalNode: (node: AstNode, key: string) => AstNode | undefined;
-export declare const getNode: (node: AstNode, key: string) => AstNode;
 export declare const sourceLocation: (node: AstNode) => {
     readonly line: number;
     readonly column: number;

package/dist/interpreter/model.js

@@ -42,19 +42,9 @@ export class ComputedValue {
         this.value = value;
     }
 }
-export class PromiseNamespace {
-}
-export class SymbolNamespace {
-}
 export const AsyncIteratorSymbol = Symbol("codemode.async-iterator");
 export const IteratorSymbol = Symbol("codemode.iterator");
 export const IteratorSymbols = [AsyncIteratorSymbol, IteratorSymbol];
-export class PromiseMethodReference {
-    name;
-    constructor(name) {
-        this.name = name;
-    }
-}
 export class PromiseInstanceMethodReference {
     promise;
     name;
@@ -63,46 +53,6 @@ export class PromiseInstanceMethodReference {
         this.name = name;
     }
 }
-export class PromiseCapabilityFunction {
-    settle;
-    constructor(settle) {
-        this.settle = settle;
-    }
-}
-export class GlobalNamespace {
-    name;
-    constructor(name) {
-        this.name = name;
-    }
-}
-export class GlobalMethodReference {
-    namespace;
-    name;
-    constructor(namespace, name) {
-        this.namespace = namespace;
-        this.name = name;
-    }
-}
-export class JsonMethodReference {
-    name;
-    constructor(name) {
-        this.name = name;
-    }
-}
-export class CoercionFunction {
-    name;
-    constructor(name) {
-        this.name = name;
-    }
-}
-export class UriFunction {
-    name;
-    constructor(name) {
-        this.name = name;
-    }
-}
-export class SearchFunction {
-}
 export class ProgramThrow {
     value;
     constructor(value) {
@@ -115,12 +65,6 @@ export class GeneratorReturn {
         this.value = value;
     }
 }
-export class ErrorConstructorReference {
-    name;
-    constructor(name) {
-        this.name = name;
-    }
-}
 export const OptionalShortCircuit = Symbol("codemode.optional-short-circuit");
 export const supportedSyntaxMessage = "Supported orchestration syntax: tools.* calls (they return promises - resolve them with await), data literals, destructuring, optional chaining, template literals, conditionals, switch, loops (incl. for...of and for...in over object/array/tools keys), arrow functions, spread, try/catch, array methods (map/filter/find/findIndex/some/every/reduce/flatMap/forEach/sort/slice/concat/indexOf/lastIndexOf/at/flat/reverse/includes/join), string methods (incl. match/matchAll/replace/split with regular expressions), Date/RegExp/Map/Set/URL/URLSearchParams, URI encoding helpers, Object/Math/JSON helpers, captured console.log/warn/error/dir/table, Promise.all/allSettled/race/any/resolve/reject over arrays mixing promises and plain values for parallel tool calls, promise chaining with .then/.catch/.finally, and new Promise((resolve, reject) => ...) construction.";
 export class InterpreterRuntimeError extends Error {
@@ -143,37 +87,6 @@ export class InterpreterRuntimeError extends Error {
 }
 export const unsupportedSyntax = (kind, node) => new InterpreterRuntimeError(`Syntax '${kind}' is not supported. ${supportedSyntaxMessage}`, node, "UnsupportedSyntax", [supportedSyntaxMessage]);
 export const isRecord = (value) => typeof value === "object" && value !== null;
-export const asNode = (value, context) => {
-    if (!isRecord(value) || typeof value.type !== "string") {
-        throw new InterpreterRuntimeError(`Invalid AST node while reading ${context}.`);
-    }
-    return value;
-};
-export const getArray = (node, key) => {
-    const value = node[key];
-    if (!Array.isArray(value))
-        throw new InterpreterRuntimeError(`Expected '${key}' to be an array.`, node);
-    return value;
-};
-export const getString = (node, key) => {
-    const value = node[key];
-    if (typeof value !== "string")
-        throw new InterpreterRuntimeError(`Expected '${key}' to be a string.`, node);
-    return value;
-};
-export const getBoolean = (node, key) => {
-    const value = node[key];
-    if (typeof value !== "boolean")
-        throw new InterpreterRuntimeError(`Expected '${key}' to be a boolean.`, node);
-    return value;
-};
-export const getOptionalNode = (node, key) => {
-    const value = node[key];
-    if (value === undefined || value === null)
-        return undefined;
-    return asNode(value, key);
-};
-export const getNode = (node, key) => asNode(node[key], key);
 export const sourceLocation = (node) => ({
     line: Math.max(1, (node.loc?.start.line ?? 2) - 1),
     column: Math.max(1, (node.loc?.start.column ?? 4) - 3),