@opencode/codemode 2.0.0 → 2.0.2

package/dist/stdlib/number.js

@@ -1,56 +1,14 @@
-import { toProgram } from "../data.js";
-import { sync } from "../interpreter/host.js";
-import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { constructor, constants, methods } from "../interpreter/native.js";
+import { InterpreterRuntimeError, rangeError } 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: {
+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, {
         MAX_SAFE_INTEGER: Number.MAX_SAFE_INTEGER,
         MIN_SAFE_INTEGER: Number.MIN_SAFE_INTEGER,
         MAX_VALUE: Number.MAX_VALUE,
@@ -59,11 +17,88 @@ export const numberGlobal = coercion("Number", {
         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]))),
-    },
-});
+    });
+    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;
+};

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: (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>;
+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>;

package/dist/stdlib/object.js

@@ -1,59 +1,58 @@
 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 { 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 { 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) => {
+export const enumerableSource = (runner, label, value, node) => {
     if (value === null || value === undefined) {
-        throw new InterpreterRuntimeError(`${label} cannot convert ${describeValue(value)} to an object.`, node).as("TypeError");
+        throw new InterpreterRuntimeError(`${label} cannot convert ${describeValue(value)} to an object.`, node);
     }
-    if (value instanceof Values.Promise) {
+    if (value instanceof ProgramPromise) {
         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]);
+        return new ProgramArray(runner.prototypes.Array, [...value]);
     if (value instanceof ProgramObject)
         return value;
-    return new ProgramObject();
+    return new ProgramObject(runner.prototypes.Object);
 };
-export const objectAssign = (args, node) => {
+export const objectAssign = (runner, 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");
+        throw new InterpreterRuntimeError(`Object.assign expects a data object or array target, received ${describeValue(target)}.`, node);
     }
     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;
+        const from = enumerableSource(runner, "Object.assign(...)", source, node);
+        for (const key of enumerableKeys(from)) {
             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");
+                if (target instanceof ProgramArray && key === "length")
+                    throw rangeError("Invalid array length", node);
+                throw new InterpreterRuntimeError(`Cannot assign to read only property '${String(key)}'.`, node);
             }
         }
     }
     return target;
 };
 const objectFromEntries = (runner, source, node) => {
-    const out = new ProgramObject();
+    const out = new ProgramObject(runner.prototypes.Object);
     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");
+            throw new InterpreterRuntimeError("Object.fromEntries expects a synchronous iterable of entries.", node);
         }
         while (true) {
             const step = yield* cursor.next;
@@ -61,46 +60,121 @@ 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).as("TypeError");
+                    throw new InterpreterRuntimeError("Object.fromEntries expects [key, value] entry objects.", node);
                 }
-                set(out, coerceToString(getOwn(step.value, 0)), getOwn(step.value, 1));
+                define(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);
+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 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) => 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"),
-    },
-});
+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;
+};

package/dist/stdlib/regexp.d.ts

@@ -1,10 +1,8 @@
+import type { Prototypes } from "../interpreter/intrinsics.js";
 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>;
+import { ProgramArray, ProgramObject, ProgramRegExp } from "../interpreter/objects.js";
+import type { Runner } from "../interpreter/runner.js";
 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;
+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>;

package/dist/stdlib/regexp.js

@@ -1,13 +1,9 @@
-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 { 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 { coerceToNumber, coerceToString } from "./value.js";
-export const regexpMethods = new Set(["test", "exec", "toString"]);
-export const regexpProperties = new Set([
-    "source",
-    "flags",
-    "lastIndex",
+const flagProperties = [
     "hasIndices",
     "global",
     "ignoreCase",
@@ -16,91 +12,53 @@ export const regexpProperties = new Set([
     "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 Values.RegExp)
+    if (arg instanceof ProgramRegExp)
         return arg.regex;
     if (typeof arg === "string") {
         try {
             return new RegExp(arg, extraFlags);
         }
         catch (error) {
-            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 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} 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 = (match) => {
-    const result = new ProgramArray(Array.from(match, (group) => group));
+export const matchToValue = (protos, match) => {
+    const result = new ProgramArray(protos.Array, Array.from(match, (group) => group));
     if (match.index !== undefined)
-        set(result, "index", match.index);
+        define(result, "index", match.index);
     if (match.input !== undefined)
-        set(result, "input", match.input);
+        define(result, "input", match.input);
     if (match.groups)
-        set(result, "groups", record(match.groups));
+        define(result, "groups", record(protos.Object, match.groups));
     if (match.indices)
-        set(result, "indices", indicesToValue(match.indices));
+        define(result, "indices", indicesToValue(protos, match.indices));
     return result;
 };
-export const constructRegExp = (args, node) => {
+export const constructRegExp = (protos, args, node, proto = protos.RegExp) => {
     const first = args[0];
-    const pattern = first instanceof Values.RegExp ? first.regex.source : first === undefined ? "" : coerceToString(first);
+    const pattern = first instanceof ProgramRegExp ? first.regex.source : first === undefined ? "" : coerceToString(first);
     const flagsArg = args[1];
     if (flagsArg !== undefined && typeof flagsArg !== "string") {
-        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");
+        throw syntaxError(`RegExp flags must be a string of flag characters (e.g. "g", "gi"), not ${flagsArg === null ? "null" : typeof flagsArg}.`, node);
     }
-    const flags = flagsArg ?? (first instanceof Values.RegExp ? first.regex.flags : "");
+    const flags = flagsArg ?? (first instanceof ProgramRegExp ? first.regex.flags : "");
     try {
-        return new Values.RegExp(pattern, flags);
+        return new ProgramRegExp(proto, pattern, flags);
     }
     catch (error) {
         const reason = regexFailureReason(error);
-        throw new InterpreterRuntimeError(/flag/i.test(reason)
+        throw syntaxError(/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).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);
+            : `new RegExp(...) received ${JSON.stringify(pattern)}, which is not a valid regular expression pattern (${reason}). ${escapeRegexHint}`, node);
     }
 };
 const toLength = (value) => {
@@ -109,12 +67,62 @@ const toLength = (value) => {
         return 0;
     return Math.min(Math.floor(number), Number.MAX_SAFE_INTEGER);
 };
-const indicesToValue = (indices) => {
-    const range = (pair) => (pair === undefined ? undefined : new ProgramArray([...pair]));
-    const result = new ProgramArray(Array.from(indices, range));
+// 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 groups = indices.groups;
-    set(result, "groups", groups === undefined
+    define(result, "groups", groups === undefined
         ? undefined
-        : record(Object.fromEntries(Object.entries(groups).map(([key, pair]) => [key, range(pair)]))));
+        : record(protos.Object, Object.fromEntries(Object.entries(groups).map(([key, pair]) => [key, range(pair)]))));
     return result;
 };

package/dist/stdlib/string.d.ts

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