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

package/dist/openapi/spec.js

@@ -1,5 +1,5 @@
 import { fromSchemaOpenApi3_0, fromSchemaOpenApi3_1 } from "effect/JsonSchema";
-import { isBlockedMember } from "../tool-runtime.js";
+import { isBlockedMember } from "../data.js";
 export const methods = new Set(["get", "put", "post", "delete", "options", "head", "patch", "trace"]);
 const parameterLocations = ["path", "query", "header"];
 const ignoredHeaderParameters = new Set(["accept", "content-type", "authorization"]);

package/dist/stdlib/array.d.ts

@@ -0,0 +1,3 @@
+import { HostFunction } from "../interpreter/host.js";
+import { type Runner } from "../interpreter/runner.js";
+export declare const arrayGlobal: <R>(runner: Runner<R>) => HostFunction<R>;

package/dist/stdlib/array.js

@@ -0,0 +1,73 @@
+import { Effect } from "effect";
+import { HostFunction, sync, syncCall } from "../interpreter/host.js";
+import { CodeModeGenerator, InterpreterRuntimeError } from "../interpreter/model.js";
+import { applyCollectionCallback, preserveConsumerError } from "../interpreter/runner.js";
+import { Values } from "../values.js";
+const constructArray = (args, node) => {
+    if (args.length !== 1)
+        return [...args];
+    const first = args[0];
+    if (typeof first !== "number")
+        return [first];
+    if (!Number.isInteger(first) || first < 0 || first > 4294967295) {
+        throw new InterpreterRuntimeError("Invalid array length.", node).as("RangeError");
+    }
+    // Sparse like JS: Array(3) has holes, and combinator loops already skip them.
+    return new Array(first);
+};
+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");
+};
+const arrayFrom = (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;
+        }
+    });
+};
+// Array constructs identically with or without new, like JS.
+export const arrayGlobal = (runner) => new HostFunction({
+    name: "Array",
+    call: syncCall(constructArray),
+    construct: syncCall(constructArray),
+    instanceOf: (value) => Array.isArray(value),
+    members: {
+        isArray: sync("Array.isArray", (args) => Array.isArray(args[0])),
+        of: sync("Array.of", (args) => [...args]),
+        from: new HostFunction({ name: "Array.from", call: (args, node) => arrayFrom(runner, args, node) }),
+    },
+});

package/dist/stdlib/collections.d.ts

@@ -1,4 +1,9 @@
+import { HostFunction } from "../interpreter/host.js";
+import { type Runner } from "../interpreter/runner.js";
 export declare const arrayMethods: Set<string>;
 export declare const mapMethods: Set<string>;
-export declare const mapStatics: Set<string>;
 export declare const setMethods: Set<string>;
+/** `Map.groupBy` and `Object.groupBy`: the same iteration, keyed into a Map or a data object. */
+export declare const groupBy: <R>(runner: Runner<R>, namespace: "Map" | "Object") => HostFunction<R>;
+export declare const mapGlobal: <R>(runner: Runner<R>) => HostFunction<R>;
+export declare const setGlobal: <R>(runner: Runner<R>) => HostFunction<R>;

package/dist/stdlib/collections.js

@@ -1,3 +1,11 @@
+import { Effect } from "effect";
+import { isBlockedMember } from "../data.js";
+import { HostFunction, requiresNew } from "../interpreter/host.js";
+import { InterpreterRuntimeError, isRecord } from "../interpreter/model.js";
+import { isRuntimeReference } from "../interpreter/references.js";
+import { applyCollectionCallback, preserveConsumerError, toPrimitive } from "../interpreter/runner.js";
+import { Values } from "../values.js";
+import { coerceToString } from "./value.js";
 export const arrayMethods = new Set([
     "map",
     "filter",
@@ -37,7 +45,6 @@ export const arrayMethods = new Set([
     "entries",
 ]);
 export const mapMethods = new Set(["get", "set", "has", "delete", "clear", "forEach", "keys", "values", "entries"]);
-export const mapStatics = new Set(["groupBy"]);
 export const setMethods = new Set([
     "add",
     "has",
@@ -55,3 +62,115 @@ export const setMethods = new Set([
     "isSupersetOf",
     "isDisjointFrom",
 ]);
+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);
+};
+/** `Map.groupBy` and `Object.groupBy`: the same iteration, keyed into a Map or a data object. */
+export const groupBy = (runner, namespace) => new HostFunction({
+    name: `${namespace}.groupBy`,
+    call: (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 constructMap = (runner, init, node) => {
+    const target = new Values.Map();
+    if (init === undefined || init === null)
+        return Effect.succeed(target);
+    return Effect.gen(function* () {
+        const cursor = yield* runner.syncIterator(init, node);
+        if (cursor === undefined) {
+            throw new InterpreterRuntimeError("new Map(...) expects an iterable of [key, value] pairs or no argument.", node).as("TypeError");
+        }
+        while (true) {
+            const step = yield* cursor.next;
+            if (step.done)
+                return target;
+            yield* preserveConsumerError(cursor, Effect.sync(() => {
+                if (!isRecord(step.value) || isRuntimeReference(step.value)) {
+                    throw new InterpreterRuntimeError("new Map(...) expects [key, value] pairs as entry objects.", node).as("TypeError");
+                }
+                target.map.set(step.value[0], step.value[1]);
+            }));
+        }
+    });
+};
+const constructSet = (runner, init, node) => {
+    const target = new Values.Set();
+    if (init === undefined || init === null)
+        return Effect.succeed(target);
+    return Effect.gen(function* () {
+        const cursor = yield* runner.syncIterator(init, node);
+        if (cursor === undefined) {
+            throw new InterpreterRuntimeError("new Set(...) expects a synchronous iterable or no argument.", node).as("TypeError");
+        }
+        while (true) {
+            const step = yield* cursor.next;
+            if (step.done)
+                return target;
+            target.set.add(step.value);
+        }
+    });
+};
+export const mapGlobal = (runner) => new HostFunction({
+    name: "Map",
+    call: requiresNew("Map"),
+    construct: (args, node) => constructMap(runner, args[0], node),
+    instanceOf: (value) => value instanceof Values.Map,
+    members: { groupBy: groupBy(runner, "Map") },
+});
+export const setGlobal = (runner) => new HostFunction({
+    name: "Set",
+    call: requiresNew("Set"),
+    construct: (args, node) => constructSet(runner, args[0], node),
+    instanceOf: (value) => value instanceof Values.Set,
+});

package/dist/stdlib/console.d.ts

@@ -1,2 +1,3 @@
-export declare const consoleMethods: Set<string>;
-export declare const formatConsoleMessage: (name: string, args: Array<unknown>) => string;
+import { HostNamespace } from "../interpreter/host.js";
+/** Captured console: every method appends one formatted line to `logs`. */
+export declare const consoleGlobal: (logs: Array<string>) => HostNamespace;

package/dist/stdlib/console.js

@@ -1,10 +1,19 @@
+import { toData, toProgram } from "../data.js";
+import { HostNamespace, sync } from "../interpreter/host.js";
 import { containsOpaqueReference, containsRuntimeReference, isRuntimeReference } from "../interpreter/references.js";
-import { copyIn, copyOut } from "../tool-runtime.js";
-import { isCodeModeValue, CodeModeDate, CodeModeMap, CodeModePromise, CodeModeRegExp, CodeModeSet, CodeModeURL, CodeModeURLSearchParams, } from "../values.js";
-import { boundedData, coerceToString } from "./value.js";
-export const consoleMethods = new Set(["log", "info", "debug", "warn", "error", "dir", "table"]);
+import { Values } from "../values.js";
+import { coerceToString } from "./value.js";
+const consoleMethods = ["log", "info", "debug", "warn", "error", "dir", "table"];
+/** Captured console: every method appends one formatted line to `logs`. */
+export const consoleGlobal = (logs) => new HostNamespace("console", Object.fromEntries(consoleMethods.map((name) => [
+    name,
+    sync(`console.${name}`, (args) => {
+        logs.push(formatConsoleMessage(name, args));
+        return undefined;
+    }),
+])));
 const MAX_CONSOLE_DEPTH = 32;
-export const formatConsoleMessage = (name, args) => {
+const formatConsoleMessage = (name, args) => {
     if (name === "dir")
         return args.length === 0 ? "undefined" : formatConsoleArgument(args[0]);
     if (name === "table")
@@ -28,21 +37,21 @@ const formatConsoleValue = (value, seen, depth) => {
         return String(value);
     if (typeof value !== "object")
         return String(value);
-    if (value instanceof CodeModePromise)
+    if (value instanceof Values.Promise)
         return "[Promise (await it to get its value)]";
-    if (value instanceof CodeModeDate)
+    if (value instanceof Values.Date)
         return coerceToString(value);
-    if (value instanceof CodeModeRegExp)
+    if (value instanceof Values.RegExp)
         return coerceToString(value);
-    if (value instanceof CodeModeURL)
+    if (value instanceof Values.URL)
         return coerceToString(value);
-    if (value instanceof CodeModeURLSearchParams)
+    if (value instanceof Values.URLSearchParams)
         return coerceToString(value);
     if (depth > MAX_CONSOLE_DEPTH)
         return "...";
     if (seen.has(value))
         return "[Circular]";
-    if (value instanceof CodeModeMap) {
+    if (value instanceof Values.Map) {
         seen.add(value);
         try {
             const entries = Array.from(value.map.entries(), ([key, item]) => [key, item]);
@@ -52,7 +61,7 @@ const formatConsoleValue = (value, seen, depth) => {
             seen.delete(value);
         }
     }
-    if (value instanceof CodeModeSet) {
+    if (value instanceof Values.Set) {
         seen.add(value);
         try {
             return `Set(${value.set.size}) ${formatConsoleValue(Array.from(value.set.values()), seen, depth + 1)}`;
@@ -81,7 +90,7 @@ const formatConsoleTable = (value, columnsArgument) => {
         return "undefined";
     if (containsOpaqueReference(value))
         return "[opaque reference]";
-    const data = boundedData(value, "console.table argument");
+    const data = toProgram(value, "console.table argument");
     const columns = consoleTableColumns(columnsArgument);
     const rows = consoleTableRows(data, columns);
     const keys = columns ?? Array.from(new Set(rows.flatMap((row) => Object.keys(row.values))));
@@ -96,20 +105,20 @@ const consoleTableColumns = (value) => {
         return undefined;
     if (containsRuntimeReference(value))
         return undefined;
-    const columns = copyOut(copyIn(value, "console.table columns"), "nullify");
+    const columns = toData(value, "console.table columns", "result");
     return Array.isArray(columns) ? columns.map((column) => String(column)) : undefined;
 };
 const consoleTableRows = (data, columns) => {
     if (Array.isArray(data)) {
         return data.map((item, index) => ({ index: String(index), values: consoleTableValues(item, columns) }));
     }
-    if (data !== null && typeof data === "object" && !isCodeModeValue(data)) {
+    if (data !== null && typeof data === "object" && !Values.isValue(data)) {
         return Object.entries(data).map(([index, item]) => ({ index, values: consoleTableValues(item, columns) }));
     }
     return [{ index: "0", values: { Value: data } }];
 };
 const consoleTableValues = (value, columns) => {
-    if (value !== null && typeof value === "object" && !Array.isArray(value) && !isCodeModeValue(value)) {
+    if (value !== null && typeof value === "object" && !Array.isArray(value) && !Values.isValue(value)) {
         const source = value;
         if (columns !== undefined)
             return Object.fromEntries(columns.map((column) => [column, source[column]]));

package/dist/stdlib/date.d.ts

@@ -1,7 +1,8 @@
+import { HostFunction } from "../interpreter/host.js";
 import { type AstNode } from "../interpreter/model.js";
-import { CodeModeDate } from "../values.js";
+import { type Runner } from "../interpreter/runner.js";
+import { Values } from "../values.js";
 export declare const dateMethods: Set<string>;
-export declare const dateStatics: Set<string>;
-export declare const invokeDateStatic: (name: string, args: Array<unknown>, node: AstNode) => number;
+export declare const dateGlobal: <R>(runner: Runner<R>) => HostFunction<R>;
 export declare const dateSetterArgumentCount: (name: string) => number | undefined;
-export declare const invokeDateMethod: (value: CodeModeDate, name: string, args: Array<number>, node: AstNode, initialTime?: number) => unknown;
+export declare const invokeDateMethod: (value: Values.Date, name: string, args: Array<number>, node: AstNode, initialTime?: number) => unknown;

package/dist/stdlib/date.js

@@ -1,5 +1,8 @@
+import { Effect } from "effect";
+import { HostFunction, sync } from "../interpreter/host.js";
 import { InterpreterRuntimeError } from "../interpreter/model.js";
-import { CodeModeDate } from "../values.js";
+import { toPrimitive } from "../interpreter/runner.js";
+import { Values } from "../values.js";
 import { coerceToNumber, coerceToString } from "./value.js";
 const dateSetterArguments = new Map([
     ["setTime", 1],
@@ -45,19 +48,32 @@ export const dateMethods = new Set([
     "getTimezoneOffset",
     ...dateSetterArguments.keys(),
 ]);
-export const dateStatics = new Set(["now", "parse", "UTC"]);
-export const invokeDateStatic = (name, args, node) => {
-    switch (name) {
-        case "now":
-            return Date.now();
-        case "parse":
-            return Date.parse(coerceToString(args[0]));
-        case "UTC":
-            return Date.UTC(...args.map((arg) => coerceToNumber(arg)));
-        default:
-            throw new InterpreterRuntimeError(`Date.${name} is not available.`, node);
+const constructDate = (runner, args, node) => {
+    if (args.length === 0)
+        return Effect.succeed(new Values.Date(Date.now()));
+    if (args.length === 1) {
+        const arg = args[0];
+        if (arg instanceof Values.Date)
+            return Effect.succeed(new Values.Date(arg.time));
+        return Effect.map(toPrimitive(runner, arg, "number", node), (value) => typeof value === "string"
+            ? new Values.Date(Date.parse(value))
+            : new Values.Date(new Date(coerceToNumber(value)).getTime()));
     }
+    const parts = args.map((arg) => coerceToNumber(arg));
+    return Effect.succeed(new Values.Date(new Date(...parts).getTime()));
 };
+export const dateGlobal = (runner) => new HostFunction({
+    name: "Date",
+    // ISO instead of the host's locale string: date strings are deterministic and must not leak the host timezone.
+    call: () => Effect.sync(() => new Date().toISOString()),
+    construct: (args, node) => constructDate(runner, args, node),
+    instanceOf: (value) => value instanceof Values.Date,
+    members: {
+        now: sync("Date.now", () => Date.now()),
+        parse: sync("Date.parse", (args) => Date.parse(coerceToString(args[0]))),
+        UTC: sync("Date.UTC", (args) => Date.UTC(...args.map((arg) => coerceToNumber(arg)))),
+    },
+});
 export const dateSetterArgumentCount = (name) => dateSetterArguments.get(name);
 export const invokeDateMethod = (value, name, args, node, initialTime = value.time) => {
     const hosted = new Date(initialTime);

package/dist/stdlib/json.d.ts

@@ -1,6 +1,6 @@
 import { Effect } from "effect";
-import type { CallbackRunner } from "../interpreter/methods.js";
+import { HostNamespace } from "../interpreter/host.js";
+import { type Runner } from "../interpreter/runner.js";
 import { type AstNode } from "../interpreter/model.js";
-export declare const jsonStatics: Set<string>;
-export type JsonMethodName = "parse" | "stringify";
-export declare const invokeJsonMethod: <R>(runner: CallbackRunner<R>, name: JsonMethodName, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
+export declare const invokeJsonMethod: <R>(runner: Runner<R>, name: "parse" | "stringify", args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
+export declare const jsonGlobal: <R>(runner: Runner<R>) => HostNamespace;

package/dist/stdlib/json.js

@@ -1,20 +1,24 @@
 import { Effect } from "effect";
-import { applyCollectionCallback } from "../interpreter/methods.js";
+import { HostFunction, HostNamespace } from "../interpreter/host.js";
+import { applyCollectionCallback } from "../interpreter/runner.js";
 import { InterpreterRuntimeError } from "../interpreter/model.js";
 import { typeofValue } from "../interpreter/references.js";
-import { copyIn, copyOut } from "../tool-runtime.js";
-import { CodeModeDate, CodeModeMap, CodeModeRegExp, CodeModeSet, CodeModeURL, CodeModeURLSearchParams, } from "../values.js";
-export const jsonStatics = new Set(["parse", "stringify"]);
+import { fromData, toData, toProgram } from "../data.js";
+import { Values } from "../values.js";
 export const invokeJsonMethod = (runner, name, args, node) => {
     return name === "parse" ? parse(runner, args, node) : stringify(runner, args, node);
 };
+export const jsonGlobal = (runner) => new HostNamespace("JSON", {
+    parse: new HostFunction({ name: "JSON.parse", call: (args, node) => parse(runner, args, node) }),
+    stringify: new HostFunction({ name: "JSON.stringify", call: (args, node) => stringify(runner, args, node) }),
+});
 const parse = (runner, args, node) => {
     const text = args[0];
     if (typeof text !== "string")
         throw new InterpreterRuntimeError("JSON.parse expects a string.", node);
     const parsed = (() => {
         try {
-            return copyIn(JSON.parse(text), "JSON.parse result");
+            return fromData(JSON.parse(text), "JSON.parse result");
         }
         catch (error) {
             throw new InterpreterRuntimeError(`JSON.parse received invalid JSON: ${error instanceof Error ? error.message : String(error)}`, node).as("SyntaxError");
@@ -54,27 +58,25 @@ const stringify = (runner, args, node) => {
     const space = args[2];
     const indent = typeof space === "number" || typeof space === "string" ? space : undefined;
     const replacer = args[1];
-    const callable = typeofValue(replacer) === "function";
-    const checked = copyIn(args[0], "JSON.stringify value", callable);
-    const input = callable ? args[0] : checked;
-    if (Array.isArray(replacer)) {
-        const properties = replacer
-            .filter((item) => typeof item === "string" || typeof item === "number")
-            .map(String);
-        return Effect.succeed(JSON.stringify(copyOut(input, "json"), properties, indent));
-    }
-    if (!callable) {
-        return Effect.succeed(JSON.stringify(copyOut(input, "json"), null, indent));
+    if (typeofValue(replacer) !== "function") {
+        const properties = Array.isArray(replacer)
+            ? replacer
+                .filter((item) => typeof item === "string" || typeof item === "number")
+                .map(String)
+            : null;
+        return Effect.succeed(JSON.stringify(toData(args[0], "JSON.stringify value"), properties, indent));
     }
+    // Validate up front; the replacer walk below reads the original value.
+    toProgram(args[0], "JSON.stringify value");
     const apply = applyCollectionCallback(runner, replacer, "JSON.stringify", node);
     const root = Object.create(null);
-    root[""] = input;
+    root[""] = args[0];
     const stack = new Set();
     const visit = (holder, key) => Effect.gen(function* () {
         const value = yield* apply([key, toJSONValue(holder[key])]);
         if (value === undefined || typeofValue(value) === "function")
             return undefined;
-        copyIn(value, "JSON.stringify replacer result", true);
+        toProgram(value, "JSON.stringify replacer result");
         if (typeof value === "number")
             return Number.isFinite(value) ? value : null;
         if (value === null || typeof value === "string" || typeof value === "boolean")
@@ -107,18 +109,11 @@ const stringify = (runner, args, node) => {
     return Effect.map(visit(root, ""), (value) => JSON.stringify(value, null, indent));
 };
 const toJSONValue = (value) => {
-    if (value instanceof CodeModeDate) {
+    if (value instanceof Values.Date) {
         return Number.isFinite(value.time) ? new Date(value.time).toISOString() : null;
     }
-    if (value instanceof CodeModeURL)
+    if (value instanceof Values.URL)
         return value.url.href;
     return value;
 };
-const isPlainObject = (value) => value !== null &&
-    typeof value === "object" &&
-    !(value instanceof CodeModeDate) &&
-    !(value instanceof CodeModeRegExp) &&
-    !(value instanceof CodeModeMap) &&
-    !(value instanceof CodeModeSet) &&
-    !(value instanceof CodeModeURL) &&
-    !(value instanceof CodeModeURLSearchParams);
+const isPlainObject = (value) => value !== null && typeof value === "object" && !Values.isValue(value);

package/dist/stdlib/math.d.ts

@@ -1,12 +1,8 @@
-import { Effect } from "effect";
-import { type SyncIteratorRunner } from "../interpreter/iterator.js";
-import { type AstNode } from "../interpreter/model.js";
+import { HostNamespace } from "../interpreter/host.js";
+import { type Runner } from "../interpreter/runner.js";
 declare global {
     interface Math {
         sumPrecise(values: Iterable<number>): number;
     }
 }
-export declare const mathConstants: Set<string>;
-export declare const mathMethods: Set<string>;
-export declare const invokeMathMethod: (name: string, args: Array<unknown>, node: AstNode) => number;
-export declare const invokeMathSumPrecise: <R>(runner: SyncIteratorRunner<R>, source: unknown, node: AstNode) => Effect.Effect<number, unknown, R>;
+export declare const mathGlobal: <R>(runner: Runner<R>) => HostNamespace;