@opencode/codemode 0.0.0-dev-19530 → 2.0.0

package/dist/stdlib/string.js

@@ -1,214 +1,51 @@
-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");
-    }
+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);
     return arg;
-};
-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;
-};
+})));
+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,8 +1,16 @@
-import type { Prototypes } from "../interpreter/intrinsics.js";
+import { HostFunction } from "../interpreter/host.js";
+import { type AstNode } from "../interpreter/model.js";
 import { type Runner } from "../interpreter/runner.js";
-export declare const uriArgument: (protos: Prototypes, value: unknown, label: string) => string;
+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;
 type UriFunction = "encodeURI" | "encodeURIComponent" | "decodeURI" | "decodeURIComponent";
-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 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 {};

package/dist/stdlib/url.js

@@ -1,12 +1,13 @@
 import { Effect } from "effect";
-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 { defineAccessor, entries, isWrapper, ProgramArray, ProgramObject, ProgramURL, ProgramURLSearchParams, } from "../interpreter/objects.js";
+import { toProgram } from "../data.js";
+import { HostFunction, requiresNew, sync, syncCall } from "../interpreter/host.js";
+import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { ownEntries, ProgramObject } from "../interpreter/objects.js";
 import { isRuntimeReference } from "../interpreter/references.js";
-import { applyCollectionCallback, preserveConsumerError } from "../interpreter/runner.js";
+import { preserveConsumerError } from "../interpreter/runner.js";
+import { Values } from "../values.js";
 import { coerceToString } from "./value.js";
-const urlProperties = [
+export const urlProperties = new Set([
     "href",
     "origin",
     "protocol",
@@ -18,244 +19,143 @@ const urlProperties = [
     "pathname",
     "search",
     "hash",
-];
-export const uriArgument = (protos, value, label) => coerceToString(toProgram(protos, value, label));
+]);
+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));
 const uriFunctions = {
     encodeURI,
     encodeURIComponent,
     decodeURI,
     decodeURIComponent,
 };
-export const uriGlobal = (runner, name) => fn(runner.prototypes, name, 1, (_, args, node) => {
-    const value = uriArgument(runner.prototypes, args[0], `${name} input`);
+export const uriGlobal = (name) => sync(name, (args, node) => {
+    const value = uriArgument(args[0], `${name} input`);
     try {
         return uriFunctions[name](value);
     }
     catch (error) {
-        throw uriError(`${name} received malformed URI data: ${error instanceof Error ? error.message : String(error)}`, node);
+        throw new InterpreterRuntimeError(`${name} received malformed URI data: ${error instanceof Error ? error.message : String(error)}`, node).as("URIError");
     }
 });
-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.`);
-                }
-            });
+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).as("TypeError");
+    }
+    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).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");
     }
-    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;
 };
-const readPair = (runner, value, node) => Effect.gen(function* () {
+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);
+        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(runner.prototypes, step.value, "URLSearchParams pair value"))));
+        items.push(yield* preserveConsumerError(cursor, Effect.sync(() => uriArgument(step.value, "URLSearchParams pair value"))));
     }
 });
-const constructURLSearchParams = (runner, init, proto, node) => {
-    const wrap = (params) => new ProgramURLSearchParams(proto, params);
+const constructURLSearchParams = (runner, init, node) => {
     if (init === undefined)
-        return Effect.succeed(wrap(new URLSearchParams()));
-    if (init instanceof ProgramURLSearchParams)
-        return Effect.succeed(wrap(new URLSearchParams(init.params)));
+        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(wrap(new URLSearchParams(init)));
+        return Effect.succeed(new Values.URLSearchParams(new URLSearchParams(init)));
     if (init === null || typeof init === "number" || typeof init === "boolean") {
-        return Effect.succeed(wrap(new URLSearchParams(coerceToString(init))));
+        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 pairs = [];
+            const entries = [];
             while (true) {
                 const step = yield* cursor.next;
                 if (step.done) {
-                    if (pairs.some((entry) => entry.length !== 2)) {
-                        throw new InterpreterRuntimeError("new URLSearchParams(...) expects iterable [name, value] pairs.", node);
+                    if (entries.some((entry) => entry.length !== 2)) {
+                        throw new InterpreterRuntimeError("new URLSearchParams(...) expects iterable [name, value] pairs.", node).as("TypeError");
                     }
-                    return wrap(new URLSearchParams(pairs.map((entry) => [entry[0] ?? "", entry[1] ?? ""])));
+                    return new Values.URLSearchParams(new URLSearchParams(entries.map((entry) => [entry[0] ?? "", entry[1] ?? ""])));
                 }
-                pairs.push(yield* preserveConsumerError(cursor, readPair(runner, step.value, node)));
+                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);
+            throw new InterpreterRuntimeError("new URLSearchParams(...) expects a query string, data object, or synchronous iterable pairs.", node).as("TypeError");
         }
-        if (isWrapper(init))
-            return wrap(new URLSearchParams());
+        if (Values.isValue(init))
+            return new Values.URLSearchParams(new URLSearchParams());
         if (!(init instanceof ProgramObject)) {
-            throw new InterpreterRuntimeError("new URLSearchParams(...) expects a query string, data object, iterable pairs, or URLSearchParams.", node);
+            throw new InterpreterRuntimeError("new URLSearchParams(...) expects a query string, data object, iterable pairs, or URLSearchParams.", node).as("TypeError");
         }
-        return wrap(new URLSearchParams(Object.fromEntries(entries(init).map(([key, value]) => [key, coerceToString(value)]))));
+        return new Values.URLSearchParams(new URLSearchParams(Object.fromEntries(ownEntries(init).map(([key, value]) => [key, coerceToString(value)]))));
     });
 };
-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;
+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);
 };