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

package/dist/stdlib/math.js

@@ -1,157 +1,89 @@
 import { Effect } from "effect";
-import { preserveConsumerError } from "../interpreter/iterator.js";
+import { HostFunction, HostNamespace, sync } from "../interpreter/host.js";
+import { preserveConsumerError } from "../interpreter/runner.js";
 import { InterpreterRuntimeError } from "../interpreter/model.js";
-export const mathConstants = new Set(["PI", "E", "LN2", "LN10", "LOG2E", "LOG10E", "SQRT2", "SQRT1_2"]);
-export const mathMethods = new Set([
-    "random",
-    "max",
-    "min",
-    "abs",
-    "acos",
-    "acosh",
-    "asin",
-    "asinh",
-    "atan",
-    "atan2",
-    "atanh",
-    "floor",
-    "ceil",
-    "round",
-    "trunc",
-    "sign",
-    "sqrt",
-    "cbrt",
-    "pow",
-    "hypot",
-    "cos",
-    "cosh",
-    "sin",
-    "sinh",
-    "tan",
-    "tanh",
-    "log",
-    "log2",
-    "log10",
-    "log1p",
-    "exp",
-    "expm1",
-    "f16round",
-    "fround",
-    "clz32",
-    "imul",
-    "sumPrecise",
-]);
-export const invokeMathMethod = (name, args, node) => {
-    if (!mathMethods.has(name))
-        throw new InterpreterRuntimeError(`Math.${name} is not available.`, node);
-    if (name === "random")
-        return Math.random();
-    // Validate only the arguments the method consumes; like JS, extras are ignored
-    // (so built-ins work as callbacks receiving (element, index, array)).
-    const num = (index) => {
-        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 nums = () => args.map((arg) => {
-        if (typeof arg !== "number")
-            throw new InterpreterRuntimeError(`Math.${name} expects number arguments.`, node);
-        return arg;
-    });
-    const a = num(0);
-    const b = () => num(1);
-    switch (name) {
-        case "max":
-            return Math.max(...nums());
-        case "min":
-            return Math.min(...nums());
-        case "abs":
-            return Math.abs(a);
-        case "acos":
-            return Math.acos(a);
-        case "acosh":
-            return Math.acosh(a);
-        case "asin":
-            return Math.asin(a);
-        case "asinh":
-            return Math.asinh(a);
-        case "atan":
-            return Math.atan(a);
-        case "atan2":
-            return Math.atan2(a, b());
-        case "atanh":
-            return Math.atanh(a);
-        case "floor":
-            return Math.floor(a);
-        case "ceil":
-            return Math.ceil(a);
-        case "round":
-            return Math.round(a);
-        case "trunc":
-            return Math.trunc(a);
-        case "sign":
-            return Math.sign(a);
-        case "sqrt":
-            return Math.sqrt(a);
-        case "cbrt":
-            return Math.cbrt(a);
-        case "pow":
-            return Math.pow(a, b());
-        case "hypot":
-            return Math.hypot(...nums());
-        case "cos":
-            return Math.cos(a);
-        case "cosh":
-            return Math.cosh(a);
-        case "sin":
-            return Math.sin(a);
-        case "sinh":
-            return Math.sinh(a);
-        case "tan":
-            return Math.tan(a);
-        case "tanh":
-            return Math.tanh(a);
-        case "log":
-            return Math.log(a);
-        case "log2":
-            return Math.log2(a);
-        case "log10":
-            return Math.log10(a);
-        case "log1p":
-            return Math.log1p(a);
-        case "exp":
-            return Math.exp(a);
-        case "expm1":
-            return Math.expm1(a);
-        case "f16round":
-            return Math.f16round(a);
-        case "fround":
-            return Math.fround(a);
-        case "clz32":
-            return Math.clz32(a);
-        case "imul":
-            return Math.imul(a, b());
-    }
-    throw new InterpreterRuntimeError(`Math.${name} is not available.`, node);
+// 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;
 };
-export const invokeMathSumPrecise = (runner, source, node) => Effect.gen(function* () {
-    const cursor = yield* runner.syncIterator(source, 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);
-        }));
-    }
+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

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

package/dist/stdlib/number.js

@@ -1,15 +1,8 @@
+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 numberConstants = new Set([
-    "MAX_SAFE_INTEGER",
-    "MIN_SAFE_INTEGER",
-    "MAX_VALUE",
-    "MIN_VALUE",
-    "EPSILON",
-    "NaN",
-    "POSITIVE_INFINITY",
-    "NEGATIVE_INFINITY",
-]);
-export const numberStatics = new Set(["isInteger", "isFinite", "isNaN", "isSafeInteger", "parseInt", "parseFloat"]);
 export const invokeNumberMethod = (value, name, args, node) => {
     const optNum = (index) => {
         const arg = args[index];
@@ -46,31 +39,31 @@ export const invokeNumberMethod = (value, name, args, node) => {
         default:
             throw new InterpreterRuntimeError(`Number method '${name}' is not available.`, node);
     }
-    return boundedData(result, `Number.${name} result`);
+    return toProgram(result, `Number.${name} result`);
 };
-export const invokeNumberStatic = (name, args, node) => {
-    const value = args[0];
-    switch (name) {
-        case "isInteger":
-            return Number.isInteger(value);
-        case "isFinite":
-            return Number.isFinite(value);
-        case "isNaN":
-            return Number.isNaN(value);
-        case "isSafeInteger":
-            return Number.isSafeInteger(value);
-        case "parseInt": {
-            const radix = args[1];
-            if (radix !== undefined && typeof radix !== "number") {
-                throw new InterpreterRuntimeError("Number.parseInt expects a numeric radix.", node);
-            }
-            return parseInt(coerceToString(value), radix);
-        }
-        case "parseFloat":
-            return parseFloat(coerceToString(value));
-        default:
-            throw new InterpreterRuntimeError(`Number.${name} is not available.`, node);
+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);
     }
-};
-import { InterpreterRuntimeError } from "../interpreter/model.js";
-import { boundedData, coerceToString } from "./value.js";
+    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

@@ -1,7 +1,5 @@
-import { Effect } from "effect";
+import { HostFunction } from "../interpreter/host.js";
 import { type AstNode } from "../interpreter/model.js";
-import { type SyncIteratorRunner } from "../interpreter/iterator.js";
-export declare const objectMethodsPreservingIdentity: Set<string>;
-export declare const objectStatics: Set<string>;
-export declare const invokeObjectMethod: (name: string, args: Array<unknown>, node: AstNode) => unknown;
-export declare const invokeObjectFromEntries: <R>(runner: SyncIteratorRunner<R>, source: unknown, node: AstNode) => Effect.Effect<Record<string, unknown>, unknown, R>;
+import { type Runner } from "../interpreter/runner.js";
+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,84 +1,66 @@
 import { Effect } from "effect";
+import { isBlockedMember, toProgram } from "../data.js";
+import { HostFunction, sync, syncCall } from "../interpreter/host.js";
 import { AsyncIteratorSymbol, InterpreterRuntimeError, IteratorSymbol } from "../interpreter/model.js";
-import { containsOpaqueReference, rejectCircularInsertion } from "../interpreter/references.js";
-import { isBlockedMember } from "../tool-runtime.js";
-import { isCodeModeValue, CodeModePromise } from "../values.js";
-import { boundedData, coerceToString } from "./value.js";
-import { preserveConsumerError } from "../interpreter/iterator.js";
-export const objectMethodsPreservingIdentity = new Set(["assign", "values", "entries", "fromEntries"]);
-export const objectStatics = new Set(["keys", "values", "entries", "hasOwn", "is", "assign", "fromEntries", "groupBy"]);
-export const invokeObjectMethod = (name, args, node) => {
-    const requireObject = () => {
-        const input = args[0];
-        if (Array.isArray(input))
-            return input;
-        if (isCodeModeValue(input))
-            return {};
-        if (input instanceof CodeModePromise) {
-            throw new InterpreterRuntimeError(`Object.${name} received an un-awaited Promise; await it before inspecting the result.`, node, "InvalidDataValue");
-        }
-        if (input === null || typeof input !== "object") {
-            throw new InterpreterRuntimeError(`Object.${name} expects a data object or array.`, node, "InvalidDataValue");
-        }
-        const prototype = Object.getPrototypeOf(input);
-        if (prototype !== null && prototype !== Object.prototype) {
-            throw new InterpreterRuntimeError(`Object.${name} expects a data object or array.`, node, "InvalidDataValue");
-        }
+import { containsOpaqueReference, 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";
+const requireObject = (name, input, node) => {
+    if (Array.isArray(input))
         return input;
+    if (Values.isValue(input))
+        return {};
+    if (input instanceof Values.Promise) {
+        throw new InterpreterRuntimeError(`Object.${name} received an un-awaited Promise; await it before inspecting the result.`, node, "InvalidDataValue");
+    }
+    if (input === null || typeof input !== "object") {
+        throw new InterpreterRuntimeError(`Object.${name} expects a data object or array.`, node, "InvalidDataValue");
+    }
+    const prototype = Object.getPrototypeOf(input);
+    if (prototype !== null && prototype !== Object.prototype) {
+        throw new InterpreterRuntimeError(`Object.${name} expects a data object or array.`, node, "InvalidDataValue");
+    }
+    return input;
+};
+export const objectAssign = (args, node) => {
+    const target = args[0];
+    if (target === null || typeof target !== "object" || Array.isArray(target) || Values.isValue(target)) {
+        throw new InterpreterRuntimeError("Object.assign expects a data object target.", node);
+    }
+    const out = target;
+    const seen = new Set();
+    const guardedSet = (key, item) => {
+        if (typeof key === "string" && isBlockedMember(key))
+            throw new InterpreterRuntimeError(`Property '${key}' is not available.`, node);
+        rejectCircularInsertion(out, item, "Object.assign result", node, seen);
+        if (!Reflect.set(out, key, item))
+            throw new InterpreterRuntimeError(`Object.assign could not assign property '${String(key)}'.`, node).as("TypeError");
     };
-    switch (name) {
-        case "keys":
-            return Object.keys(requireObject());
-        case "values":
-            return Object.values(requireObject());
-        case "entries":
-            return Object.entries(requireObject()).map(([key, item]) => [key, item]);
-        case "hasOwn":
-            return Object.hasOwn(requireObject(), args[1] === AsyncIteratorSymbol || args[1] === IteratorSymbol ? args[1] : String(args[1]));
-        case "is":
-            if (containsOpaqueReference(args[0]) || containsOpaqueReference(args[1])) {
-                throw new InterpreterRuntimeError("Object.is requires data values.", node, "InvalidDataValue");
-            }
-            return Object.is(args[0], args[1]);
-        case "assign": {
-            const target = args[0];
-            if (target === null || typeof target !== "object" || Array.isArray(target) || isCodeModeValue(target)) {
-                throw new InterpreterRuntimeError("Object.assign expects a data object target.", node);
-            }
-            const out = target;
-            const seen = new Set();
-            const guardedSet = (key, item) => {
-                if (typeof key === "string" && isBlockedMember(key))
-                    throw new InterpreterRuntimeError(`Property '${key}' is not available.`, node);
-                rejectCircularInsertion(out, item, "Object.assign result", node, seen);
-                if (!Reflect.set(out, key, item))
-                    throw new InterpreterRuntimeError(`Object.assign could not assign property '${String(key)}'.`, node).as("TypeError");
-            };
-            for (const source of args.slice(1)) {
-                if (source === null || source === undefined || isCodeModeValue(source))
-                    continue;
-                if (typeof source !== "object" || Array.isArray(source)) {
-                    throw new InterpreterRuntimeError("Object.assign expects data objects.", node);
-                }
-                for (const key of Reflect.ownKeys(source)) {
-                    if (typeof key === "string") {
-                        if (Object.prototype.propertyIsEnumerable.call(source, key))
-                            guardedSet(key, Reflect.get(source, key));
-                        continue;
-                    }
-                    if (key !== AsyncIteratorSymbol && key !== IteratorSymbol)
-                        continue;
-                    if (!Object.prototype.propertyIsEnumerable.call(source, key))
-                        continue;
+    for (const source of args.slice(1)) {
+        if (source === null || source === undefined || Values.isValue(source))
+            continue;
+        if (typeof source !== "object" || Array.isArray(source)) {
+            throw new InterpreterRuntimeError("Object.assign expects data objects.", node);
+        }
+        for (const key of Reflect.ownKeys(source)) {
+            if (typeof key === "string") {
+                if (Object.prototype.propertyIsEnumerable.call(source, key))
                     guardedSet(key, Reflect.get(source, key));
-                }
+                continue;
             }
-            return out;
+            if (key !== AsyncIteratorSymbol && key !== IteratorSymbol)
+                continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key))
+                continue;
+            guardedSet(key, Reflect.get(source, key));
         }
     }
-    throw new InterpreterRuntimeError(`Object.${name} is not available.`, node);
+    return out;
 };
-export const invokeObjectFromEntries = (runner, source, node) => {
+const objectFromEntries = (runner, source, node) => {
     const out = Object.create(null);
     return Effect.gen(function* () {
         const cursor = yield* runner.syncIterator(source, node);
@@ -92,13 +74,13 @@ export const invokeObjectFromEntries = (runner, source, node) => {
             yield* preserveConsumerError(cursor, Effect.sync(() => {
                 if (step.value === null ||
                     typeof step.value !== "object" ||
-                    isCodeModeValue(step.value) ||
+                    Values.isValue(step.value) ||
                     containsOpaqueReference(step.value)) {
                     throw new InterpreterRuntimeError("Object.fromEntries expects [key, value] entry objects.", node).as("TypeError");
                 }
                 const entry = step.value;
-                boundedData(entry[0], "Object.fromEntries key");
-                boundedData(entry[1], "Object.fromEntries value");
+                toProgram(entry[0], "Object.fromEntries key");
+                toProgram(entry[1], "Object.fromEntries value");
                 const key = coerceToString(entry[0]);
                 if (isBlockedMember(key))
                     throw new InterpreterRuntimeError(`Property '${key}' is not available.`, node);
@@ -107,3 +89,52 @@ export const invokeObjectFromEntries = (runner, source, node) => {
         }
     });
 };
+const constructObject = (args, node) => {
+    const first = args[0];
+    if (first === null || first === undefined)
+        return {};
+    if (typeof first === "object")
+        return first;
+    throw new InterpreterRuntimeError(`Object(${typeof first}) wrapper objects are not supported; use the primitive value directly.`, node);
+};
+// Tool references are not data; only Object.keys(tools) reads them, for tool names.
+const rejectTools = (name, args, node) => {
+    if (!(args[0] instanceof ToolReference))
+        return;
+    throw new InterpreterRuntimeError(`Object.${name}(...) cannot read tool references: they are not plain data. Use Object.keys(tools) for names, or search({ query }) for signatures.`, node, "InvalidDataValue");
+};
+const objectStatic = (name, impl) => sync(`Object.${name}`, (args, node) => {
+    rejectTools(name, args, node);
+    return impl(args, 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)]
+            : Object.keys(requireObject("keys", args[0], node)), "Object.keys result")),
+        values: objectStatic("values", (args, node) => Object.values(requireObject("values", args[0], node))),
+        entries: objectStatic("entries", (args, node) => Object.entries(requireObject("entries", args[0], node)).map(([key, item]) => [key, item])),
+        hasOwn: objectStatic("hasOwn", (args, node) => Object.hasOwn(requireObject("hasOwn", args[0], node), args[1] === AsyncIteratorSymbol || args[1] === IteratorSymbol ? args[1] : String(args[1]))),
+        is: objectStatic("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: objectStatic("assign", objectAssign),
+        fromEntries: new HostFunction({
+            name: "Object.fromEntries",
+            call: (args, node) => Effect.suspend(() => {
+                rejectTools("fromEntries", args, node);
+                return objectFromEntries(runner, args[0], node);
+            }),
+        }),
+        groupBy: groupBy(runner, "Object"),
+    },
+});

package/dist/stdlib/regexp.d.ts

@@ -1,11 +1,9 @@
 import { type AstNode } from "../interpreter/model.js";
-import { CodeModeRegExp } from "../values.js";
+import { Values } from "../values.js";
 export declare const regexpMethods: Set<string>;
-export declare const regexpStatics: Set<string>;
 export declare const regexpProperties: Set<string>;
-export declare const regexFailureReason: (error: unknown) => string;
-export declare const escapeRegexHint = "To match special characters like ( ) [ ] { } + * ? . literally, escape them with a backslash (e.g. \"\\\\(\") or test for them with String.includes instead.";
 export declare const toHostRegex: (arg: unknown, method: string, node: AstNode, extraFlags?: string) => RegExp;
 export declare const matchToValue: (match: RegExpMatchArray) => Array<unknown>;
-export declare const invokeRegExpStatic: (name: string, args: Array<unknown>, node: AstNode) => string;
-export declare const invokeRegExpMethod: (value: CodeModeRegExp, name: string, args: Array<unknown>, node: AstNode) => unknown;
+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,9 @@
+import { sync, syncCall } from "../interpreter/host.js";
 import { InterpreterRuntimeError } from "../interpreter/model.js";
-import { isBlockedMember } from "../tool-runtime.js";
-import { CodeModeRegExp } from "../values.js";
+import { isBlockedMember } from "../data.js";
+import { Values } from "../values.js";
 import { coerceToNumber, coerceToString } from "./value.js";
 export const regexpMethods = new Set(["test", "exec", "toString"]);
-export const regexpStatics = new Set(["escape"]);
 export const regexpProperties = new Set([
     "source",
     "flags",
@@ -17,13 +17,13 @@ export const regexpProperties = new Set([
     "unicodeSets",
     "dotAll",
 ]);
-export const regexFailureReason = (error) => (error instanceof Error ? error.message : String(error)).replace(/^Invalid regular expression:\s*/i, "");
-export const escapeRegexHint = 'To match special characters like ( ) [ ] { } + * ? . literally, escape them with a backslash (e.g. "\\\\(") or test for them with String.includes instead.';
+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 CodeModeRegExp)
+    if (arg instanceof Values.RegExp)
         return arg.regex;
     if (typeof arg === "string") {
         try {
@@ -51,14 +51,37 @@ export const matchToValue = (match) => {
         result.indices = indicesToValue(match.indices);
     return result;
 };
-export const invokeRegExpStatic = (name, args, node) => {
-    if (name !== "escape")
-        throw new InterpreterRuntimeError(`RegExp.${name} is not available.`, node);
-    if (typeof args[0] !== "string") {
-        throw new InterpreterRuntimeError("RegExp.escape expects a string.", node).as("TypeError");
+export const constructRegExp = (args, node) => {
+    const first = args[0];
+    const pattern = first instanceof Values.RegExp ? 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");
+    }
+    const flags = flagsArg ?? (first instanceof Values.RegExp ? first.regex.flags : "");
+    try {
+        return new Values.RegExp(pattern, flags);
+    }
+    catch (error) {
+        const reason = regexFailureReason(error);
+        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).as("SyntaxError");
     }
-    return RegExp.escape(args[0]);
 };
+// 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":

package/dist/stdlib/string.d.ts

@@ -1,4 +1,2 @@
 export declare const stringMethods: Set<string>;
-export declare const stringStatics: Set<string>;
-export declare const invokeStringStatic: (name: string, args: Array<unknown>, node: AstNode) => unknown;
-import { type AstNode } from "../interpreter/model.js";
+export declare const stringGlobal: import("../interpreter/host.js").HostFunction<never>;