@opencode/codemode 0.0.0-beta-19365 → 0.0.0-beta-19381

package/dist/stdlib/number.js

@@ -1,18 +1,8 @@
-import { InterpreterRuntimeError } from "../interpreter/model.js";
 import { toProgram } from "../data.js";
-import { coerceToString } from "./value.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];
@@ -51,27 +41,29 @@ export const invokeNumberMethod = (value, name, args, node) => {
     }
     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);
     }
-};
+    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,85 +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 "../data.js";
+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 { toProgram } from "../data.js";
+import { groupBy } from "./collections.js";
 import { 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 (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");
-        }
+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) || 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");
-            };
-            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;
-                    }
-                    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);
@@ -108,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 { 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 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 "../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,8 +17,8 @@ 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)
@@ -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 @@
-import { type AstNode } from "../interpreter/model.js";
 export declare const stringMethods: Set<string>;
-export declare const stringStatics: Set<string>;
-export declare const invokeStringStatic: (name: string, args: Array<unknown>, node: AstNode) => unknown;
+export declare const stringGlobal: import("../interpreter/host.js").HostFunction<never>;

package/dist/stdlib/string.js

@@ -1,4 +1,6 @@
+import { sync } from "../interpreter/host.js";
 import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { coercion } from "./value.js";
 export const stringMethods = new Set([
     "toLowerCase",
     "toUpperCase",
@@ -30,19 +32,15 @@ export const stringMethods = new Set([
     "localeCompare",
     "normalize",
 ]);
-export const stringStatics = new Set(["fromCharCode", "fromCodePoint"]);
-export const invokeStringStatic = (name, args, node) => {
-    const codes = args.map((arg) => {
-        if (typeof arg !== "number")
-            throw new InterpreterRuntimeError(`String.${name} expects number arguments.`, node);
-        return arg;
-    });
-    switch (name) {
-        case "fromCharCode":
-            return String.fromCharCode(...codes);
-        case "fromCodePoint":
-            return String.fromCodePoint(...codes);
-        default:
-            throw new InterpreterRuntimeError(`String.${name} is not available.`, node);
-    }
-};
+const codeUnits = (name, op) => sync(`String.${name}`, (args, node) => op(...args.map((arg) => {
+    if (typeof arg !== "number")
+        throw new InterpreterRuntimeError(`String.${name} expects number arguments.`, node);
+    return arg;
+})));
+export const stringGlobal = coercion("String", {
+    instanceOf: () => false,
+    members: {
+        fromCharCode: codeUnits("fromCharCode", String.fromCharCode),
+        fromCodePoint: codeUnits("fromCodePoint", String.fromCodePoint),
+    },
+});

package/dist/stdlib/url.d.ts

@@ -1,12 +1,16 @@
-import { type AstNode, UriFunction } from "../interpreter/model.js";
+import { HostFunction } from "../interpreter/host.js";
+import { type AstNode } from "../interpreter/model.js";
+import { type Runner } from "../interpreter/runner.js";
 import { Values } from "../values.js";
 export declare const urlProperties: Set<string>;
 export declare const urlWritableProperties: Set<string>;
 export declare const urlMethods: Set<string>;
-export declare const urlStatics: Set<string>;
 export declare const urlSearchParamsMethods: Set<string>;
 export declare const uriArgument: (value: unknown, label: string) => string;
-export declare const invokeUriFunction: (ref: UriFunction, args: Array<unknown>, node: AstNode) => string;
+type UriFunction = "encodeURI" | "encodeURIComponent" | "decodeURI" | "decodeURIComponent";
+export declare const uriGlobal: (name: UriFunction) => HostFunction<never>;
 export declare const urlArgument: (value: unknown, label: string) => string;
-export declare const invokeURLStatic: (name: string, args: Array<unknown>, node: AstNode) => unknown;
+export declare const urlGlobal: HostFunction<never>;
+export declare const urlSearchParamsGlobal: <R>(runner: Runner<R>) => HostFunction<R>;
 export declare const invokeURLMethod: (value: Values.URL, name: string, node: AstNode) => string;
+export {};

package/dist/stdlib/url.js

@@ -1,6 +1,10 @@
-import { InterpreterRuntimeError, UriFunction } from "../interpreter/model.js";
-import { Values } from "../values.js";
+import { Effect } from "effect";
 import { toProgram } from "../data.js";
+import { HostFunction, requiresNew, sync, syncCall } from "../interpreter/host.js";
+import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { isRuntimeReference } from "../interpreter/references.js";
+import { preserveConsumerError } from "../interpreter/runner.js";
+import { Values } from "../values.js";
 import { coerceToString } from "./value.js";
 export const urlProperties = new Set([
     "href",
@@ -28,7 +32,6 @@ export const urlWritableProperties = new Set([
     "hash",
 ]);
 export const urlMethods = new Set(["toString", "toJSON"]);
-export const urlStatics = new Set(["canParse", "parse"]);
 export const urlSearchParamsMethods = new Set([
     "append",
     "delete",
@@ -44,30 +47,26 @@ export const urlSearchParamsMethods = new Set([
     "toString",
 ]);
 export const uriArgument = (value, label) => coerceToString(toProgram(value, label));
-export const invokeUriFunction = (ref, args, node) => {
-    const value = uriArgument(args[0], `${ref.name} input`);
+const uriFunctions = {
+    encodeURI,
+    encodeURIComponent,
+    decodeURI,
+    decodeURIComponent,
+};
+export const uriGlobal = (name) => sync(name, (args, node) => {
+    const value = uriArgument(args[0], `${name} input`);
     try {
-        switch (ref.name) {
-            case "encodeURI":
-                return encodeURI(value);
-            case "encodeURIComponent":
-                return encodeURIComponent(value);
-            case "decodeURI":
-                return decodeURI(value);
-            case "decodeURIComponent":
-                return decodeURIComponent(value);
-        }
+        return uriFunctions[name](value);
     }
     catch (error) {
-        throw new InterpreterRuntimeError(`${ref.name} received malformed URI data: ${error instanceof Error ? error.message : String(error)}`, node).as("URIError");
+        throw new InterpreterRuntimeError(`${name} received malformed URI data: ${error instanceof Error ? error.message : String(error)}`, node).as("URIError");
     }
-};
+});
 export const urlArgument = (value, label) => value instanceof Values.URL ? value.url.href : uriArgument(value, label);
-export const invokeURLStatic = (name, args, node) => {
-    if (!urlStatics.has(name))
-        throw new InterpreterRuntimeError(`URL.${name} is not available.`, node);
-    if (args.length === 0)
+const urlStatic = (name) => sync(`URL.${name}`, (args, node) => {
+    if (args.length === 0) {
         throw new InterpreterRuntimeError(`URL.${name} requires a URL argument.`, node).as("TypeError");
+    }
     const input = urlArgument(args[0], `URL.${name} input`);
     const base = args[1] === undefined ? undefined : urlArgument(args[1], `URL.${name} base`);
     try {
@@ -77,7 +76,84 @@ export const invokeURLStatic = (name, args, node) => {
     catch {
         return name === "canParse" ? false : null;
     }
+});
+const constructURL = (args, node) => {
+    if (args.length === 0) {
+        throw new InterpreterRuntimeError("new URL(...) requires a URL string and an optional base URL.", node).as("TypeError");
+    }
+    const input = urlArgument(args[0], "new URL input");
+    const base = args[1] === undefined ? undefined : urlArgument(args[1], "new URL base");
+    try {
+        return new Values.URL(new URL(input, base));
+    }
+    catch {
+        throw new InterpreterRuntimeError(`new URL(...) received an invalid URL${base === undefined ? "" : " or base URL"}.`, node).as("TypeError");
+    }
+};
+export const urlGlobal = new HostFunction({
+    name: "URL",
+    call: requiresNew("URL"),
+    construct: syncCall(constructURL),
+    instanceOf: (value) => value instanceof Values.URL,
+    members: { canParse: urlStatic("canParse"), parse: urlStatic("parse") },
+});
+const readURLSearchParamsPair = (runner, value, node) => Effect.gen(function* () {
+    const cursor = yield* runner.syncIterator(value, node);
+    if (cursor === undefined) {
+        throw new InterpreterRuntimeError("new URLSearchParams(...) expects iterable [name, value] pairs.", node).as("TypeError");
+    }
+    const items = [];
+    while (true) {
+        const step = yield* cursor.next;
+        if (step.done)
+            return items;
+        items.push(yield* preserveConsumerError(cursor, Effect.sync(() => uriArgument(step.value, "URLSearchParams pair value"))));
+    }
+});
+const constructURLSearchParams = (runner, init, node) => {
+    if (init === undefined)
+        return Effect.succeed(new Values.URLSearchParams(new URLSearchParams()));
+    if (init instanceof Values.URLSearchParams) {
+        return Effect.succeed(new Values.URLSearchParams(new URLSearchParams(init.params)));
+    }
+    if (typeof init === "string")
+        return Effect.succeed(new Values.URLSearchParams(new URLSearchParams(init)));
+    if (init === null || typeof init === "number" || typeof init === "boolean") {
+        return Effect.succeed(new Values.URLSearchParams(new URLSearchParams(coerceToString(init))));
+    }
+    return Effect.gen(function* () {
+        const cursor = yield* runner.syncIterator(init, node);
+        if (cursor !== undefined) {
+            const entries = [];
+            while (true) {
+                const step = yield* cursor.next;
+                if (step.done) {
+                    if (entries.some((entry) => entry.length !== 2)) {
+                        throw new InterpreterRuntimeError("new URLSearchParams(...) expects iterable [name, value] pairs.", node).as("TypeError");
+                    }
+                    return new Values.URLSearchParams(new URLSearchParams(entries.map((entry) => [entry[0] ?? "", entry[1] ?? ""])));
+                }
+                entries.push(yield* preserveConsumerError(cursor, readURLSearchParamsPair(runner, step.value, node)));
+            }
+        }
+        if (isRuntimeReference(init)) {
+            throw new InterpreterRuntimeError("new URLSearchParams(...) expects a query string, data object, or synchronous iterable pairs.", node).as("TypeError");
+        }
+        if (Values.isValue(init))
+            return new Values.URLSearchParams(new URLSearchParams());
+        const data = toProgram(init, "new URLSearchParams input");
+        if (data === null || typeof data !== "object") {
+            throw new InterpreterRuntimeError("new URLSearchParams(...) expects a query string, data object, iterable pairs, or URLSearchParams.", node).as("TypeError");
+        }
+        return new Values.URLSearchParams(new URLSearchParams(Object.fromEntries(Object.entries(data).map(([key, value]) => [key, coerceToString(value)]))));
+    });
 };
+export const urlSearchParamsGlobal = (runner) => new HostFunction({
+    name: "URLSearchParams",
+    call: requiresNew("URLSearchParams"),
+    construct: (args, node) => constructURLSearchParams(runner, args[0], node),
+    instanceOf: (value) => value instanceof Values.URLSearchParams,
+});
 export const invokeURLMethod = (value, name, node) => {
     if (name === "toString" || name === "toJSON")
         return value.url.href;

package/dist/stdlib/value.d.ts

@@ -1,11 +1,13 @@
-import { type AstNode, CoercionFunction } from "../interpreter/model.js";
+import { type HostFunction, type SyncOptions } from "../interpreter/host.js";
 import { type SafeObject } from "../data.js";
 export declare const errorConstructors: Set<string>;
-export declare const valueConstructors: Set<string>;
 export declare const compoundOperators: Set<string>;
 export declare const createErrorValue: (name: string, message: string) => SafeObject;
 export declare const createAggregateErrorValue: (errors: Array<unknown>, message: string) => SafeObject;
 export declare const errorBrandName: (value: unknown) => string | undefined;
 export declare const coerceToString: (value: unknown) => string;
 export declare const coerceToNumber: (value: unknown) => number;
-export declare const invokeCoercion: (ref: CoercionFunction, args: Array<unknown>, node: AstNode) => unknown;
+type Coercion = "Number" | "String" | "Boolean" | "parseInt" | "parseFloat" | "isFinite" | "isNaN";
+/** A global coercion function such as `Number` or `parseInt`. */
+export declare const coercion: (name: Coercion, options?: SyncOptions) => HostFunction;
+export {};