@opencode/codemode 2.0.1 → 2.0.2

package/dist/stdlib/string.js

@@ -1,51 +1,214 @@
-import { sync } from "../interpreter/host.js";
-import { InterpreterRuntimeError } from "../interpreter/model.js";
-import { coercion } from "./value.js";
-export const stringMethods = new Set([
-    "toLowerCase",
-    "toUpperCase",
-    "trim",
-    "trimStart",
-    "trimEnd",
-    "trimLeft",
-    "trimRight",
-    "split",
-    "slice",
-    "substring",
-    "substr",
-    "includes",
-    "startsWith",
-    "endsWith",
-    "indexOf",
-    "lastIndexOf",
-    "replace",
-    "replaceAll",
-    "repeat",
-    "padStart",
-    "padEnd",
-    "charAt",
-    "charCodeAt",
-    "codePointAt",
-    "at",
-    "concat",
-    "toString",
-    "match",
-    "matchAll",
-    "search",
-    "localeCompare",
-    "normalize",
-    "isWellFormed",
-    "toWellFormed",
-]);
-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);
+import { Effect } from "effect";
+import { toProgram } from "../data.js";
+import { constructor, methods } from "../interpreter/native.js";
+import { InterpreterRuntimeError, rangeError } from "../interpreter/model.js";
+import { ProgramArray, ProgramPromise, ProgramRegExp, record } from "../interpreter/objects.js";
+import { containsOpaqueReference, typeofValue } from "../interpreter/references.js";
+import { applyCollectionCallback, isSupportedCallback } from "../interpreter/runner.js";
+import { matchToValue, toHostRegex } from "./regexp.js";
+import { coerceToNumber, coerceToString, coercion } from "./value.js";
+// console is intercepted by the interpreter before reaching here.
+const requireDataArgument = (name, index, arg, node) => {
+    if (containsOpaqueReference(arg)) {
+        throw new InterpreterRuntimeError(`String.${name} expects argument ${index + 1} to be a data value.`, node, "InvalidDataValue");
+    }
     return arg;
-})));
-export const stringGlobal = coercion("String", {
-    instanceOf: () => false,
-    members: {
-        fromCharCode: codeUnits("fromCharCode", String.fromCharCode),
-        fromCodePoint: codeUnits("fromCodePoint", String.fromCodePoint),
-    },
-});
+};
+const replaceAllNeedsGlobal = (pattern, node) => {
+    if (!pattern.global) {
+        throw new InterpreterRuntimeError(`String.replaceAll requires a regular expression with the global (g) flag: write /${pattern.source}/${pattern.flags}g, or use String.replace to replace only the first match.`, node);
+    }
+};
+const replaceWithCallback = (runner, value, name, args, node) => {
+    const protos = runner.prototypes;
+    const apply = applyCollectionCallback(runner, args[1], `String.${name}`, node);
+    const matches = [];
+    const collect = (...callbackArgs) => {
+        const match = callbackArgs[0];
+        const groups = callbackArgs[callbackArgs.length - 1];
+        const hasGroups = groups !== null && typeof groups === "object";
+        const offset = callbackArgs[callbackArgs.length - (hasGroups ? 3 : 2)];
+        if (typeof match !== "string" || typeof offset !== "number") {
+            throw new InterpreterRuntimeError(`String.${name} produced an invalid replacement match.`, node);
+        }
+        if (hasGroups)
+            callbackArgs[callbackArgs.length - 1] = record(protos.Object, groups);
+        matches.push({ match, offset, args: callbackArgs });
+        return match;
+    };
+    const pattern = args[0];
+    if (pattern instanceof ProgramRegExp) {
+        if (name === "replaceAll")
+            replaceAllNeedsGlobal(pattern.regex, node);
+        if (name === "replace")
+            value.replace(pattern.regex, collect);
+        else
+            value.replaceAll(pattern.regex, collect);
+    }
+    else {
+        const search = coerceToString(requireDataArgument(name, 0, pattern, node));
+        if (name === "replace")
+            value.replace(search, collect);
+        else
+            value.replaceAll(search, collect);
+    }
+    return Effect.gen(function* () {
+        const output = [];
+        let end = 0;
+        for (const match of matches) {
+            const replacement = yield* apply(match.args);
+            output.push(value.slice(end, match.offset), replacement instanceof ProgramPromise
+                ? "[object Promise]"
+                : coerceToString(toProgram(protos, replacement, `String.${name} replacer result`)));
+            end = match.offset + match.match.length;
+        }
+        output.push(value.slice(end));
+        return output.join("");
+    });
+};
+export const stringGlobal = (runner) => {
+    const protos = runner.prototypes;
+    const string = constructor(protos, protos.String, {
+        name: "String",
+        length: 1,
+        call: coercion(runner, "String").call,
+    });
+    const codeUnits = (name, op) => [
+        name,
+        1,
+        (_, args, node) => op(...args.map((arg) => {
+            if (typeof arg !== "number") {
+                throw new InterpreterRuntimeError(`String.${name} expects number arguments.`, node);
+            }
+            return arg;
+        })),
+    ];
+    methods(protos, string, [
+        codeUnits("fromCharCode", String.fromCharCode),
+        codeUnits("fromCodePoint", String.fromCodePoint),
+    ]);
+    const self = (thisValue, name, node) => {
+        if (typeof thisValue === "string")
+            return thisValue;
+        if (thisValue === null || thisValue === undefined) {
+            throw new InterpreterRuntimeError(`String.prototype.${name} called on null or undefined.`, node);
+        }
+        return coerceToString(thisValue);
+    };
+    // Coerce arguments like native JS; opaque runtime references still reject.
+    const str = (name, args, index, node) => coerceToString(requireDataArgument(name, index, args[index], node));
+    const num = (name, args, index, node) => coerceToNumber(requireDataArgument(name, index, args[index], node));
+    const optNum = (name, args, index, node) => args[index] === undefined ? undefined : num(name, args, index, node);
+    const optStr = (name, args, index, node) => args[index] === undefined ? undefined : str(name, args, index, node);
+    const rejectRegex = (name, args, node) => {
+        if (args[0] instanceof ProgramRegExp) {
+            throw new InterpreterRuntimeError(`String.${name} cannot take a regular expression; use regex.test(string) or String.search instead.`, node);
+        }
+    };
+    const simple = (name, length, op) => [name, length, (thisValue, args, node) => op(self(thisValue, name, node), args, node)];
+    const replace = (name) => simple(name, 2, (value, args, node) => {
+        if (isSupportedCallback(args[1]))
+            return replaceWithCallback(runner, value, name, args, node);
+        if (typeofValue(args[1]) === "function") {
+            throw new InterpreterRuntimeError(`String.${name} cannot use this callable as a replacer; wrap it in an arrow function, e.g. (match) => tools.ns.tool(match).`, node);
+        }
+        if (args[0] instanceof ProgramRegExp) {
+            const pattern = args[0].regex;
+            const replacement = str(name, args, 1, node);
+            if (name === "replaceAll")
+                replaceAllNeedsGlobal(pattern, node);
+            return name === "replace" ? value.replace(pattern, replacement) : value.replaceAll(pattern, replacement);
+        }
+        if (name === "replace")
+            return value.replace(str(name, args, 0, node), str(name, args, 1, node));
+        return value.replaceAll(str(name, args, 0, node), str(name, args, 1, node));
+    });
+    methods(protos, protos.String, [
+        simple("toString", 0, (value) => value),
+        simple("valueOf", 0, (value) => value),
+        simple("toLowerCase", 0, (value) => value.toLowerCase()),
+        simple("toUpperCase", 0, (value) => value.toUpperCase()),
+        simple("trim", 0, (value) => value.trim()),
+        simple("trimStart", 0, (value) => value.trimStart()),
+        simple("trimLeft", 0, (value) => value.trimStart()),
+        simple("trimEnd", 0, (value) => value.trimEnd()),
+        simple("trimRight", 0, (value) => value.trimEnd()),
+        // Locale/options are deliberately unsupported; comparison uses the host default locale.
+        simple("localeCompare", 1, (value, args, node) => value.localeCompare(str("localeCompare", args, 0, node))),
+        simple("normalize", 0, (value, args, node) => {
+            const form = optStr("normalize", args, 0, node);
+            try {
+                return value.normalize(form);
+            }
+            catch {
+                throw rangeError(`String.normalize expects the form "NFC", "NFD", "NFKC", or "NFKD" (got ${JSON.stringify(form)}).`, node);
+            }
+        }),
+        simple("split", 2, (value, args, node) => {
+            const wrap = (parts) => new ProgramArray(protos.Array, parts);
+            // Native: an undefined separator returns the whole string, not a split on "undefined",
+            // unless the limit truncates to zero.
+            const requestedLimit = optNum("split", args, 1, node);
+            if (args[0] === undefined) {
+                return wrap(requestedLimit !== undefined && requestedLimit >>> 0 === 0 ? [] : [value]);
+            }
+            if (args[0] instanceof ProgramRegExp)
+                return wrap(value.split(args[0].regex, requestedLimit));
+            return wrap(value.split(str("split", args, 0, node), requestedLimit === undefined ? undefined : requestedLimit >>> 0));
+        }),
+        simple("slice", 2, (value, args, node) => value.slice(optNum("slice", args, 0, node), optNum("slice", args, 1, node))),
+        simple("includes", 1, (value, args, node) => {
+            rejectRegex("includes", args, node);
+            return value.includes(str("includes", args, 0, node), optNum("includes", args, 1, node));
+        }),
+        simple("startsWith", 1, (value, args, node) => {
+            rejectRegex("startsWith", args, node);
+            return value.startsWith(str("startsWith", args, 0, node), optNum("startsWith", args, 1, node));
+        }),
+        simple("endsWith", 1, (value, args, node) => {
+            rejectRegex("endsWith", args, node);
+            return value.endsWith(str("endsWith", args, 0, node), optNum("endsWith", args, 1, node));
+        }),
+        simple("indexOf", 1, (value, args, node) => value.indexOf(str("indexOf", args, 0, node), optNum("indexOf", args, 1, node))),
+        simple("lastIndexOf", 1, (value, args, node) => value.lastIndexOf(str("lastIndexOf", args, 0, node), optNum("lastIndexOf", args, 1, node))),
+        replace("replace"),
+        replace("replaceAll"),
+        simple("match", 1, (value, args, node) => {
+            const pattern = toHostRegex(args[0], "match", node);
+            const matched = value.match(pattern);
+            if (matched === null)
+                return null;
+            // Preserve the own `index` and `groups` properties on non-global matches.
+            if (pattern.global)
+                return toProgram(protos, matched, "String.match result");
+            return matchToValue(protos, matched);
+        }),
+        simple("matchAll", 1, (value, args, node) => {
+            const pattern = toHostRegex(args[0], "matchAll", node, "g");
+            if (!pattern.global) {
+                throw new InterpreterRuntimeError(`String.matchAll requires a regular expression with the global (g) flag: write /${pattern.source}/${pattern.flags}g, or use String.match for a single match.`, node);
+            }
+            return new ProgramArray(protos.Array, Array.from(value.matchAll(pattern), (match) => matchToValue(protos, match)));
+        }),
+        simple("search", 1, (value, args, node) => value.search(toHostRegex(args[0], "search", node))),
+        simple("repeat", 1, (value, args, node) => {
+            const count = num("repeat", args, 0, node);
+            if (!Number.isFinite(count) || count < 0) {
+                throw rangeError("String.repeat expects a finite non-negative count.", node);
+            }
+            return value.repeat(count);
+        }),
+        simple("padStart", 1, (value, args, node) => value.padStart(num("padStart", args, 0, node), optStr("padStart", args, 1, node))),
+        simple("padEnd", 1, (value, args, node) => value.padEnd(num("padEnd", args, 0, node), optStr("padEnd", args, 1, node))),
+        simple("charAt", 1, (value, args, node) => value.charAt(optNum("charAt", args, 0, node) ?? 0)),
+        simple("at", 1, (value, args, node) => value.at(optNum("at", args, 0, node) ?? 0)),
+        simple("substring", 2, (value, args, node) => value.substring(optNum("substring", args, 0, node) ?? 0, optNum("substring", args, 1, node))),
+        simple("substr", 2, (value, args, node) => value.substr(optNum("substr", args, 0, node) ?? 0, optNum("substr", args, 1, node))),
+        simple("isWellFormed", 0, (value) => value.isWellFormed()),
+        simple("toWellFormed", 0, (value) => value.toWellFormed()),
+        simple("charCodeAt", 1, (value, args, node) => value.charCodeAt(optNum("charCodeAt", args, 0, node) ?? 0)),
+        simple("codePointAt", 1, (value, args, node) => value.codePointAt(optNum("codePointAt", args, 0, node) ?? 0)),
+        simple("concat", 1, (value, args, node) => value.concat(...args.map((_, index) => str("concat", args, index, node)))),
+    ]);
+    return string;
+};

package/dist/stdlib/url.d.ts

@@ -1,16 +1,8 @@
-import { HostFunction } from "../interpreter/host.js";
-import { type AstNode } from "../interpreter/model.js";
+import type { Prototypes } from "../interpreter/intrinsics.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 urlSearchParamsMethods: Set<string>;
-export declare const uriArgument: (value: unknown, label: string) => string;
+export declare const uriArgument: (protos: Prototypes, value: unknown, label: string) => 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 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 declare const uriGlobal: <R>(runner: Runner<R>, name: UriFunction) => import("../interpreter/objects.js").NativeFunction<R>;
+export declare const urlGlobal: <R>(runner: Runner<R>) => import("../interpreter/objects.js").NativeFunction<R>;
+export declare const urlSearchParamsGlobal: <R>(runner: Runner<R>) => import("../interpreter/objects.js").NativeFunction<R>;
 export {};

package/dist/stdlib/url.js

@@ -1,13 +1,12 @@
 import { Effect } from "effect";
-import { toProgram } from "../data.js";
-import { HostFunction, requiresNew, sync, syncCall } from "../interpreter/host.js";
+import { toProgram, ToolRuntimeError } from "../data.js";
+import { constructor, fn, methods, prototypeFrom, receiver, requiresNew } from "../interpreter/native.js";
 import { InterpreterRuntimeError, uriError } from "../interpreter/model.js";
-import { ownEntries, ProgramObject } from "../interpreter/objects.js";
+import { defineAccessor, entries, isWrapper, ProgramArray, ProgramObject, ProgramURL, ProgramURLSearchParams, } from "../interpreter/objects.js";
 import { isRuntimeReference } from "../interpreter/references.js";
-import { preserveConsumerError } from "../interpreter/runner.js";
-import { Values } from "../values.js";
+import { applyCollectionCallback, preserveConsumerError } from "../interpreter/runner.js";
 import { coerceToString } from "./value.js";
-export const urlProperties = new Set([
+const urlProperties = [
     "href",
     "origin",
     "protocol",
@@ -19,43 +18,16 @@ export const urlProperties = new Set([
     "pathname",
     "search",
     "hash",
-]);
-export const urlWritableProperties = new Set([
-    "href",
-    "protocol",
-    "username",
-    "password",
-    "host",
-    "hostname",
-    "port",
-    "pathname",
-    "search",
-    "hash",
-]);
-export const urlMethods = new Set(["toString", "toJSON"]);
-export const urlSearchParamsMethods = new Set([
-    "append",
-    "delete",
-    "get",
-    "getAll",
-    "has",
-    "set",
-    "sort",
-    "forEach",
-    "keys",
-    "values",
-    "entries",
-    "toString",
-]);
-export const uriArgument = (value, label) => coerceToString(toProgram(value, label));
+];
+export const uriArgument = (protos, value, label) => coerceToString(toProgram(protos, value, label));
 const uriFunctions = {
     encodeURI,
     encodeURIComponent,
     decodeURI,
     decodeURIComponent,
 };
-export const uriGlobal = (name) => sync(name, (args, node) => {
-    const value = uriArgument(args[0], `${name} input`);
+export const uriGlobal = (runner, name) => fn(runner.prototypes, name, 1, (_, args, node) => {
+    const value = uriArgument(runner.prototypes, args[0], `${name} input`);
     try {
         return uriFunctions[name](value);
     }
@@ -63,42 +35,72 @@ export const uriGlobal = (name) => sync(name, (args, node) => {
         throw uriError(`${name} received malformed URI data: ${error instanceof Error ? error.message : String(error)}`, node);
     }
 });
-export const urlArgument = (value, label) => value instanceof Values.URL ? value.url.href : uriArgument(value, label);
-const urlStatic = (name) => sync(`URL.${name}`, (args, node) => {
-    if (args.length === 0) {
-        throw new InterpreterRuntimeError(`URL.${name} requires a URL argument.`, node);
-    }
-    const input = urlArgument(args[0], `URL.${name} input`);
-    const base = args[1] === undefined ? undefined : urlArgument(args[1], `URL.${name} base`);
-    try {
-        const url = new URL(input, base);
-        return name === "canParse" ? true : new Values.URL(url);
-    }
-    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);
-    }
-    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);
+const urlArgument = (protos, value, label) => value instanceof ProgramURL ? value.url.href : uriArgument(protos, value, label);
+export const urlGlobal = (runner) => {
+    const protos = runner.prototypes;
+    const proto = protos.URL;
+    const construct = (args, into, node) => {
+        if (args.length === 0) {
+            throw new InterpreterRuntimeError("new URL(...) requires a URL string and an optional base URL.", node);
+        }
+        const input = urlArgument(protos, args[0], "new URL input");
+        const base = args[1] === undefined ? undefined : urlArgument(protos, args[1], "new URL base");
+        try {
+            return new ProgramURL(into, protos.URLSearchParams, new URL(input, base));
+        }
+        catch {
+            throw new InterpreterRuntimeError(`new URL(...) received an invalid URL${base === undefined ? "" : " or base URL"}.`, node);
+        }
+    };
+    const url = constructor(protos, proto, {
+        name: "URL",
+        length: 1,
+        call: requiresNew("URL"),
+        construct: (args, newTarget, node) => Effect.sync(() => construct(args, prototypeFrom(newTarget, proto), node)),
+    });
+    const parse = (name) => [
+        name,
+        1,
+        (_, args, node) => {
+            if (args.length === 0)
+                throw new InterpreterRuntimeError(`URL.${name} requires a URL argument.`, node);
+            const input = urlArgument(protos, args[0], `URL.${name} input`);
+            const base = args[1] === undefined ? undefined : urlArgument(protos, args[1], `URL.${name} base`);
+            try {
+                const parsed = new URL(input, base);
+                return name === "canParse" ? true : new ProgramURL(proto, protos.URLSearchParams, parsed);
+            }
+            catch {
+                return name === "canParse" ? false : null;
+            }
+        },
+    ];
+    methods(protos, url, [parse("canParse"), parse("parse")]);
+    const self = (thisValue, name, node) => receiver(ProgramURL, thisValue, `URL.prototype.${name}`, node);
+    for (const name of urlProperties) {
+        defineAccessor(proto, name, (thisValue) => self(thisValue, name).url[name], name === "origin"
+            ? undefined
+            : (thisValue, value) => {
+                const target = self(thisValue, name);
+                try {
+                    ;
+                    target.url[name] = uriArgument(protos, value, `URL.${name} value`);
+                }
+                catch (error) {
+                    if (error instanceof InterpreterRuntimeError || error instanceof ToolRuntimeError)
+                        throw error;
+                    throw new InterpreterRuntimeError(`URL.${name} received an invalid value.`);
+                }
+            });
     }
+    defineAccessor(proto, "searchParams", (thisValue) => self(thisValue, "searchParams").searchParams);
+    methods(protos, proto, [
+        ["toString", 0, (thisValue, _, node) => self(thisValue, "toString", node).url.href],
+        ["toJSON", 0, (thisValue, _, node) => self(thisValue, "toJSON", node).url.href],
+    ]);
+    return url;
 };
-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 readPair = (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);
@@ -108,54 +110,152 @@ const readURLSearchParamsPair = (runner, value, node) => Effect.gen(function* ()
         const step = yield* cursor.next;
         if (step.done)
             return items;
-        items.push(yield* preserveConsumerError(cursor, Effect.sync(() => uriArgument(step.value, "URLSearchParams pair value"))));
+        items.push(yield* preserveConsumerError(cursor, Effect.sync(() => uriArgument(runner.prototypes, step.value, "URLSearchParams pair value"))));
     }
 });
-const constructURLSearchParams = (runner, init, node) => {
+const constructURLSearchParams = (runner, init, proto, node) => {
+    const wrap = (params) => new ProgramURLSearchParams(proto, params);
     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)));
-    }
+        return Effect.succeed(wrap(new URLSearchParams()));
+    if (init instanceof ProgramURLSearchParams)
+        return Effect.succeed(wrap(new URLSearchParams(init.params)));
     if (typeof init === "string")
-        return Effect.succeed(new Values.URLSearchParams(new URLSearchParams(init)));
+        return Effect.succeed(wrap(new URLSearchParams(init)));
     if (init === null || typeof init === "number" || typeof init === "boolean") {
-        return Effect.succeed(new Values.URLSearchParams(new URLSearchParams(coerceToString(init))));
+        return Effect.succeed(wrap(new URLSearchParams(coerceToString(init))));
     }
     return Effect.gen(function* () {
         const cursor = yield* runner.syncIterator(init, node);
         if (cursor !== undefined) {
-            const entries = [];
+            const pairs = [];
             while (true) {
                 const step = yield* cursor.next;
                 if (step.done) {
-                    if (entries.some((entry) => entry.length !== 2)) {
+                    if (pairs.some((entry) => entry.length !== 2)) {
                         throw new InterpreterRuntimeError("new URLSearchParams(...) expects iterable [name, value] pairs.", node);
                     }
-                    return new Values.URLSearchParams(new URLSearchParams(entries.map((entry) => [entry[0] ?? "", entry[1] ?? ""])));
+                    return wrap(new URLSearchParams(pairs.map((entry) => [entry[0] ?? "", entry[1] ?? ""])));
                 }
-                entries.push(yield* preserveConsumerError(cursor, readURLSearchParamsPair(runner, step.value, node)));
+                pairs.push(yield* preserveConsumerError(cursor, readPair(runner, step.value, node)));
             }
         }
         if (isRuntimeReference(init)) {
             throw new InterpreterRuntimeError("new URLSearchParams(...) expects a query string, data object, or synchronous iterable pairs.", node);
         }
-        if (Values.isValue(init))
-            return new Values.URLSearchParams(new URLSearchParams());
+        if (isWrapper(init))
+            return wrap(new URLSearchParams());
         if (!(init instanceof ProgramObject)) {
             throw new InterpreterRuntimeError("new URLSearchParams(...) expects a query string, data object, iterable pairs, or URLSearchParams.", node);
         }
-        return new Values.URLSearchParams(new URLSearchParams(Object.fromEntries(ownEntries(init).map(([key, value]) => [key, coerceToString(value)]))));
+        return wrap(new URLSearchParams(Object.fromEntries(entries(init).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;
-    throw new InterpreterRuntimeError(`URL method '${name}' is not available.`, node);
+export const urlSearchParamsGlobal = (runner) => {
+    const protos = runner.prototypes;
+    const proto = protos.URLSearchParams;
+    const searchParams = constructor(protos, proto, {
+        name: "URLSearchParams",
+        call: requiresNew("URLSearchParams"),
+        construct: (args, newTarget, node) => constructURLSearchParams(runner, args[0], prototypeFrom(newTarget, proto), node),
+    });
+    const self = (thisValue, name, node) => receiver(ProgramURLSearchParams, thisValue, `URLSearchParams.prototype.${name}`, node);
+    const wrap = (items) => new ProgramArray(protos.Array, items);
+    const arg = (name, args, index) => uriArgument(protos, args[index], `URLSearchParams.${name} argument ${index + 1}`);
+    const requireArgs = (name, args, count, node) => {
+        if (args.length < count) {
+            throw new InterpreterRuntimeError(`URLSearchParams.${name} requires ${count} argument${count === 1 ? "" : "s"}.`, node);
+        }
+    };
+    defineAccessor(proto, "size", (thisValue) => self(thisValue, "size").params.size);
+    methods(protos, proto, [
+        [
+            "append",
+            2,
+            (thisValue, args, node) => {
+                requireArgs("append", args, 2, node);
+                self(thisValue, "append", node).params.append(arg("append", args, 0), arg("append", args, 1));
+                return undefined;
+            },
+        ],
+        [
+            "delete",
+            1,
+            (thisValue, args, node) => {
+                requireArgs("delete", args, 1, node);
+                const params = self(thisValue, "delete", node).params;
+                if (args[1] !== undefined)
+                    params.delete(arg("delete", args, 0), arg("delete", args, 1));
+                else
+                    params.delete(arg("delete", args, 0));
+                return undefined;
+            },
+        ],
+        [
+            "get",
+            1,
+            (thisValue, args, node) => {
+                requireArgs("get", args, 1, node);
+                return self(thisValue, "get", node).params.get(arg("get", args, 0));
+            },
+        ],
+        [
+            "getAll",
+            1,
+            (thisValue, args, node) => {
+                requireArgs("getAll", args, 1, node);
+                return wrap(self(thisValue, "getAll", node).params.getAll(arg("getAll", args, 0)));
+            },
+        ],
+        [
+            "has",
+            1,
+            (thisValue, args, node) => {
+                requireArgs("has", args, 1, node);
+                const params = self(thisValue, "has", node).params;
+                return args[1] !== undefined
+                    ? params.has(arg("has", args, 0), arg("has", args, 1))
+                    : params.has(arg("has", args, 0));
+            },
+        ],
+        [
+            "set",
+            2,
+            (thisValue, args, node) => {
+                requireArgs("set", args, 2, node);
+                self(thisValue, "set", node).params.set(arg("set", args, 0), arg("set", args, 1));
+                return undefined;
+            },
+        ],
+        [
+            "sort",
+            0,
+            (thisValue, _, node) => {
+                self(thisValue, "sort", node).params.sort();
+                return undefined;
+            },
+        ],
+        ["keys", 0, (thisValue, _, node) => wrap(Array.from(self(thisValue, "keys", node).params.keys()))],
+        ["values", 0, (thisValue, _, node) => wrap(Array.from(self(thisValue, "values", node).params.values()))],
+        [
+            "entries",
+            0,
+            (thisValue, _, node) => wrap(Array.from(self(thisValue, "entries", node).params.entries(), ([key, value]) => wrap([key, value]))),
+        ],
+        ["toString", 0, (thisValue, _, node) => self(thisValue, "toString", node).params.toString()],
+        [
+            "forEach",
+            1,
+            (thisValue, args, node) => {
+                requireArgs("forEach", args, 1, node);
+                const target = self(thisValue, "forEach", node);
+                const apply = applyCollectionCallback(runner, args[0], "URLSearchParams.forEach", node);
+                return Effect.gen(function* () {
+                    for (const [key, value] of Array.from(target.params.entries()))
+                        yield* apply([value, key, target]);
+                    return undefined;
+                });
+            },
+        ],
+    ]);
+    return searchParams;
 };

package/dist/stdlib/value.d.ts

@@ -1,8 +1,9 @@
-import { type HostFunction, type SyncOptions } from "../interpreter/host.js";
+import { type NativeFunction } from "../interpreter/objects.js";
+import type { Runner } from "../interpreter/runner.js";
 export declare const compoundOperators: Set<string>;
+/** The built-in string form of a value, without consulting program-defined `toString` methods. */
 export declare const coerceToString: (value: unknown) => string;
 export declare const coerceToNumber: (value: unknown) => number;
-type Coercion = "Number" | "String" | "Boolean" | "parseInt" | "parseFloat" | "isFinite" | "isNaN";
+export 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 {};
+export declare const coercion: <R>(runner: Runner<R>, name: Coercion, length?: number) => NativeFunction<R>;