@opencode/codemode 0.0.0-beta-19507 → 0.0.0-dev-19274

package/dist/openapi/spec.js

@@ -1,4 +1,5 @@
 import { fromSchemaOpenApi3_0, fromSchemaOpenApi3_1 } from "effect/JsonSchema";
+import { isBlockedMember } from "../tool-runtime.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"]);
@@ -362,7 +363,8 @@ export const operationInput = (document, pathItem, operation) => {
         ok: true,
         value: {
             fields: fields.map((field) => {
-                const base = conflicts.has(field.name) ? `${field.location}_${field.name}` : field.name;
+                const visibleName = isBlockedMember(field.name) ? `${field.name}_2` : field.name;
+                const base = conflicts.has(field.name) ? `${field.location}_${visibleName}` : visibleName;
                 const next = (index) => {
                     const candidate = index === 1 ? base : `${base}_${index}`;
                     return used.has(candidate) ? next(index + 1) : candidate;
@@ -442,10 +444,11 @@ export const operationOutput = (document, operation, definitions) => {
     };
 };
 const sanitizeOperationSegment = (raw) => {
-    return (raw
+    const base = raw
         .replaceAll(/[^A-Za-z0-9_$]+/g, "_")
         .replace(/^_+|_+$/g, "")
-        .replace(/^([0-9])/, "_$1") || "operation");
+        .replace(/^([0-9])/, "_$1") || "operation";
+    return isBlockedMember(base) ? `${base}_2` : base;
 };
 const fallbackOperationId = (method, path) => [
     method,

package/dist/stdlib/collections.d.ts

@@ -1,9 +1,4 @@
-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,11 +1,3 @@
-import { Effect } from "effect";
-import { HostFunction, requiresNew } from "../interpreter/host.js";
-import { InterpreterRuntimeError } from "../interpreter/model.js";
-import { getOwn, ProgramArray, ProgramObject, set } from "../interpreter/objects.js";
-import { describeValue, 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",
@@ -45,6 +37,7 @@ 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",
@@ -62,112 +55,3 @@ 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, received ${describeValue(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, new ProgramArray([item]));
-                    else
-                        group.items.push(item);
-                    index += 1;
-                }
-            }
-            const result = new ProgramObject();
-            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)));
-                const group = getOwn(result, key);
-                if (group === undefined)
-                    set(result, key, new ProgramArray([item]));
-                else
-                    group.items.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 (!(step.value instanceof ProgramObject)) {
-                    throw new InterpreterRuntimeError("new Map(...) expects [key, value] pairs as entry objects.", node).as("TypeError");
-                }
-                target.map.set(getOwn(step.value, 0), getOwn(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,3 +1,2 @@
-import { HostNamespace } from "../interpreter/host.js";
-/** Captured console: every method appends one formatted line to `logs`. */
-export declare const consoleGlobal: (logs: Array<string>) => HostNamespace;
+export declare const consoleMethods: Set<string>;
+export declare const formatConsoleMessage: (name: string, args: Array<unknown>) => string;

package/dist/stdlib/console.js

@@ -1,20 +1,10 @@
-import { toData, toProgram } from "../data.js";
-import { HostNamespace, sync } from "../interpreter/host.js";
-import { get, ownEntries, ProgramArray, ProgramObject } from "../interpreter/objects.js";
 import { containsOpaqueReference, containsRuntimeReference, isRuntimeReference } from "../interpreter/references.js";
-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;
-    }),
-])));
+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"]);
 const MAX_CONSOLE_DEPTH = 32;
-const formatConsoleMessage = (name, args) => {
+export const formatConsoleMessage = (name, args) => {
     if (name === "dir")
         return args.length === 0 ? "undefined" : formatConsoleArgument(args[0]);
     if (name === "table")
@@ -38,34 +28,34 @@ const formatConsoleValue = (value, seen, depth) => {
         return String(value);
     if (typeof value !== "object")
         return String(value);
-    if (value instanceof Values.Promise)
+    if (value instanceof CodeModePromise)
         return "[Promise (await it to get its value)]";
-    if (value instanceof Values.Date)
+    if (value instanceof CodeModeDate)
         return coerceToString(value);
-    if (value instanceof Values.RegExp)
+    if (value instanceof CodeModeRegExp)
         return coerceToString(value);
-    if (value instanceof Values.URL)
+    if (value instanceof CodeModeURL)
         return coerceToString(value);
-    if (value instanceof Values.URLSearchParams)
+    if (value instanceof CodeModeURLSearchParams)
         return coerceToString(value);
     if (depth > MAX_CONSOLE_DEPTH)
         return "...";
     if (seen.has(value))
         return "[Circular]";
-    if (value instanceof Values.Map) {
+    if (value instanceof CodeModeMap) {
         seen.add(value);
         try {
-            const entries = Array.from(value.map.entries(), ([key, item]) => new ProgramArray([key, item]));
-            return `Map(${value.map.size}) ${formatConsoleValue(new ProgramArray(entries), seen, depth + 1)}`;
+            const entries = Array.from(value.map.entries(), ([key, item]) => [key, item]);
+            return `Map(${value.map.size}) ${formatConsoleValue(entries, seen, depth + 1)}`;
         }
         finally {
             seen.delete(value);
         }
     }
-    if (value instanceof Values.Set) {
+    if (value instanceof CodeModeSet) {
         seen.add(value);
         try {
-            return `Set(${value.set.size}) ${formatConsoleValue(new ProgramArray([...value.set.values()]), seen, depth + 1)}`;
+            return `Set(${value.set.size}) ${formatConsoleValue(Array.from(value.set.values()), seen, depth + 1)}`;
         }
         finally {
             seen.delete(value);
@@ -75,12 +65,10 @@ const formatConsoleValue = (value, seen, depth) => {
         return "[opaque reference]";
     seen.add(value);
     try {
-        if (value instanceof ProgramArray) {
-            return `[${value.items.map((item) => formatConsoleValue(item, seen, depth + 1)).join(",")}]`;
+        if (Array.isArray(value)) {
+            return `[${value.map((item) => formatConsoleValue(item, seen, depth + 1)).join(",")}]`;
         }
-        if (!(value instanceof ProgramObject))
-            return "[object Object]";
-        return `{${ownEntries(value)
+        return `{${Object.entries(value)
             .map(([key, item]) => `${JSON.stringify(key)}:${formatConsoleValue(item, seen, depth + 1)}`)
             .join(",")}}`;
     }
@@ -93,7 +81,7 @@ const formatConsoleTable = (value, columnsArgument) => {
         return "undefined";
     if (containsOpaqueReference(value))
         return "[opaque reference]";
-    const data = toProgram(value, "console.table argument");
+    const data = boundedData(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))));
@@ -108,23 +96,24 @@ const consoleTableColumns = (value) => {
         return undefined;
     if (containsRuntimeReference(value))
         return undefined;
-    const columns = toData(value, "console.table columns", "result");
+    const columns = copyOut(copyIn(value, "console.table columns"), "nullify");
     return Array.isArray(columns) ? columns.map((column) => String(column)) : undefined;
 };
 const consoleTableRows = (data, columns) => {
-    if (data instanceof ProgramArray) {
-        return data.items.map((item, index) => ({ index: String(index), values: consoleTableValues(item, columns) }));
+    if (Array.isArray(data)) {
+        return data.map((item, index) => ({ index: String(index), values: consoleTableValues(item, columns) }));
     }
-    if (data instanceof ProgramObject) {
-        return ownEntries(data).map(([index, item]) => ({ index, values: consoleTableValues(item, columns) }));
+    if (data !== null && typeof data === "object" && !isCodeModeValue(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 instanceof ProgramObject && !(value instanceof ProgramArray)) {
+    if (value !== null && typeof value === "object" && !Array.isArray(value) && !isCodeModeValue(value)) {
+        const source = value;
         if (columns !== undefined)
-            return Object.fromEntries(columns.map((column) => [column, get(value, column)]));
-        return Object.fromEntries(ownEntries(value));
+            return Object.fromEntries(columns.map((column) => [column, source[column]]));
+        return Object.fromEntries(Object.entries(source));
     }
     return { Value: value };
 };

package/dist/stdlib/date.d.ts

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

package/dist/stdlib/date.js

@@ -1,8 +1,5 @@
-import { Effect } from "effect";
-import { HostFunction, sync } from "../interpreter/host.js";
 import { InterpreterRuntimeError } from "../interpreter/model.js";
-import { toPrimitive } from "../interpreter/runner.js";
-import { Values } from "../values.js";
+import { CodeModeDate } from "../values.js";
 import { coerceToNumber, coerceToString } from "./value.js";
 const dateSetterArguments = new Map([
     ["setTime", 1],
@@ -27,8 +24,6 @@ export const dateMethods = new Set([
     "toISOString",
     "toJSON",
     "toString",
-    "toDateString",
-    "toTimeString",
     "toUTCString",
     "toGMTString",
     "getFullYear",
@@ -50,32 +45,19 @@ export const dateMethods = new Set([
     "getTimezoneOffset",
     ...dateSetterArguments.keys(),
 ]);
-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()));
+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 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);
@@ -91,10 +73,6 @@ export const invokeDateMethod = (value, name, args, node, initialTime = value.ti
             return Number.isFinite(value.time) ? hosted.toISOString() : null;
         case "toString":
             return coerceToString(value);
-        case "toDateString":
-            return hosted.toDateString();
-        case "toTimeString":
-            return hosted.toTimeString();
         case "toUTCString":
         case "toGMTString":
             return hosted.toUTCString();

package/dist/stdlib/json.d.ts

@@ -1,3 +1,6 @@
-import { HostNamespace } from "../interpreter/host.js";
-import { type Runner } from "../interpreter/runner.js";
-export declare const jsonGlobal: <R>(runner: Runner<R>) => HostNamespace;
+import { Effect } from "effect";
+import type { CallbackRunner } from "../interpreter/methods.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>;

package/dist/stdlib/json.js

@@ -1,22 +1,20 @@
 import { Effect } from "effect";
-import { HostFunction, HostNamespace } from "../interpreter/host.js";
-import { applyCollectionCallback } from "../interpreter/runner.js";
+import { applyCollectionCallback } from "../interpreter/methods.js";
 import { InterpreterRuntimeError } from "../interpreter/model.js";
 import { typeofValue } from "../interpreter/references.js";
-import { fromData, toData, toProgram } from "../data.js";
-import { get, ownKeys, ProgramArray, ProgramObject, record, remove, set } from "../interpreter/objects.js";
-import { Values } from "../values.js";
-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) }),
-});
+import { copyIn, copyOut } from "../tool-runtime.js";
+import { CodeModeDate, CodeModeMap, CodeModeRegExp, CodeModeSet, CodeModeURL, CodeModeURLSearchParams, } from "../values.js";
+export const jsonStatics = new Set(["parse", "stringify"]);
+export const invokeJsonMethod = (runner, name, args, node) => {
+    return name === "parse" ? parse(runner, 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 fromData(JSON.parse(text), "JSON.parse result");
+            return copyIn(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");
@@ -25,63 +23,80 @@ const parse = (runner, args, node) => {
     if (typeofValue(args[1]) !== "function")
         return Effect.succeed(parsed);
     const apply = applyCollectionCallback(runner, args[1], "JSON.parse", node);
+    const root = Object.create(null);
+    root[""] = parsed;
     const visit = (holder, key) => Effect.gen(function* () {
-        const value = get(holder, key);
-        if (value instanceof ProgramObject) {
-            for (const name of ownKeys(value)) {
+        const value = holder[key];
+        if (Array.isArray(value)) {
+            const length = value.length;
+            for (let index = 0; index < length; index += 1) {
+                const revived = yield* visit(value, String(index));
+                if (revived === undefined)
+                    Reflect.deleteProperty(value, index);
+                else
+                    value[index] = revived;
+            }
+        }
+        else if (isPlainObject(value)) {
+            for (const name of Object.keys(value)) {
                 const revived = yield* visit(value, name);
                 if (revived === undefined)
-                    remove(value, name);
+                    Reflect.deleteProperty(value, name);
                 else
-                    set(value, name, revived);
+                    value[name] = revived;
             }
         }
         return yield* apply([key, value]);
     });
-    return visit(record({ "": parsed }), "");
+    return visit(root, "");
 };
 const stringify = (runner, args, node) => {
     const space = args[2];
     const indent = typeof space === "number" || typeof space === "string" ? space : undefined;
     const replacer = args[1];
-    if (typeofValue(replacer) !== "function") {
-        const properties = replacer instanceof ProgramArray
-            ? replacer.items
-                .filter((item) => typeof item === "string" || typeof item === "number")
-                .map(String)
-            : null;
-        return Effect.succeed(JSON.stringify(toData(args[0], "JSON.stringify value"), properties, indent));
+    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));
     }
-    // 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;
     const stack = new Set();
     const visit = (holder, key) => Effect.gen(function* () {
-        const value = yield* apply([key, toJSONValue(get(holder, key))]);
+        const value = yield* apply([key, toJSONValue(holder[key])]);
         if (value === undefined || typeofValue(value) === "function")
             return undefined;
-        toProgram(value, "JSON.stringify replacer result");
+        copyIn(value, "JSON.stringify replacer result", true);
         if (typeof value === "number")
             return Number.isFinite(value) ? value : null;
         if (value === null || typeof value === "string" || typeof value === "boolean")
             return value;
-        if (!(value instanceof ProgramObject))
-            return {};
-        if (stack.has(value))
-            throw new InterpreterRuntimeError("Converting circular structure to JSON.", node).as("TypeError");
-        stack.add(value);
-        if (value instanceof ProgramArray) {
+        if (Array.isArray(value)) {
+            if (stack.has(value))
+                throw new InterpreterRuntimeError("Converting circular structure to JSON.", node).as("TypeError");
+            stack.add(value);
             const result = [];
-            for (let index = 0; index < value.items.length; index += 1) {
+            for (let index = 0; index < value.length; index += 1) {
                 result.push((yield* visit(value, String(index))) ?? null);
             }
             stack.delete(value);
             return result;
         }
+        if (!isPlainObject(value))
+            return {};
+        if (stack.has(value))
+            throw new InterpreterRuntimeError("Converting circular structure to JSON.", node).as("TypeError");
+        stack.add(value);
         const result = Object.create(null);
-        for (const name of ownKeys(value)) {
-            if (typeof name !== "string")
-                continue;
+        for (const name of Object.keys(value)) {
             const item = yield* visit(value, name);
             if (item !== undefined)
                 result[name] = item;
@@ -89,13 +104,21 @@ const stringify = (runner, args, node) => {
         stack.delete(value);
         return result;
     });
-    return Effect.map(visit(record({ "": args[0] }), ""), (value) => JSON.stringify(value, null, indent));
+    return Effect.map(visit(root, ""), (value) => JSON.stringify(value, null, indent));
 };
 const toJSONValue = (value) => {
-    if (value instanceof Values.Date) {
+    if (value instanceof CodeModeDate) {
         return Number.isFinite(value.time) ? new Date(value.time).toISOString() : null;
     }
-    if (value instanceof Values.URL)
+    if (value instanceof CodeModeURL)
         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);

package/dist/stdlib/math.d.ts

@@ -1,8 +1,12 @@
-import { HostNamespace } from "../interpreter/host.js";
-import { type Runner } from "../interpreter/runner.js";
+import { Effect } from "effect";
+import { type SyncIteratorRunner } from "../interpreter/iterator.js";
+import { type AstNode } from "../interpreter/model.js";
 declare global {
     interface Math {
         sumPrecise(values: Iterable<number>): number;
     }
 }
-export declare const mathGlobal: <R>(runner: Runner<R>) => HostNamespace;
+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>;