@opencode/codemode 0.0.0-reserved → 2.0.0

package/dist/stdlib/date.js

@@ -0,0 +1,208 @@
+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 { coerceToNumber, coerceToString } from "./value.js";
+const dateSetterArguments = new Map([
+    ["setTime", 1],
+    ["setMilliseconds", 1],
+    ["setUTCMilliseconds", 1],
+    ["setSeconds", 2],
+    ["setUTCSeconds", 2],
+    ["setMinutes", 3],
+    ["setUTCMinutes", 3],
+    ["setHours", 4],
+    ["setUTCHours", 4],
+    ["setDate", 1],
+    ["setUTCDate", 1],
+    ["setMonth", 2],
+    ["setUTCMonth", 2],
+    ["setFullYear", 3],
+    ["setUTCFullYear", 3],
+]);
+export const dateMethods = new Set([
+    "getTime",
+    "valueOf",
+    "toISOString",
+    "toJSON",
+    "toString",
+    "toDateString",
+    "toTimeString",
+    "toUTCString",
+    "toGMTString",
+    "getFullYear",
+    "getMonth",
+    "getDate",
+    "getDay",
+    "getHours",
+    "getMinutes",
+    "getSeconds",
+    "getMilliseconds",
+    "getUTCFullYear",
+    "getUTCMonth",
+    "getUTCDate",
+    "getUTCDay",
+    "getUTCHours",
+    "getUTCMinutes",
+    "getUTCSeconds",
+    "getUTCMilliseconds",
+    "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()));
+    }
+    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);
+    switch (name) {
+        case "getTime":
+        case "valueOf":
+            return value.time;
+        case "toISOString":
+            if (!Number.isFinite(value.time))
+                throw new InterpreterRuntimeError("Invalid time value.", node).as("RangeError");
+            return hosted.toISOString();
+        case "toJSON":
+            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();
+        case "getFullYear":
+            return hosted.getFullYear();
+        case "getMonth":
+            return hosted.getMonth();
+        case "getDate":
+            return hosted.getDate();
+        case "getDay":
+            return hosted.getDay();
+        case "getHours":
+            return hosted.getHours();
+        case "getMinutes":
+            return hosted.getMinutes();
+        case "getSeconds":
+            return hosted.getSeconds();
+        case "getMilliseconds":
+            return hosted.getMilliseconds();
+        case "getUTCFullYear":
+            return hosted.getUTCFullYear();
+        case "getUTCMonth":
+            return hosted.getUTCMonth();
+        case "getUTCDate":
+            return hosted.getUTCDate();
+        case "getUTCDay":
+            return hosted.getUTCDay();
+        case "getUTCHours":
+            return hosted.getUTCHours();
+        case "getUTCMinutes":
+            return hosted.getUTCMinutes();
+        case "getUTCSeconds":
+            return hosted.getUTCSeconds();
+        case "getUTCMilliseconds":
+            return hosted.getUTCMilliseconds();
+        case "getTimezoneOffset":
+            return hosted.getTimezoneOffset();
+        case "setTime":
+            return updateDate(value, hosted.setTime(args[0]));
+        case "setMilliseconds":
+            return updateDate(value, hosted.setMilliseconds(args[0]));
+        case "setUTCMilliseconds":
+            return updateDate(value, hosted.setUTCMilliseconds(args[0]));
+        case "setSeconds":
+            if (args.length < 2)
+                return updateDate(value, hosted.setSeconds(args[0]));
+            return updateDate(value, hosted.setSeconds(args[0], args[1]));
+        case "setUTCSeconds":
+            if (args.length < 2)
+                return updateDate(value, hosted.setUTCSeconds(args[0]));
+            return updateDate(value, hosted.setUTCSeconds(args[0], args[1]));
+        case "setMinutes":
+            if (args.length < 2)
+                return updateDate(value, hosted.setMinutes(args[0]));
+            if (args.length < 3)
+                return updateDate(value, hosted.setMinutes(args[0], args[1]));
+            return updateDate(value, hosted.setMinutes(args[0], args[1], args[2]));
+        case "setUTCMinutes":
+            if (args.length < 2)
+                return updateDate(value, hosted.setUTCMinutes(args[0]));
+            if (args.length < 3)
+                return updateDate(value, hosted.setUTCMinutes(args[0], args[1]));
+            return updateDate(value, hosted.setUTCMinutes(args[0], args[1], args[2]));
+        case "setHours":
+            if (args.length < 2)
+                return updateDate(value, hosted.setHours(args[0]));
+            if (args.length < 3)
+                return updateDate(value, hosted.setHours(args[0], args[1]));
+            if (args.length < 4)
+                return updateDate(value, hosted.setHours(args[0], args[1], args[2]));
+            return updateDate(value, hosted.setHours(args[0], args[1], args[2], args[3]));
+        case "setUTCHours":
+            if (args.length < 2)
+                return updateDate(value, hosted.setUTCHours(args[0]));
+            if (args.length < 3)
+                return updateDate(value, hosted.setUTCHours(args[0], args[1]));
+            if (args.length < 4)
+                return updateDate(value, hosted.setUTCHours(args[0], args[1], args[2]));
+            return updateDate(value, hosted.setUTCHours(args[0], args[1], args[2], args[3]));
+        case "setDate":
+            return updateDate(value, hosted.setDate(args[0]));
+        case "setUTCDate":
+            return updateDate(value, hosted.setUTCDate(args[0]));
+        case "setMonth":
+            if (args.length < 2)
+                return updateDate(value, hosted.setMonth(args[0]));
+            return updateDate(value, hosted.setMonth(args[0], args[1]));
+        case "setUTCMonth":
+            if (args.length < 2)
+                return updateDate(value, hosted.setUTCMonth(args[0]));
+            return updateDate(value, hosted.setUTCMonth(args[0], args[1]));
+        case "setFullYear":
+            if (args.length < 2)
+                return updateDate(value, hosted.setFullYear(args[0]));
+            if (args.length < 3)
+                return updateDate(value, hosted.setFullYear(args[0], args[1]));
+            return updateDate(value, hosted.setFullYear(args[0], args[1], args[2]));
+        case "setUTCFullYear":
+            if (args.length < 2)
+                return updateDate(value, hosted.setUTCFullYear(args[0]));
+            if (args.length < 3)
+                return updateDate(value, hosted.setUTCFullYear(args[0], args[1]));
+            return updateDate(value, hosted.setUTCFullYear(args[0], args[1], args[2]));
+        default:
+            throw new InterpreterRuntimeError(`Date method '${name}' is not available.`, node);
+    }
+};
+const updateDate = (value, time) => {
+    value.time = time;
+    return time;
+};

package/dist/stdlib/json.d.ts

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

package/dist/stdlib/json.js

@@ -0,0 +1,101 @@
+import { Effect } from "effect";
+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 { 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) }),
+});
+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");
+        }
+        catch (error) {
+            throw new InterpreterRuntimeError(`JSON.parse received invalid JSON: ${error instanceof Error ? error.message : String(error)}`, node).as("SyntaxError");
+        }
+    })();
+    if (typeofValue(args[1]) !== "function")
+        return Effect.succeed(parsed);
+    const apply = applyCollectionCallback(runner, args[1], "JSON.parse", node);
+    const visit = (holder, key) => Effect.gen(function* () {
+        const value = get(holder, key);
+        if (value instanceof ProgramObject) {
+            for (const name of ownKeys(value)) {
+                const revived = yield* visit(value, name);
+                if (revived === undefined)
+                    remove(value, name);
+                else
+                    set(value, name, revived);
+            }
+        }
+        return yield* apply([key, value]);
+    });
+    return visit(record({ "": parsed }), "");
+};
+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));
+    }
+    // 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 stack = new Set();
+    const visit = (holder, key) => Effect.gen(function* () {
+        const value = yield* apply([key, toJSONValue(get(holder, key))]);
+        if (value === undefined || typeofValue(value) === "function")
+            return undefined;
+        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")
+            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) {
+            const result = [];
+            for (let index = 0; index < value.items.length; index += 1) {
+                result.push((yield* visit(value, String(index))) ?? null);
+            }
+            stack.delete(value);
+            return result;
+        }
+        const result = Object.create(null);
+        for (const name of ownKeys(value)) {
+            if (typeof name !== "string")
+                continue;
+            const item = yield* visit(value, name);
+            if (item !== undefined)
+                result[name] = item;
+        }
+        stack.delete(value);
+        return result;
+    });
+    return Effect.map(visit(record({ "": args[0] }), ""), (value) => JSON.stringify(value, null, indent));
+};
+const toJSONValue = (value) => {
+    if (value instanceof Values.Date) {
+        return Number.isFinite(value.time) ? new Date(value.time).toISOString() : null;
+    }
+    if (value instanceof Values.URL)
+        return value.url.href;
+    return value;
+};

package/dist/stdlib/math.d.ts

@@ -0,0 +1,8 @@
+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 mathGlobal: <R>(runner: Runner<R>) => HostNamespace;

package/dist/stdlib/math.js

@@ -0,0 +1,89 @@
+import { Effect } from "effect";
+import { HostFunction, HostNamespace, sync } from "../interpreter/host.js";
+import { preserveConsumerError } from "../interpreter/runner.js";
+import { InterpreterRuntimeError } from "../interpreter/model.js";
+// Validate only the arguments a method consumes; like JS, extras are ignored
+// (so built-ins work as callbacks receiving (element, index, array)).
+const number = (name, args, index, node) => {
+    if (index >= args.length)
+        return Number.NaN;
+    const arg = args[index];
+    if (typeof arg !== "number")
+        throw new InterpreterRuntimeError(`Math.${name} expects number arguments.`, node);
+    return arg;
+};
+const unary = (name, op) => sync(`Math.${name}`, (args, node) => op(number(name, args, 0, node)));
+const binary = (name, op) => sync(`Math.${name}`, (args, node) => op(number(name, args, 0, node), number(name, args, 1, node)));
+const variadic = (name, op) => sync(`Math.${name}`, (args, node) => op(...args.map((arg) => {
+    if (typeof arg !== "number")
+        throw new InterpreterRuntimeError(`Math.${name} expects number arguments.`, node);
+    return arg;
+})));
+const sumPrecise = (runner) => new HostFunction({
+    name: "Math.sumPrecise",
+    call: (args, node) => Effect.gen(function* () {
+        const cursor = yield* runner.syncIterator(args[0], node);
+        if (cursor === undefined) {
+            throw new InterpreterRuntimeError("Math.sumPrecise expects a synchronous iterable.", node).as("TypeError");
+        }
+        const numbers = [];
+        while (true) {
+            const step = yield* cursor.next;
+            if (step.done)
+                return Math.sumPrecise(numbers);
+            yield* preserveConsumerError(cursor, Effect.sync(() => {
+                if (typeof step.value !== "number") {
+                    throw new InterpreterRuntimeError("Math.sumPrecise expects an iterable of numbers.", node).as("TypeError");
+                }
+                numbers.push(step.value);
+            }));
+        }
+    }),
+});
+export const mathGlobal = (runner) => new HostNamespace("Math", {
+    PI: Math.PI,
+    E: Math.E,
+    LN2: Math.LN2,
+    LN10: Math.LN10,
+    LOG2E: Math.LOG2E,
+    LOG10E: Math.LOG10E,
+    SQRT2: Math.SQRT2,
+    SQRT1_2: Math.SQRT1_2,
+    random: sync("Math.random", () => Math.random()),
+    max: variadic("max", Math.max),
+    min: variadic("min", Math.min),
+    hypot: variadic("hypot", Math.hypot),
+    abs: unary("abs", Math.abs),
+    acos: unary("acos", Math.acos),
+    acosh: unary("acosh", Math.acosh),
+    asin: unary("asin", Math.asin),
+    asinh: unary("asinh", Math.asinh),
+    atan: unary("atan", Math.atan),
+    atan2: binary("atan2", Math.atan2),
+    atanh: unary("atanh", Math.atanh),
+    floor: unary("floor", Math.floor),
+    ceil: unary("ceil", Math.ceil),
+    round: unary("round", Math.round),
+    trunc: unary("trunc", Math.trunc),
+    sign: unary("sign", Math.sign),
+    sqrt: unary("sqrt", Math.sqrt),
+    cbrt: unary("cbrt", Math.cbrt),
+    pow: binary("pow", Math.pow),
+    cos: unary("cos", Math.cos),
+    cosh: unary("cosh", Math.cosh),
+    sin: unary("sin", Math.sin),
+    sinh: unary("sinh", Math.sinh),
+    tan: unary("tan", Math.tan),
+    tanh: unary("tanh", Math.tanh),
+    log: unary("log", Math.log),
+    log2: unary("log2", Math.log2),
+    log10: unary("log10", Math.log10),
+    log1p: unary("log1p", Math.log1p),
+    exp: unary("exp", Math.exp),
+    expm1: unary("expm1", Math.expm1),
+    f16round: unary("f16round", Math.f16round),
+    fround: unary("fround", Math.fround),
+    clz32: unary("clz32", Math.clz32),
+    imul: binary("imul", Math.imul),
+    sumPrecise: sumPrecise(runner),
+});

package/dist/stdlib/number.d.ts

@@ -0,0 +1,4 @@
+import { type AstNode } from "../interpreter/model.js";
+export declare const numberMethods: Set<string>;
+export declare const invokeNumberMethod: (value: number, name: string, args: Array<unknown>, node: AstNode) => unknown;
+export declare const numberGlobal: import("../interpreter/host.js").HostFunction<never>;

package/dist/stdlib/number.js

@@ -0,0 +1,69 @@
+import { toProgram } from "../data.js";
+import { sync } from "../interpreter/host.js";
+import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { coercion, coerceToString } from "./value.js";
+export const numberMethods = new Set(["toFixed", "toPrecision", "toExponential", "toString", "valueOf"]);
+export const invokeNumberMethod = (value, name, args, node) => {
+    const optNum = (index) => {
+        const arg = args[index];
+        if (arg === undefined)
+            return undefined;
+        if (typeof arg !== "number")
+            throw new InterpreterRuntimeError(`Number.${name} expects a number argument.`, node);
+        return arg;
+    };
+    let result;
+    switch (name) {
+        case "toFixed":
+            result = value.toFixed(optNum(0));
+            break;
+        case "toExponential":
+            result = value.toExponential(optNum(0));
+            break;
+        case "toPrecision": {
+            const digits = optNum(0);
+            result = digits === undefined ? value.toString() : value.toPrecision(digits);
+            break;
+        }
+        case "toString": {
+            const radix = optNum(0);
+            if (radix !== undefined && (radix < 2 || radix > 36)) {
+                throw new InterpreterRuntimeError("Number.toString radix must be between 2 and 36.", node);
+            }
+            result = value.toString(radix);
+            break;
+        }
+        case "valueOf":
+            result = value;
+            break;
+        default:
+            throw new InterpreterRuntimeError(`Number method '${name}' is not available.`, node);
+    }
+    return toProgram(result, `Number.${name} result`);
+};
+const parseIntStatic = sync("Number.parseInt", (args, node) => {
+    const radix = args[1];
+    if (radix !== undefined && typeof radix !== "number") {
+        throw new InterpreterRuntimeError("Number.parseInt expects a numeric radix.", node);
+    }
+    return parseInt(coerceToString(args[0]), radix);
+});
+export const numberGlobal = coercion("Number", {
+    instanceOf: () => false,
+    members: {
+        MAX_SAFE_INTEGER: Number.MAX_SAFE_INTEGER,
+        MIN_SAFE_INTEGER: Number.MIN_SAFE_INTEGER,
+        MAX_VALUE: Number.MAX_VALUE,
+        MIN_VALUE: Number.MIN_VALUE,
+        EPSILON: Number.EPSILON,
+        NaN: Number.NaN,
+        POSITIVE_INFINITY: Number.POSITIVE_INFINITY,
+        NEGATIVE_INFINITY: Number.NEGATIVE_INFINITY,
+        isInteger: sync("Number.isInteger", (args) => Number.isInteger(args[0])),
+        isFinite: sync("Number.isFinite", (args) => Number.isFinite(args[0])),
+        isNaN: sync("Number.isNaN", (args) => Number.isNaN(args[0])),
+        isSafeInteger: sync("Number.isSafeInteger", (args) => Number.isSafeInteger(args[0])),
+        parseInt: parseIntStatic,
+        parseFloat: sync("Number.parseFloat", (args) => parseFloat(coerceToString(args[0]))),
+    },
+});

package/dist/stdlib/object.d.ts

@@ -0,0 +1,7 @@
+import { HostFunction } from "../interpreter/host.js";
+import { type AstNode } from "../interpreter/model.js";
+import { ProgramObject } from "../interpreter/objects.js";
+import { type Runner } from "../interpreter/runner.js";
+export declare const enumerableSource: (label: string, value: unknown, node: AstNode) => ProgramObject;
+export declare const objectAssign: (args: Array<unknown>, node: AstNode) => unknown;
+export declare const objectGlobal: <R>(runner: Runner<R>, toolKeys: (path: ReadonlyArray<string>) => ReadonlyArray<string>) => HostFunction<R>;

package/dist/stdlib/object.js

@@ -0,0 +1,106 @@
+import { Effect } from "effect";
+import { toProgram } from "../data.js";
+import { HostFunction, sync, syncCall } from "../interpreter/host.js";
+import { AsyncIteratorSymbol, InterpreterRuntimeError, IteratorSymbol } from "../interpreter/model.js";
+import { getOwn, hasOwn, ownEntries, ownKeys, ProgramArray, ProgramObject, set } from "../interpreter/objects.js";
+import { containsOpaqueReference, describeValue, rejectCircularInsertion, typeofValue, } from "../interpreter/references.js";
+import { preserveConsumerError } from "../interpreter/runner.js";
+import { ToolReference } from "../tool-runtime.js";
+import { Values } from "../values.js";
+import { groupBy } from "./collections.js";
+import { coerceToString } from "./value.js";
+// ToObject for enumeration.
+export const enumerableSource = (label, value, node) => {
+    if (value === null || value === undefined) {
+        throw new InterpreterRuntimeError(`${label} cannot convert ${describeValue(value)} to an object.`, node).as("TypeError");
+    }
+    if (value instanceof Values.Promise) {
+        throw new InterpreterRuntimeError(`${label} received an un-awaited Promise; await it before inspecting the result.`, node, "InvalidDataValue");
+    }
+    if (value instanceof ToolReference) {
+        throw new InterpreterRuntimeError(`${label} cannot read tool references: they are not plain data. Use Object.keys(tools) for names, or search({ query }) for signatures.`, node, "InvalidDataValue");
+    }
+    if (typeof value === "string")
+        return new ProgramArray([...value]);
+    if (value instanceof ProgramObject)
+        return value;
+    return new ProgramObject();
+};
+export const objectAssign = (args, node) => {
+    const target = args[0];
+    // JS would box a primitive target; wrappers and primitives cannot hold fields here.
+    if (!(target instanceof ProgramObject)) {
+        throw new InterpreterRuntimeError(`Object.assign expects a data object or array target, received ${describeValue(target)}.`, node).as("TypeError");
+    }
+    const seen = new Set();
+    for (const source of args.slice(1)) {
+        if (source === null || source === undefined)
+            continue;
+        const from = enumerableSource("Object.assign(...)", source, node);
+        for (const key of ownKeys(from)) {
+            if (typeof key === "symbol" && key !== AsyncIteratorSymbol && key !== IteratorSymbol)
+                continue;
+            rejectCircularInsertion(target, getOwn(from, key), "Object.assign result", node, seen);
+            if (!set(target, key, getOwn(from, key))) {
+                throw new InterpreterRuntimeError("Invalid array length", node).as("RangeError");
+            }
+        }
+    }
+    return target;
+};
+const objectFromEntries = (runner, source, node) => {
+    const out = new ProgramObject();
+    return Effect.gen(function* () {
+        const cursor = yield* runner.syncIterator(source, node);
+        if (cursor === undefined) {
+            throw new InterpreterRuntimeError("Object.fromEntries expects a synchronous iterable of entries.", node).as("TypeError");
+        }
+        while (true) {
+            const step = yield* cursor.next;
+            if (step.done)
+                return out;
+            yield* preserveConsumerError(cursor, Effect.sync(() => {
+                if (!(step.value instanceof ProgramObject) || containsOpaqueReference(step.value)) {
+                    throw new InterpreterRuntimeError("Object.fromEntries expects [key, value] entry objects.", node).as("TypeError");
+                }
+                set(out, coerceToString(getOwn(step.value, 0)), getOwn(step.value, 1));
+            }));
+        }
+    });
+};
+const constructObject = (args, node) => {
+    const first = args[0];
+    if (first === null || first === undefined)
+        return new ProgramObject();
+    if (typeof first === "object")
+        return first;
+    throw new InterpreterRuntimeError(`Object(${typeof first}) wrapper objects are not supported; use the primitive value directly.`, node);
+};
+// Object constructs identically with or without new, like JS. Only `keys` copies its result into the
+// program; `values`, `entries`, `assign`, and `fromEntries` hand back the program's own values.
+export const objectGlobal = (runner, toolKeys) => new HostFunction({
+    name: "Object",
+    call: syncCall(constructObject),
+    construct: syncCall(constructObject),
+    instanceOf: (value) => value !== null && (typeof value === "object" || typeofValue(value) === "function"),
+    members: {
+        keys: sync("Object.keys", (args, node) => toProgram(args[0] instanceof ToolReference
+            ? [...toolKeys(args[0].path)]
+            : ownKeys(enumerableSource("Object.keys(...)", args[0], node)).filter((key) => typeof key === "string"), "Object.keys result")),
+        values: sync("Object.values", (args, node) => new ProgramArray(ownEntries(enumerableSource("Object.values(...)", args[0], node)).map((entry) => entry[1]))),
+        entries: sync("Object.entries", (args, node) => new ProgramArray(ownEntries(enumerableSource("Object.entries(...)", args[0], node)).map((entry) => new ProgramArray(entry)))),
+        hasOwn: sync("Object.hasOwn", (args, node) => hasOwn(enumerableSource("Object.hasOwn(...)", args[0], node), args[1] === AsyncIteratorSymbol || args[1] === IteratorSymbol ? args[1] : String(args[1]))),
+        is: sync("Object.is", (args, node) => {
+            if (containsOpaqueReference(args[0]) || containsOpaqueReference(args[1])) {
+                throw new InterpreterRuntimeError("Object.is requires data values.", node, "InvalidDataValue");
+            }
+            return Object.is(args[0], args[1]);
+        }),
+        assign: sync("Object.assign", objectAssign),
+        fromEntries: new HostFunction({
+            name: "Object.fromEntries",
+            call: (args, node) => Effect.suspend(() => objectFromEntries(runner, args[0], node)),
+        }),
+        groupBy: groupBy(runner, "Object"),
+    },
+});

package/dist/stdlib/regexp.d.ts

@@ -0,0 +1,10 @@
+import { type AstNode } from "../interpreter/model.js";
+import { ProgramArray } from "../interpreter/objects.js";
+import { Values } from "../values.js";
+export declare const regexpMethods: Set<string>;
+export declare const regexpProperties: Set<string>;
+export declare const toHostRegex: (arg: unknown, method: string, node: AstNode, extraFlags?: string) => RegExp;
+export declare const matchToValue: (match: RegExpMatchArray) => ProgramArray;
+export declare const constructRegExp: (args: Array<unknown>, node: AstNode) => Values.RegExp;
+export declare const regexpGlobal: import("../interpreter/host.js").HostFunction<never>;
+export declare const invokeRegExpMethod: (value: Values.RegExp, name: string, args: Array<unknown>, node: AstNode) => unknown;