@opencode/codemode 0.0.0-dev-19530 → 2.0.0

package/dist/stdlib/number.js

@@ -1,14 +1,56 @@
-import { constructor, constants, methods } from "../interpreter/native.js";
-import { InterpreterRuntimeError, rangeError } from "../interpreter/model.js";
+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 numberGlobal = (runner) => {
-    const protos = runner.prototypes;
-    const number = constructor(protos, protos.Number, {
-        name: "Number",
-        length: 1,
-        call: coercion(runner, "Number").call,
-    });
-    constants(number, {
+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,
@@ -17,88 +59,11 @@ export const numberGlobal = (runner) => {
         NaN: Number.NaN,
         POSITIVE_INFINITY: Number.POSITIVE_INFINITY,
         NEGATIVE_INFINITY: Number.NEGATIVE_INFINITY,
-    });
-    methods(protos, number, [
-        ["isInteger", 1, (_, args) => Number.isInteger(args[0])],
-        ["isFinite", 1, (_, args) => Number.isFinite(args[0])],
-        ["isNaN", 1, (_, args) => Number.isNaN(args[0])],
-        ["isSafeInteger", 1, (_, args) => Number.isSafeInteger(args[0])],
-        [
-            "parseInt",
-            2,
-            (_, 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);
-            },
-        ],
-        ["parseFloat", 1, (_, args) => parseFloat(coerceToString(args[0]))],
-    ]);
-    const self = (thisValue, name, node) => {
-        if (typeof thisValue === "number")
-            return thisValue;
-        throw new InterpreterRuntimeError(`Number.prototype.${name} requires that 'this' be a Number.`, node);
-    };
-    const optNum = (name, arg, node) => {
-        if (arg === undefined)
-            return undefined;
-        if (typeof arg !== "number")
-            throw new InterpreterRuntimeError(`Number.${name} expects a number argument.`, node);
-        return arg;
-    };
-    methods(protos, protos.Number, [
-        [
-            "toFixed",
-            1,
-            (thisValue, args, node) => self(thisValue, "toFixed", node).toFixed(optNum("toFixed", args[0], node)),
-        ],
-        [
-            "toExponential",
-            1,
-            (thisValue, args, node) => self(thisValue, "toExponential", node).toExponential(optNum("toExponential", args[0], node)),
-        ],
-        [
-            "toPrecision",
-            1,
-            (thisValue, args, node) => {
-                const value = self(thisValue, "toPrecision", node);
-                const digits = optNum("toPrecision", args[0], node);
-                return digits === undefined ? value.toString() : value.toPrecision(digits);
-            },
-        ],
-        [
-            "toString",
-            1,
-            (thisValue, args, node) => {
-                const value = self(thisValue, "toString", node);
-                const radix = optNum("toString", args[0], node);
-                if (radix !== undefined && (radix < 2 || radix > 36)) {
-                    throw rangeError("Number.toString radix must be between 2 and 36.", node);
-                }
-                return value.toString(radix);
-            },
-        ],
-        ["valueOf", 0, (thisValue, _, node) => self(thisValue, "valueOf", node)],
-    ]);
-    return number;
-};
-export const booleanGlobal = (runner) => {
-    const protos = runner.prototypes;
-    const boolean = constructor(protos, protos.Boolean, {
-        name: "Boolean",
-        length: 1,
-        call: coercion(runner, "Boolean").call,
-    });
-    const self = (thisValue, name, node) => {
-        if (typeof thisValue === "boolean")
-            return thisValue;
-        throw new InterpreterRuntimeError(`Boolean.prototype.${name} requires that 'this' be a Boolean.`, node);
-    };
-    methods(protos, protos.Boolean, [
-        ["toString", 0, (thisValue, _, node) => String(self(thisValue, "toString", node))],
-        ["valueOf", 0, (thisValue, _, node) => self(thisValue, "valueOf", node)],
-    ]);
-    return boolean;
-};
+        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

@@ -1,7 +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: <R>(runner: Runner<R>, label: string, value: unknown, node: AstNode) => ProgramObject;
-export declare const objectAssign: <R>(runner: Runner<R>, args: Array<unknown>, node: AstNode) => unknown;
-export declare const classTag: (value: unknown) => string;
-export declare const objectGlobal: <R>(runner: Runner<R>, toolKeys: (path: ReadonlyArray<string>) => ReadonlyArray<string>) => import("../interpreter/objects.js").NativeFunction<R>;
+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

@@ -1,58 +1,59 @@
 import { Effect } from "effect";
 import { toProgram } from "../data.js";
-import { constructor, methods, receiver } from "../interpreter/native.js";
-import { AsyncIteratorSymbol, InterpreterRuntimeError, IteratorSymbol, rangeError, } from "../interpreter/model.js";
-import { Callable, define, entries, enumerableKeys, getOwn, hasOwn, hasPrototype, hidden, keys, own, ProgramArray, ProgramDate, ProgramError, ProgramObject, ProgramPromise, ProgramRegExp, set, } from "../interpreter/objects.js";
-import { containsOpaqueReference, describeValue, rejectCircularInsertion } from "../interpreter/references.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 = (runner, label, value, node) => {
+export const enumerableSource = (label, value, node) => {
     if (value === null || value === undefined) {
-        throw new InterpreterRuntimeError(`${label} cannot convert ${describeValue(value)} to an object.`, node);
+        throw new InterpreterRuntimeError(`${label} cannot convert ${describeValue(value)} to an object.`, node).as("TypeError");
     }
-    if (value instanceof ProgramPromise) {
+    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(runner.prototypes.Array, [...value]);
+        return new ProgramArray([...value]);
     if (value instanceof ProgramObject)
         return value;
-    return new ProgramObject(runner.prototypes.Object);
+    return new ProgramObject();
 };
-export const objectAssign = (runner, args, node) => {
+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);
+        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(runner, "Object.assign(...)", source, node);
-        for (const key of enumerableKeys(from)) {
+        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))) {
-                if (target instanceof ProgramArray && key === "length")
-                    throw rangeError("Invalid array length", node);
-                throw new InterpreterRuntimeError(`Cannot assign to read only property '${String(key)}'.`, node);
+                throw new InterpreterRuntimeError("Invalid array length", node).as("RangeError");
             }
         }
     }
     return target;
 };
 const objectFromEntries = (runner, source, node) => {
-    const out = new ProgramObject(runner.prototypes.Object);
+    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);
+            throw new InterpreterRuntimeError("Object.fromEntries expects a synchronous iterable of entries.", node).as("TypeError");
         }
         while (true) {
             const step = yield* cursor.next;
@@ -60,121 +61,46 @@ const objectFromEntries = (runner, source, node) => {
                 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);
+                    throw new InterpreterRuntimeError("Object.fromEntries expects [key, value] entry objects.", node).as("TypeError");
                 }
-                define(out, coerceToString(getOwn(step.value, 0)), getOwn(step.value, 1));
+                set(out, coerceToString(getOwn(step.value, 0)), getOwn(step.value, 1));
             }));
         }
     });
 };
-export const classTag = (value) => {
-    if (value === null)
-        return "Null";
-    if (value === undefined)
-        return "Undefined";
-    if (value instanceof ProgramArray)
-        return "Array";
-    if (value instanceof Callable)
-        return "Function";
-    if (value instanceof ProgramError)
-        return "Error";
-    if (value instanceof ProgramDate)
-        return "Date";
-    if (value instanceof ProgramRegExp)
-        return "RegExp";
-    if (typeof value === "string")
-        return "String";
-    if (typeof value === "number")
-        return "Number";
-    if (typeof value === "boolean")
-        return "Boolean";
-    return "Object";
+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);
 };
-const propertyKey = (value) => value === AsyncIteratorSymbol || value === IteratorSymbol ? value : coerceToString(value);
 // 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) => {
-    const protos = runner.prototypes;
-    const construct = (args, node) => {
-        const first = args[0];
-        if (first === null || first === undefined)
-            return new ProgramObject(protos.Object);
-        if (typeof first === "object")
-            return first;
-        throw new InterpreterRuntimeError(`Object(${typeof first}) wrapper objects are not supported; use the primitive value directly.`, node);
-    };
-    const object = constructor(protos, protos.Object, {
-        name: "Object",
-        length: 1,
-        call: (_, args, node) => Effect.sync(() => construct(args, node)),
-        construct: (args, _, node) => Effect.sync(() => construct(args, node)),
-    });
-    methods(protos, object, [
-        [
-            "keys",
-            1,
-            (_, args, node) => toProgram(protos, args[0] instanceof ToolReference
-                ? [...toolKeys(args[0].path)]
-                : keys(enumerableSource(runner, "Object.keys(...)", args[0], node)), "Object.keys result"),
-        ],
-        [
-            "values",
-            1,
-            (_, args, node) => new ProgramArray(protos.Array, entries(enumerableSource(runner, "Object.values(...)", args[0], node)).map((entry) => entry[1])),
-        ],
-        [
-            "entries",
-            1,
-            (_, args, node) => new ProgramArray(protos.Array, entries(enumerableSource(runner, "Object.entries(...)", args[0], node)).map((entry) => new ProgramArray(protos.Array, entry))),
-        ],
-        [
-            "hasOwn",
-            2,
-            (_, args, node) => hasOwn(enumerableSource(runner, "Object.hasOwn(...)", args[0], node), propertyKey(args[1])),
-        ],
-        [
-            "is",
-            2,
-            (_, 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", 2, (_, args, node) => objectAssign(runner, args, node)],
-        ["fromEntries", 1, (_, args, node) => objectFromEntries(runner, args[0], node)],
-    ]);
-    define(object, "groupBy", groupBy(runner, "Object"), hidden);
-    methods(protos, protos.Object, [
-        [
-            "hasOwnProperty",
-            1,
-            (thisValue, args, node) => hasOwn(receiver(ProgramObject, thisValue, "Object.prototype.hasOwnProperty", node), propertyKey(args[0])),
-        ],
-        [
-            "isPrototypeOf",
-            1,
-            (thisValue, args, node) => hasPrototype(args[0], receiver(ProgramObject, thisValue, "Object.prototype.isPrototypeOf", node)),
-        ],
-        [
-            "propertyIsEnumerable",
-            1,
-            (thisValue, args, node) => own(receiver(ProgramObject, thisValue, "Object.prototype.propertyIsEnumerable", node), propertyKey(args[0]))
-                ?.enumerable === true,
-        ],
-        ["toString", 0, (thisValue) => `[object ${classTag(thisValue)}]`],
-        ["toLocaleString", 0, (thisValue) => `[object ${classTag(thisValue)}]`],
-        [
-            "valueOf",
-            0,
-            (thisValue, _, node) => {
-                if (thisValue === null || thisValue === undefined) {
-                    throw new InterpreterRuntimeError("Object.prototype.valueOf called on null or undefined.", node);
-                }
-                return thisValue;
-            },
-        ],
-    ]);
-    return object;
-};
+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

@@ -1,8 +1,10 @@
-import type { Prototypes } from "../interpreter/intrinsics.js";
 import { type AstNode } from "../interpreter/model.js";
-import { ProgramArray, ProgramObject, ProgramRegExp } from "../interpreter/objects.js";
-import type { Runner } from "../interpreter/runner.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: (protos: Prototypes, match: RegExpMatchArray) => ProgramArray;
-export declare const constructRegExp: (protos: Prototypes, args: Array<unknown>, node: AstNode, proto?: ProgramObject) => ProgramRegExp;
-export declare const regexpGlobal: <R>(runner: Runner<R>) => import("../interpreter/objects.js").NativeFunction<R>;
+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;

package/dist/stdlib/regexp.js

@@ -1,9 +1,13 @@
-import { Effect } from "effect";
-import { constructor, methods, prototypeFrom, receiver } from "../interpreter/native.js";
-import { InterpreterRuntimeError, syntaxError } from "../interpreter/model.js";
-import { define, defineAccessor, getOwn, ProgramArray, ProgramObject, ProgramRegExp, record, set, } from "../interpreter/objects.js";
+import { sync, syncCall } from "../interpreter/host.js";
+import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { ProgramArray, record, set } from "../interpreter/objects.js";
+import { Values } from "../values.js";
 import { coerceToNumber, coerceToString } from "./value.js";
-const flagProperties = [
+export const regexpMethods = new Set(["test", "exec", "toString"]);
+export const regexpProperties = new Set([
+    "source",
+    "flags",
+    "lastIndex",
     "hasIndices",
     "global",
     "ignoreCase",
@@ -12,53 +16,91 @@ const flagProperties = [
     "unicode",
     "unicodeSets",
     "dotAll",
-];
+]);
 const regexFailureReason = (error) => (error instanceof Error ? error.message : String(error)).replace(/^Invalid regular expression:\s*/i, "");
 const escapeRegexHint = 'To match special characters like ( ) [ ] { } + * ? . literally, escape them with a backslash (e.g. "\\\\(") or test for them with String.includes instead.';
 export const toHostRegex = (arg, method, node, extraFlags = "") => {
     // Native parity: an undefined pattern behaves as an empty pattern.
     if (arg === undefined)
         return new RegExp("", extraFlags);
-    if (arg instanceof ProgramRegExp)
+    if (arg instanceof Values.RegExp)
         return arg.regex;
     if (typeof arg === "string") {
         try {
             return new RegExp(arg, extraFlags);
         }
         catch (error) {
-            throw syntaxError(`String.${method} received the string ${JSON.stringify(arg)}, which is not a valid regular expression pattern (${regexFailureReason(error)}). ${escapeRegexHint}`, node);
+            throw new InterpreterRuntimeError(`String.${method} received the string ${JSON.stringify(arg)}, which is not a valid regular expression pattern (${regexFailureReason(error)}). ${escapeRegexHint}`, node).as("SyntaxError");
         }
     }
     throw new InterpreterRuntimeError(`String.${method} expects a regular expression (a /pattern/flags literal or new RegExp(...)) or a string pattern, not ${arg === null ? "null" : typeof arg}.`, node);
 };
-export const matchToValue = (protos, match) => {
-    const result = new ProgramArray(protos.Array, Array.from(match, (group) => group));
+export const matchToValue = (match) => {
+    const result = new ProgramArray(Array.from(match, (group) => group));
     if (match.index !== undefined)
-        define(result, "index", match.index);
+        set(result, "index", match.index);
     if (match.input !== undefined)
-        define(result, "input", match.input);
+        set(result, "input", match.input);
     if (match.groups)
-        define(result, "groups", record(protos.Object, match.groups));
+        set(result, "groups", record(match.groups));
     if (match.indices)
-        define(result, "indices", indicesToValue(protos, match.indices));
+        set(result, "indices", indicesToValue(match.indices));
     return result;
 };
-export const constructRegExp = (protos, args, node, proto = protos.RegExp) => {
+export const constructRegExp = (args, node) => {
     const first = args[0];
-    const pattern = first instanceof ProgramRegExp ? first.regex.source : first === undefined ? "" : coerceToString(first);
+    const pattern = first instanceof Values.RegExp ? first.regex.source : first === undefined ? "" : coerceToString(first);
     const flagsArg = args[1];
     if (flagsArg !== undefined && typeof flagsArg !== "string") {
-        throw syntaxError(`RegExp flags must be a string of flag characters (e.g. "g", "gi"), not ${flagsArg === null ? "null" : typeof flagsArg}.`, node);
+        throw new InterpreterRuntimeError(`RegExp flags must be a string of flag characters (e.g. "g", "gi"), not ${flagsArg === null ? "null" : typeof flagsArg}.`, node).as("SyntaxError");
     }
-    const flags = flagsArg ?? (first instanceof ProgramRegExp ? first.regex.flags : "");
+    const flags = flagsArg ?? (first instanceof Values.RegExp ? first.regex.flags : "");
     try {
-        return new ProgramRegExp(proto, pattern, flags);
+        return new Values.RegExp(pattern, flags);
     }
     catch (error) {
         const reason = regexFailureReason(error);
-        throw syntaxError(/flag/i.test(reason)
+        throw new InterpreterRuntimeError(/flag/i.test(reason)
             ? `new RegExp(...) received invalid flags ${JSON.stringify(flags)} (${reason}). Valid flags are d, g, i, m, s, u, v, and y.`
-            : `new RegExp(...) received ${JSON.stringify(pattern)}, which is not a valid regular expression pattern (${reason}). ${escapeRegexHint}`, node);
+            : `new RegExp(...) received ${JSON.stringify(pattern)}, which is not a valid regular expression pattern (${reason}). ${escapeRegexHint}`, node).as("SyntaxError");
+    }
+};
+// RegExp constructs identically with or without new, like JS.
+export const regexpGlobal = sync("RegExp", constructRegExp, {
+    construct: syncCall(constructRegExp),
+    instanceOf: (value) => value instanceof Values.RegExp,
+    members: {
+        escape: sync("RegExp.escape", (args, node) => {
+            if (typeof args[0] !== "string") {
+                throw new InterpreterRuntimeError("RegExp.escape expects a string.", node).as("TypeError");
+            }
+            return RegExp.escape(args[0]);
+        }),
+    },
+});
+export const invokeRegExpMethod = (value, name, args, node) => {
+    switch (name) {
+        case "test":
+        case "exec": {
+            const input = coerceToString(args[0]);
+            const lastIndex = value.lastIndex;
+            const stateful = value.regex.global || value.regex.sticky;
+            value.regex.lastIndex = toLength(lastIndex);
+            if (name === "test") {
+                const matched = value.regex.test(input);
+                if (!stateful)
+                    value.lastIndex = lastIndex;
+                return matched;
+            }
+            const matched = value.regex.exec(input);
+            if (!stateful)
+                value.lastIndex = lastIndex;
+            return matched === null ? null : matchToValue(matched);
+        }
+        case "toString":
+            return coerceToString(value);
+        default:
+            throw new InterpreterRuntimeError(`RegExp method '${name}' is not available.`, node);
     }
 };
 const toLength = (value) => {
@@ -67,62 +109,12 @@ const toLength = (value) => {
         return 0;
     return Math.min(Math.floor(number), Number.MAX_SAFE_INTEGER);
 };
-// RegExp constructs identically with or without new, like JS.
-export const regexpGlobal = (runner) => {
-    const protos = runner.prototypes;
-    const proto = protos.RegExp;
-    const regexp = constructor(protos, proto, {
-        name: "RegExp",
-        length: 2,
-        call: (_, args, node) => Effect.sync(() => constructRegExp(protos, args, node)),
-        construct: (args, newTarget, node) => Effect.sync(() => constructRegExp(protos, args, node, prototypeFrom(newTarget, proto))),
-    });
-    methods(protos, regexp, [
-        [
-            "escape",
-            1,
-            (_, args, node) => {
-                if (typeof args[0] !== "string")
-                    throw new InterpreterRuntimeError("RegExp.escape expects a string.", node);
-                return RegExp.escape(args[0]);
-            },
-        ],
-    ]);
-    const self = (thisValue, name, node) => receiver(ProgramRegExp, thisValue, `RegExp.prototype.${name}`, node);
-    defineAccessor(proto, "source", (thisValue) => self(thisValue, "source").regex.source);
-    defineAccessor(proto, "flags", (thisValue) => self(thisValue, "flags").regex.flags);
-    for (const name of flagProperties)
-        defineAccessor(proto, name, (thisValue) => self(thisValue, name).regex[name]);
-    // exec/test run the host regex from the program-visible lastIndex and write it back only when g or y is set.
-    const run = (name) => [
-        name,
-        1,
-        (thisValue, args, node) => {
-            const value = self(thisValue, name, node);
-            const input = coerceToString(args[0]);
-            const stateful = value.regex.global || value.regex.sticky;
-            value.regex.lastIndex = toLength(getOwn(value, "lastIndex"));
-            const matched = value.regex.exec(input);
-            if (stateful)
-                set(value, "lastIndex", value.regex.lastIndex);
-            if (name === "test")
-                return matched !== null;
-            return matched === null ? null : matchToValue(protos, matched);
-        },
-    ];
-    methods(protos, proto, [
-        run("exec"),
-        run("test"),
-        ["toString", 0, (thisValue, _, node) => coerceToString(self(thisValue, "toString", node))],
-    ]);
-    return regexp;
-};
-const indicesToValue = (protos, indices) => {
-    const range = (pair) => pair === undefined ? undefined : new ProgramArray(protos.Array, [...pair]);
-    const result = new ProgramArray(protos.Array, Array.from(indices, range));
+const indicesToValue = (indices) => {
+    const range = (pair) => (pair === undefined ? undefined : new ProgramArray([...pair]));
+    const result = new ProgramArray(Array.from(indices, range));
     const groups = indices.groups;
-    define(result, "groups", groups === undefined
+    set(result, "groups", groups === undefined
         ? undefined
-        : record(protos.Object, Object.fromEntries(Object.entries(groups).map(([key, pair]) => [key, range(pair)]))));
+        : record(Object.fromEntries(Object.entries(groups).map(([key, pair]) => [key, range(pair)]))));
     return result;
 };

package/dist/stdlib/string.d.ts

@@ -1,2 +1,2 @@
-import { type Runner } from "../interpreter/runner.js";
-export declare const stringGlobal: <R>(runner: Runner<R>) => import("../interpreter/objects.js").NativeFunction<R>;
+export declare const stringMethods: Set<string>;
+export declare const stringGlobal: import("../interpreter/host.js").HostFunction<never>;