@opencode/codemode 0.0.0-beta-19365 → 0.0.0-beta-19381

package/dist/interpreter/errors.d.ts

@@ -1,9 +1,7 @@
-import { Effect } from "effect";
 import type { Diagnostic } from "../codemode.js";
-import { type SafeObject } from "../data.js";
-import { type AstNode } from "./model.js";
-import { type SyncIteratorRunner } from "./iterator.js";
+import { HostFunction } from "./host.js";
+import { type Runner } from "./runner.js";
 export declare const normalizeError: (error: unknown) => Diagnostic;
 export declare const caughtErrorValue: (thrown: unknown) => unknown;
-export declare const constructErrorValue: (name: string, args: Array<unknown>) => SafeObject;
-export declare const constructAggregateErrorValue: <R>(runner: SyncIteratorRunner<R>, args: Array<unknown>, node: AstNode) => Effect.Effect<SafeObject, unknown, R>;
+/** An error constructor such as `Error` or `TypeError`; callable with or without `new`, like JS. */
+export declare const errorGlobal: <R>(name: string, runner: Runner<R>) => HostFunction<R>;

package/dist/interpreter/errors.js

@@ -3,8 +3,9 @@ import { ToolError } from "../tool-error.js";
 import { toData, ToolRuntimeError } from "../data.js";
 import { formatLocation, InterpreterRuntimeError, ProgramThrow, sourceLocation } from "./model.js";
 import { containsRuntimeReference } from "./references.js";
-import {} from "./iterator.js";
-import { coerceToString, createAggregateErrorValue, createErrorValue, errorConstructors } from "../stdlib/value.js";
+import { HostFunction } from "./host.js";
+import {} from "./runner.js";
+import { coerceToString, createAggregateErrorValue, createErrorValue, errorBrandName, errorConstructors, } from "../stdlib/value.js";
 export const normalizeError = (error) => {
     if (error instanceof InterpreterRuntimeError) {
         return {
@@ -74,8 +75,8 @@ export const caughtErrorValue = (thrown) => {
     const name = thrown instanceof Error && errorConstructors.has(thrown.name) ? thrown.name : "Error";
     return createErrorValue(name, normalizeError(thrown).message);
 };
-export const constructErrorValue = (name, args) => createErrorValue(name, args[0] === undefined ? "" : coerceToString(args[0]));
-export const constructAggregateErrorValue = (runner, args, node) => Effect.gen(function* () {
+const constructErrorValue = (name, args) => createErrorValue(name, args[0] === undefined ? "" : coerceToString(args[0]));
+const constructAggregateErrorValue = (runner, args, node) => Effect.gen(function* () {
     const cursor = yield* runner.syncIterator(args[0], node);
     if (cursor === undefined) {
         throw new InterpreterRuntimeError("new AggregateError(...) expects a synchronous iterable of errors.", node).as("TypeError");
@@ -89,3 +90,18 @@ export const constructAggregateErrorValue = (runner, args, node) => Effect.gen(f
         errors.push(step.value);
     }
 });
+/** An error constructor such as `Error` or `TypeError`; callable with or without `new`, like JS. */
+export const errorGlobal = (name, runner) => {
+    const construct = (args, node) => name === "AggregateError"
+        ? constructAggregateErrorValue(runner, args, node)
+        : Effect.sync(() => constructErrorValue(name, args));
+    return new HostFunction({
+        name,
+        call: construct,
+        construct,
+        instanceOf: (value) => {
+            const brand = errorBrandName(value);
+            return brand !== undefined && (name === "Error" || brand === name);
+        },
+    });
+};

package/dist/interpreter/execute.js

@@ -8,7 +8,7 @@ import { ToolRuntime } from "../tool-runtime.js";
 import { normalizeError } from "./errors.js";
 import { InterpreterRuntimeError } from "./model.js";
 import { PromiseRuntime } from "./promises.js";
-import { Interpreter } from "./runtime.js";
+import { Runtime } from "./runtime.js";
 export const executeProgram = (code, prepared, limits, hooks) => {
     if (code.trim().length === 0) {
         return Effect.succeed({
@@ -27,8 +27,7 @@ export const executeProgram = (code, prepared, limits, hooks) => {
         const base = Effect.acquireUseRelease(Scope.make("parallel"), (scope) => Effect.gen(function* () {
             const program = parseProgram(code);
             const promises = new PromiseRuntime(scope);
-            const interpreter = new Interpreter(tools.execute, tools.search, tools.keys, promises, logs);
-            const value = yield* interpreter.run(program);
+            const value = yield* new Runtime(tools.execute, tools.search, tools.keys, promises, logs).run(program);
             const result = toData(value, "Execution result", "result");
             returned = { value: result, promises };
             const warnings = yield* promises.interrupt();

package/dist/interpreter/globals.d.ts

@@ -0,0 +1,13 @@
+import { Effect } from "effect";
+import { type PromiseRuntime } from "./promises.js";
+import type { Runner } from "./runner.js";
+/** What the built-in globals need from the interpreter that owns them. */
+export type Host<R> = {
+    readonly runner: Runner<R>;
+    readonly promises: PromiseRuntime<R>;
+    readonly search: (args: Array<unknown>) => Effect.Effect<unknown, unknown, R>;
+    readonly toolKeys: (path: ReadonlyArray<string>) => ReadonlyArray<string>;
+    readonly logs: Array<string>;
+};
+/** The immutable global bindings of every program, in declaration order. */
+export declare const globals: <R>(host: Host<R>) => ReadonlyArray<readonly [string, unknown]>;

package/dist/interpreter/globals.js

@@ -0,0 +1,59 @@
+import { Effect } from "effect";
+import { arrayGlobal } from "../stdlib/array.js";
+import { mapGlobal, setGlobal } from "../stdlib/collections.js";
+import { consoleGlobal } from "../stdlib/console.js";
+import { dateGlobal } from "../stdlib/date.js";
+import { jsonGlobal } from "../stdlib/json.js";
+import { mathGlobal } from "../stdlib/math.js";
+import { numberGlobal } from "../stdlib/number.js";
+import { objectGlobal } from "../stdlib/object.js";
+import { regexpGlobal } from "../stdlib/regexp.js";
+import { stringGlobal } from "../stdlib/string.js";
+import { uriGlobal, urlGlobal, urlSearchParamsGlobal } from "../stdlib/url.js";
+import { coercion, errorConstructors } from "../stdlib/value.js";
+import { ToolReference } from "../tool-runtime.js";
+import { errorGlobal } from "./errors.js";
+import { HostFunction } from "./host.js";
+import { AsyncIteratorSymbol, InterpreterRuntimeError, IteratorSymbol } from "./model.js";
+import { promiseGlobal } from "./promises.js";
+const symbolGlobal = new HostFunction({
+    name: "Symbol",
+    call: (_, node) => Effect.sync(() => {
+        throw new InterpreterRuntimeError("Symbol is not callable; only Symbol.asyncIterator and Symbol.iterator are available.", node).as("TypeError");
+    }),
+    callback: false,
+    members: { asyncIterator: AsyncIteratorSymbol, iterator: IteratorSymbol },
+});
+/** The immutable global bindings of every program, in declaration order. */
+export const globals = (host) => [
+    ["tools", new ToolReference([])],
+    ["search", new HostFunction({ name: "search", call: (args) => host.search(args), callback: false })],
+    ["undefined", undefined],
+    ["NaN", NaN],
+    ["Infinity", Infinity],
+    ["Object", objectGlobal(host.runner, host.toolKeys)],
+    ["Array", arrayGlobal(host.runner)],
+    ["Math", mathGlobal(host.runner)],
+    ["JSON", jsonGlobal(host.runner)],
+    ["console", consoleGlobal(host.logs)],
+    ["Promise", promiseGlobal(host.runner, host.promises)],
+    ["Symbol", symbolGlobal],
+    ["Number", numberGlobal],
+    ["String", stringGlobal],
+    ["Boolean", coercion("Boolean", { instanceOf: () => false })],
+    ["parseInt", coercion("parseInt")],
+    ["parseFloat", coercion("parseFloat")],
+    ["isFinite", coercion("isFinite")],
+    ["isNaN", coercion("isNaN")],
+    ["Date", dateGlobal(host.runner)],
+    ["RegExp", regexpGlobal],
+    ["Map", mapGlobal(host.runner)],
+    ["Set", setGlobal(host.runner)],
+    ["URL", urlGlobal],
+    ["URLSearchParams", urlSearchParamsGlobal(host.runner)],
+    ["encodeURI", uriGlobal("encodeURI")],
+    ["encodeURIComponent", uriGlobal("encodeURIComponent")],
+    ["decodeURI", uriGlobal("decodeURI")],
+    ["decodeURIComponent", uriGlobal("decodeURIComponent")],
+    ...[...errorConstructors].map((name) => [name, errorGlobal(name, host.runner)]),
+];

package/dist/interpreter/host.d.ts

@@ -0,0 +1,41 @@
+import { Effect } from "effect";
+import { type AstNode } from "./model.js";
+export type HostCall<R> = (args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
+type HostMember = (key: PropertyKey, node: AstNode) => unknown;
+type HostFunctionOptions<R> = {
+    readonly name: string;
+    readonly call: HostCall<R>;
+    /** `new name(...)`; without it `new` is unsupported syntax. */
+    readonly construct?: HostCall<R>;
+    /** Static members read through `name.key`; unknown keys read as `undefined` unless the function decides otherwise. */
+    readonly members?: Record<string, unknown> | HostMember;
+    /** `value instanceof name`; without it the operator rejects this right-hand side. */
+    readonly instanceOf?: (value: unknown) => boolean;
+    /** Whether callback sites (array methods, replacers, promise reactions) admit this function. Defaults to true. */
+    readonly callback?: boolean;
+};
+/** A host-implemented function value. `typeof` is "function". */
+export declare class HostFunction<R = never> {
+    readonly name: string;
+    readonly call: HostCall<R>;
+    readonly construct: HostCall<R> | undefined;
+    readonly member: HostMember;
+    readonly instanceOf: ((value: unknown) => boolean) | undefined;
+    readonly callback: boolean;
+    constructor(options: HostFunctionOptions<R>);
+}
+/** A host-implemented object of static members. `typeof` is "object" and it is not callable. */
+export declare class HostNamespace {
+    readonly name: string;
+    readonly member: HostMember;
+    constructor(name: string, members: Record<string, unknown> | HostMember);
+}
+export type SyncOptions = Omit<HostFunctionOptions<never>, "name" | "call">;
+type SyncImpl = (args: Array<unknown>, node: AstNode) => unknown;
+/** Lifts a synchronous implementation, which may throw `InterpreterRuntimeError`, into a host call. */
+export declare const syncCall: (impl: SyncImpl) => HostCall<never>;
+/** A synchronous host function. */
+export declare const sync: (name: string, impl: SyncImpl, options?: SyncOptions) => HostFunction<never>;
+/** The `call` of a constructor that JS requires to be invoked with `new`. */
+export declare const requiresNew: (name: string) => HostCall<never>;
+export {};

package/dist/interpreter/host.js

@@ -0,0 +1,44 @@
+import { Effect } from "effect";
+import { InterpreterRuntimeError } from "./model.js";
+/** A host-implemented function value. `typeof` is "function". */
+export class HostFunction {
+    name;
+    call;
+    construct;
+    member;
+    instanceOf;
+    callback;
+    constructor(options) {
+        this.name = options.name;
+        this.call = options.call;
+        this.construct = options.construct;
+        this.member = memberLookup(options.members);
+        this.instanceOf = options.instanceOf;
+        this.callback = options.callback ?? true;
+    }
+}
+/** A host-implemented object of static members. `typeof` is "object" and it is not callable. */
+export class HostNamespace {
+    name;
+    member;
+    constructor(name, members) {
+        this.name = name;
+        this.member = memberLookup(members);
+    }
+}
+const memberLookup = (members) => {
+    if (members === undefined)
+        return () => undefined;
+    if (typeof members === "function")
+        return members;
+    const table = new Map(Object.entries(members));
+    return (key) => (typeof key === "string" ? table.get(key) : undefined);
+};
+/** Lifts a synchronous implementation, which may throw `InterpreterRuntimeError`, into a host call. */
+export const syncCall = (impl) => (args, node) => Effect.sync(() => impl(args, node));
+/** A synchronous host function. */
+export const sync = (name, impl, options = {}) => new HostFunction({ name, call: syncCall(impl), ...options });
+/** The `call` of a constructor that JS requires to be invoked with `new`. */
+export const requiresNew = (name) => (_, node) => Effect.sync(() => {
+    throw new InterpreterRuntimeError(`Constructor ${name} requires 'new'.`, node).as("TypeError");
+});

package/dist/interpreter/methods.d.ts

@@ -1,24 +1,4 @@
 import { Effect } from "effect";
-import { type AstNode, CodeModeFunction, CoercionFunction, ErrorConstructorReference, GlobalMethodReference, GlobalNamespace, IntrinsicReference, JsonMethodReference, PromiseCapabilityFunction, PromiseNamespace, UriFunction } from "./model.js";
-import { Values } from "../values.js";
-import { type SyncIteratorRunner } from "./iterator.js";
-export type CallbackRunner<R> = {
-    readonly invokeFunction: (fn: CodeModeFunction, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>;
-    readonly invokeCallable: (callable: unknown, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
-    readonly settlePromise: (promise: Values.Promise) => Effect.Effect<unknown, unknown, never>;
-};
-export type SupportedCallback = CodeModeFunction | CoercionFunction | UriFunction | PromiseCapabilityFunction | GlobalMethodReference | JsonMethodReference | IntrinsicReference | ErrorConstructorReference | GlobalNamespace | PromiseNamespace;
-export declare const isSupportedCallback: (value: unknown) => value is SupportedCallback;
-export declare const invokeIntrinsic: <R>(runner: CallbackRunner<R>, ref: IntrinsicReference, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
-/**
- * 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.
- */
-export declare const toPrimitive: <R>(runner: CallbackRunner<R>, value: unknown, hint: "number" | "string", node: AstNode) => Effect.Effect<unknown, unknown, R>;
-export declare const invokeGlobalMethod: (ref: GlobalMethodReference, args: Array<unknown>, node: AstNode) => unknown;
-export declare const arrayStatics: Set<string>;
-export declare const invokeArrayFrom: <R>(runner: CallbackRunner<R> & SyncIteratorRunner<R>, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
-export declare const invokeGroupBy: <R>(runner: CallbackRunner<R> & SyncIteratorRunner<R>, namespace: "Map" | "Object", args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
-export declare const applyCollectionCallback: <R>(runner: CallbackRunner<R>, callback: unknown, name: string, node: AstNode) => ((args: Array<unknown>) => Effect.Effect<unknown, unknown, R>);
+import { type AstNode, IntrinsicReference } from "./model.js";
+import { type Runner } from "./runner.js";
+export declare const invokeIntrinsic: <R>(runner: Runner<R>, ref: IntrinsicReference, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;

package/dist/interpreter/methods.js

@@ -1,30 +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, 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 { 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 { 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 { 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") {
@@ -76,48 +61,8 @@ export const invokeIntrinsic = (runner, ref, args, node) => {
  * 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.
  */
-export const toPrimitive = (runner, value, hint, node) => {
-    if (value === null || typeof value !== "object")
-        return Effect.succeed(value);
-    if (Values.isValue(value)) {
-        return Effect.succeed(value instanceof Values.Date && hint === "number" ? value.time : coerceToString(value));
-    }
-    const object = value;
-    const order = hint === "number" ? ["valueOf", "toString"] : ["toString", "valueOf"];
-    return Effect.gen(function* () {
-        for (const method of order) {
-            if (method === "toString" && !Object.hasOwn(object, "toString"))
-                return coerceToString(value);
-            if (!Object.hasOwn(object, method) || typeofValue(object[method]) !== "function")
-                continue;
-            const result = yield* runner.invokeCallable(object[method], [], node);
-            if (result === null || (typeof result !== "object" && typeof result !== "function"))
-                return result;
-        }
-        throw new InterpreterRuntimeError("Cannot convert object to primitive value.", node).as("TypeError");
-    });
-};
 const coerceNumericArgument = (runner, value, node) => Effect.map(toPrimitive(runner, value, "number", node), coerceToNumber);
 // console is intercepted by the interpreter before reaching here.
-export const invokeGlobalMethod = (ref, args, 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);
-    throw new InterpreterRuntimeError(`${ref.namespace}.${ref.name} is not available.`, node);
-};
 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");
@@ -282,117 +227,6 @@ const invokeStringMethod = (value, name, args, node) => {
     }
     return toProgram(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 Values.Promise) {
-        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 Values.Map();
-            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 instanceof Values.Promise)
-        return Effect.succeed("[object Promise]");
-    if (!Values.isValue(value) && isRuntimeReference(value)) {
-        throw new InterpreterRuntimeError("Object.groupBy callback must return a data value.", node, "InvalidDataValue");
-    }
-    return Effect.map(toPrimitive(runner, value, "string", node), coerceToString);
-};
 const invokeStringReplacer = (runner, value, name, args, node) => {
     const apply = applyCollectionCallback(runner, args[1], `String.${name}`, node);
     const matches = [];
@@ -449,15 +283,6 @@ const invokeStringReplacer = (runner, value, name, args, node) => {
         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":

package/dist/interpreter/model.d.ts

@@ -54,52 +54,15 @@ 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: Values.Promise;
     readonly name: PromiseInstanceMethodName;
     constructor(promise: Values.Promise, 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 {
-}
 export declare class ProgramThrow {
     readonly value: unknown;
     constructor(value: unknown);
@@ -108,10 +71,6 @@ export declare class GeneratorReturn {
     readonly value: unknown;
     constructor(value: unknown);
 }
-export declare class ErrorConstructorReference {
-    readonly name: string;
-    constructor(name: string);
-}
 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 {

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 {