@opencode/codemode 0.0.0-dev-19631 → 0.0.0-dev-19633

package/dist/stdlib/regexp.js

@@ -1,7 +1,7 @@
 import { Effect } from "effect";
 import { constructor, methods, prototypeFrom, receiver } from "../interpreter/native.js";
 import { syntaxError, typeError } from "../interpreter/model.js";
-import { define, defineAccessor, getOwn, ProgramArray, ProgramObject, ProgramRegExp, record, set, } from "../interpreter/objects.js";
+import { define, defineAccessor, getOwn, Arr, Obj, RegExpObj, record, set } from "../interpreter/objects.js";
 import { coerceToNumber, coerceToString } from "./value.js";
 const flagProperties = [
     "hasIndices",
@@ -19,7 +19,7 @@ export const toHostRegex = (arg, method, extraFlags = "") => {
     // Native parity: an undefined pattern behaves as an empty pattern.
     if (arg === undefined)
         return new RegExp("", extraFlags);
-    if (arg instanceof ProgramRegExp)
+    if (arg instanceof RegExpObj)
         return arg.regex;
     if (typeof arg === "string") {
         try {
@@ -31,28 +31,28 @@ export const toHostRegex = (arg, method, extraFlags = "") => {
     }
     throw typeError(`String.${method} expects a regular expression (a /pattern/flags literal or new RegExp(...)) or a string pattern, not ${arg === null ? "null" : typeof arg}.`);
 };
-export const matchToValue = (protos, match) => {
-    const result = new ProgramArray(protos.Array, Array.from(match, (group) => group));
+export const matchToValue = (builtins, match) => {
+    const result = new Arr(builtins.Array, Array.from(match, (group) => group));
     if (match.index !== undefined)
         define(result, "index", match.index);
     if (match.input !== undefined)
         define(result, "input", match.input);
     if (match.groups)
-        define(result, "groups", record(protos.Object, match.groups));
+        define(result, "groups", record(builtins.Object, match.groups));
     if (match.indices)
-        define(result, "indices", indicesToValue(protos, match.indices));
+        define(result, "indices", indicesToValue(builtins, match.indices));
     return result;
 };
-export const constructRegExp = (protos, args, proto = protos.RegExp) => {
+export const constructRegExp = (builtins, args, proto = builtins.RegExp) => {
     const first = args[0];
-    const pattern = first instanceof ProgramRegExp ? first.regex.source : first === undefined ? "" : coerceToString(first);
+    const pattern = first instanceof RegExpObj ? first.regex.source : first === undefined ? "" : coerceToString(first);
     const flagsArg = args[1];
     if (flagsArg !== undefined && typeof flagsArg !== "string") {
         throw syntaxError(`RegExp flags must be a string of flag characters (e.g. "g", "gi"), not ${flagsArg === null ? "null" : typeof flagsArg}.`);
     }
-    const flags = flagsArg ?? (first instanceof ProgramRegExp ? first.regex.flags : "");
+    const flags = flagsArg ?? (first instanceof RegExpObj ? first.regex.flags : "");
     try {
-        return new ProgramRegExp(proto, pattern, flags);
+        return new RegExpObj(proto, pattern, flags);
     }
     catch (error) {
         const reason = regexFailureReason(error);
@@ -68,16 +68,16 @@ const toLength = (value) => {
     return Math.min(Math.floor(number), Number.MAX_SAFE_INTEGER);
 };
 // RegExp constructs identically with or without new, like JS.
-export const regexpGlobal = (runner) => {
-    const protos = runner.prototypes;
-    const proto = protos.RegExp;
-    const regexp = constructor(protos, proto, {
+export const regexpGlobal = (ctx) => {
+    const builtins = ctx.builtins;
+    const proto = builtins.RegExp;
+    const regexp = constructor(builtins, proto, {
         name: "RegExp",
         length: 2,
-        call: (_, args) => Effect.sync(() => constructRegExp(protos, args)),
-        construct: (args, newTarget) => Effect.sync(() => constructRegExp(protos, args, prototypeFrom(newTarget, proto))),
+        call: (_, args) => Effect.sync(() => constructRegExp(builtins, args)),
+        construct: (args, newTarget) => Effect.sync(() => constructRegExp(builtins, args, prototypeFrom(newTarget, proto))),
     });
-    methods(protos, regexp, [
+    methods(builtins, regexp, [
         [
             "escape",
             1,
@@ -88,7 +88,7 @@ export const regexpGlobal = (runner) => {
             },
         ],
     ]);
-    const self = (thisValue, name) => receiver(ProgramRegExp, thisValue, `RegExp.prototype.${name}`);
+    const self = (thisValue, name) => receiver(RegExpObj, thisValue, `RegExp.prototype.${name}`);
     defineAccessor(proto, "source", (thisValue) => self(thisValue, "source").regex.source);
     defineAccessor(proto, "flags", (thisValue) => self(thisValue, "flags").regex.flags);
     for (const name of flagProperties)
@@ -107,22 +107,22 @@ export const regexpGlobal = (runner) => {
                 set(value, "lastIndex", value.regex.lastIndex);
             if (name === "test")
                 return matched !== null;
-            return matched === null ? null : matchToValue(protos, matched);
+            return matched === null ? null : matchToValue(builtins, matched);
         },
     ];
-    methods(protos, proto, [
+    methods(builtins, proto, [
         run("exec"),
         run("test"),
         ["toString", 0, (thisValue) => coerceToString(self(thisValue, "toString"))],
     ]);
     return regexp;
 };
-const indicesToValue = (protos, indices) => {
-    const range = (pair) => pair === undefined ? undefined : new ProgramArray(protos.Array, [...pair]);
-    const result = new ProgramArray(protos.Array, Array.from(indices, range));
+const indicesToValue = (builtins, indices) => {
+    const range = (pair) => pair === undefined ? undefined : new Arr(builtins.Array, [...pair]);
+    const result = new Arr(builtins.Array, Array.from(indices, range));
     const groups = indices.groups;
     define(result, "groups", groups === undefined
         ? undefined
-        : record(protos.Object, Object.fromEntries(Object.entries(groups).map(([key, pair]) => [key, range(pair)]))));
+        : record(builtins.Object, Object.fromEntries(Object.entries(groups).map(([key, pair]) => [key, range(pair)]))));
     return result;
 };

package/dist/stdlib/string.d.ts

@@ -1,2 +1,2 @@
-import { type Runner } from "../interpreter/runner.js";
-export declare const stringGlobal: <R>(runner: Runner<R>) => import("../interpreter/objects.js").NativeFunction<R>;
+import type { Interpreter } from "../interpreter/interpreter.js";
+export declare const stringGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;

package/dist/stdlib/string.js

@@ -3,9 +3,9 @@ import { toProgram } from "../data.js";
 import { constructor, methods } from "../interpreter/native.js";
 import { checkArrayLength, checkStringLength } from "../interpreter/limits.js";
 import { invalidData, rangeError, typeError } from "../interpreter/model.js";
-import { ProgramArray, ProgramPromise, ProgramRegExp, record } from "../interpreter/objects.js";
+import { Arr, PromiseObj, RegExpObj, record } from "../interpreter/objects.js";
 import { containsOpaqueReference, typeofValue } from "../interpreter/references.js";
-import { applyCollectionCallback, isSupportedCallback } from "../interpreter/runner.js";
+import { applyCollectionCallback, isSupportedCallback } from "../interpreter/callback.js";
 import { matchToValue, toHostRegex } from "./regexp.js";
 import { coerceToNumber, coerceToString, coercion } from "./value.js";
 // console is intercepted by the interpreter before reaching here.
@@ -20,9 +20,9 @@ const replaceAllNeedsGlobal = (pattern) => {
         throw typeError(`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.`);
     }
 };
-const replaceWithCallback = (runner, value, name, args) => {
-    const protos = runner.prototypes;
-    const apply = applyCollectionCallback(runner, args[1], `String.${name}`);
+const replaceWithCallback = (ctx, value, name, args) => {
+    const builtins = ctx.builtins;
+    const apply = applyCollectionCallback(ctx, args[1], `String.${name}`);
     const matches = [];
     const collect = (...callbackArgs) => {
         const match = callbackArgs[0];
@@ -33,12 +33,12 @@ const replaceWithCallback = (runner, value, name, args) => {
             throw typeError(`String.${name} produced an invalid replacement match.`);
         }
         if (hasGroups)
-            callbackArgs[callbackArgs.length - 1] = record(protos.Object, groups);
+            callbackArgs[callbackArgs.length - 1] = record(builtins.Object, groups);
         matches.push({ match, offset, args: callbackArgs });
         return match;
     };
     const pattern = args[0];
-    if (pattern instanceof ProgramRegExp) {
+    if (pattern instanceof RegExpObj) {
         if (name === "replaceAll")
             replaceAllNeedsGlobal(pattern.regex);
         if (name === "replace")
@@ -58,21 +58,21 @@ const replaceWithCallback = (runner, value, name, args) => {
         let end = 0;
         for (const match of matches) {
             const replacement = yield* apply(match.args);
-            output.push(value.slice(end, match.offset), replacement instanceof ProgramPromise
+            output.push(value.slice(end, match.offset), replacement instanceof PromiseObj
                 ? "[object Promise]"
-                : coerceToString(toProgram(protos, replacement, `String.${name} replacer result`)));
+                : coerceToString(toProgram(builtins, 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, {
+export const stringGlobal = (ctx) => {
+    const builtins = ctx.builtins;
+    const string = constructor(builtins, builtins.String, {
         name: "String",
         length: 1,
-        call: coercion(runner, "String").call,
+        call: coercion(ctx, "String").call,
     });
     const codeUnits = (name, op) => [
         name,
@@ -84,7 +84,7 @@ export const stringGlobal = (runner) => {
             return arg;
         })),
     ];
-    methods(protos, string, [
+    methods(builtins, string, [
         codeUnits("fromCharCode", String.fromCharCode),
         codeUnits("fromCodePoint", String.fromCodePoint),
     ]);
@@ -102,7 +102,7 @@ export const stringGlobal = (runner) => {
     const optNum = (name, args, index) => args[index] === undefined ? undefined : num(name, args, index);
     const optStr = (name, args, index) => args[index] === undefined ? undefined : str(name, args, index);
     const rejectRegex = (name, args) => {
-        if (args[0] instanceof ProgramRegExp) {
+        if (args[0] instanceof RegExpObj) {
             throw typeError(`String.${name} cannot take a regular expression; use regex.test(string) or String.search instead.`);
         }
     };
@@ -113,11 +113,11 @@ export const stringGlobal = (runner) => {
     ];
     const replace = (name) => simple(name, 2, (value, args) => {
         if (isSupportedCallback(args[1]))
-            return replaceWithCallback(runner, value, name, args);
+            return replaceWithCallback(ctx, value, name, args);
         if (typeofValue(args[1]) === "function") {
             throw typeError(`String.${name} cannot use this callable as a replacer; wrap it in an arrow function, e.g. (match) => tools.ns.tool(match).`);
         }
-        if (args[0] instanceof ProgramRegExp) {
+        if (args[0] instanceof RegExpObj) {
             const pattern = args[0].regex;
             const replacement = str(name, args, 1);
             if (name === "replaceAll")
@@ -128,7 +128,7 @@ export const stringGlobal = (runner) => {
             return value.replace(str(name, args, 0), str(name, args, 1));
         return value.replaceAll(str(name, args, 0), str(name, args, 1));
     });
-    methods(protos, protos.String, [
+    methods(builtins, builtins.String, [
         simple("toString", 0, (value) => value),
         simple("valueOf", 0, (value) => value),
         simple("toLowerCase", 0, (value) => value.toLowerCase()),
@@ -150,14 +150,14 @@ export const stringGlobal = (runner) => {
             }
         }),
         simple("split", 2, (value, args) => {
-            const wrap = (parts) => new ProgramArray(protos.Array, parts);
+            const wrap = (parts) => new Arr(builtins.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);
             if (args[0] === undefined) {
                 return wrap(requestedLimit !== undefined && requestedLimit >>> 0 === 0 ? [] : [value]);
             }
-            const parts = args[0] instanceof ProgramRegExp
+            const parts = args[0] instanceof RegExpObj
                 ? value.split(args[0].regex, requestedLimit)
                 : value.split(str("split", args, 0), requestedLimit === undefined ? undefined : requestedLimit >>> 0);
             checkArrayLength(parts.length);
@@ -187,8 +187,8 @@ export const stringGlobal = (runner) => {
                 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);
+                return toProgram(builtins, matched, "String.match result");
+            return matchToValue(builtins, matched);
         }),
         simple("matchAll", 1, (value, args) => {
             const pattern = toHostRegex(args[0], "matchAll", "g");
@@ -198,9 +198,9 @@ export const stringGlobal = (runner) => {
             const matches = [];
             for (const match of value.matchAll(pattern)) {
                 checkArrayLength(matches.length + 1);
-                matches.push(matchToValue(protos, match));
+                matches.push(matchToValue(builtins, match));
             }
-            return new ProgramArray(protos.Array, matches);
+            return new Arr(builtins.Array, matches);
         }),
         simple("search", 1, (value, args) => value.search(toHostRegex(args[0], "search"))),
         simple("repeat", 1, (value, args) => {

package/dist/stdlib/url.d.ts

@@ -1,8 +1,8 @@
-import type { Prototypes } from "../interpreter/intrinsics.js";
-import { type Runner } from "../interpreter/runner.js";
-export declare const uriArgument: (protos: Prototypes, value: unknown, label: string) => string;
+import type { Builtins } from "../interpreter/intrinsics.js";
+import type { Interpreter } from "../interpreter/interpreter.js";
+export declare const uriArgument: (builtins: Builtins, 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: <R>(ctx: Interpreter<R>, name: UriFunction) => import("../interpreter/objects.js").Native<R>;
+export declare const urlGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;
+export declare const urlSearchParamsGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;
 export {};

package/dist/stdlib/url.js

@@ -2,9 +2,9 @@ import { Effect } from "effect";
 import { toProgram, ToolRuntimeError } from "../data.js";
 import { constructor, fn, methods, prototypeFrom, receiver, requiresNew } from "../interpreter/native.js";
 import { PendingThrow, typeError, uriError } from "../interpreter/model.js";
-import { defineAccessor, entries, isWrapper, ProgramArray, ProgramObject, ProgramURL, ProgramURLSearchParams, } from "../interpreter/objects.js";
+import { defineAccessor, entries, isWrapper, Arr, Obj, URLObj, URLSearchParamsObj } from "../interpreter/objects.js";
 import { isRuntimeReference } from "../interpreter/references.js";
-import { applyCollectionCallback, preserveConsumerError } from "../interpreter/runner.js";
+import { applyCollectionCallback, preserveConsumerError } from "../interpreter/callback.js";
 import { coerceToString } from "./value.js";
 const urlProperties = [
     "href",
@@ -19,15 +19,15 @@ const urlProperties = [
     "search",
     "hash",
 ];
-export const uriArgument = (protos, value, label) => coerceToString(toProgram(protos, value, label));
+export const uriArgument = (builtins, value, label) => coerceToString(toProgram(builtins, value, label));
 const uriFunctions = {
     encodeURI,
     encodeURIComponent,
     decodeURI,
     decodeURIComponent,
 };
-export const uriGlobal = (runner, name) => fn(runner.prototypes, name, 1, (_, args) => {
-    const value = uriArgument(runner.prototypes, args[0], `${name} input`);
+export const uriGlobal = (ctx, name) => fn(ctx.builtins, name, 1, (_, args) => {
+    const value = uriArgument(ctx.builtins, args[0], `${name} input`);
     try {
         return uriFunctions[name](value);
     }
@@ -35,24 +35,24 @@ export const uriGlobal = (runner, name) => fn(runner.prototypes, name, 1, (_, ar
         throw uriError(`${name} received malformed URI data: ${error instanceof Error ? error.message : String(error)}`);
     }
 });
-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 urlArgument = (builtins, value, label) => value instanceof URLObj ? value.url.href : uriArgument(builtins, value, label);
+export const urlGlobal = (ctx) => {
+    const builtins = ctx.builtins;
+    const proto = builtins.URL;
     const construct = (args, into) => {
         if (args.length === 0) {
             throw typeError("new URL(...) requires a URL string and an optional base URL.");
         }
-        const input = urlArgument(protos, args[0], "new URL input");
-        const base = args[1] === undefined ? undefined : urlArgument(protos, args[1], "new URL base");
+        const input = urlArgument(builtins, args[0], "new URL input");
+        const base = args[1] === undefined ? undefined : urlArgument(builtins, args[1], "new URL base");
         try {
-            return new ProgramURL(into, protos.URLSearchParams, new URL(input, base));
+            return new URLObj(into, builtins.URLSearchParams, new URL(input, base));
         }
         catch {
             throw typeError(`new URL(...) received an invalid URL${base === undefined ? "" : " or base URL"}.`);
         }
     };
-    const url = constructor(protos, proto, {
+    const url = constructor(builtins, proto, {
         name: "URL",
         length: 1,
         call: requiresNew("URL"),
@@ -64,19 +64,19 @@ export const urlGlobal = (runner) => {
         (_, args) => {
             if (args.length === 0)
                 throw typeError(`URL.${name} requires a URL argument.`);
-            const input = urlArgument(protos, args[0], `URL.${name} input`);
-            const base = args[1] === undefined ? undefined : urlArgument(protos, args[1], `URL.${name} base`);
+            const input = urlArgument(builtins, args[0], `URL.${name} input`);
+            const base = args[1] === undefined ? undefined : urlArgument(builtins, args[1], `URL.${name} base`);
             try {
                 const parsed = new URL(input, base);
-                return name === "canParse" ? true : new ProgramURL(proto, protos.URLSearchParams, parsed);
+                return name === "canParse" ? true : new URLObj(proto, builtins.URLSearchParams, parsed);
             }
             catch {
                 return name === "canParse" ? false : null;
             }
         },
     ];
-    methods(protos, url, [parse("canParse"), parse("parse")]);
-    const self = (thisValue, name) => receiver(ProgramURL, thisValue, `URL.prototype.${name}`);
+    methods(builtins, url, [parse("canParse"), parse("parse")]);
+    const self = (thisValue, name) => receiver(URLObj, thisValue, `URL.prototype.${name}`);
     for (const name of urlProperties) {
         defineAccessor(proto, name, (thisValue) => self(thisValue, name).url[name], name === "origin"
             ? undefined
@@ -84,7 +84,7 @@ export const urlGlobal = (runner) => {
                 const target = self(thisValue, name);
                 try {
                     ;
-                    target.url[name] = uriArgument(protos, value, `URL.${name} value`);
+                    target.url[name] = uriArgument(builtins, value, `URL.${name} value`);
                 }
                 catch (error) {
                     if (error instanceof PendingThrow || error instanceof ToolRuntimeError)
@@ -94,14 +94,14 @@ export const urlGlobal = (runner) => {
             });
     }
     defineAccessor(proto, "searchParams", (thisValue) => self(thisValue, "searchParams").searchParams);
-    methods(protos, proto, [
+    methods(builtins, proto, [
         ["toString", 0, (thisValue) => self(thisValue, "toString").url.href],
         ["toJSON", 0, (thisValue) => self(thisValue, "toJSON").url.href],
     ]);
     return url;
 };
-const readPair = (runner, value) => Effect.gen(function* () {
-    const cursor = yield* runner.syncIterator(value);
+const readPair = (ctx, value) => Effect.gen(function* () {
+    const cursor = yield* ctx.iterate(value);
     if (cursor === undefined) {
         throw typeError("new URLSearchParams(...) expects iterable [name, value] pairs.");
     }
@@ -110,14 +110,14 @@ const readPair = (runner, value) => Effect.gen(function* () {
         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(ctx.builtins, step.value, "URLSearchParams pair value"))));
     }
 });
-const constructURLSearchParams = (runner, init, proto) => {
-    const wrap = (params) => new ProgramURLSearchParams(proto, params);
+const constructURLSearchParams = (ctx, init, proto) => {
+    const wrap = (params) => new URLSearchParamsObj(proto, params);
     if (init === undefined)
         return Effect.succeed(wrap(new URLSearchParams()));
-    if (init instanceof ProgramURLSearchParams)
+    if (init instanceof URLSearchParamsObj)
         return Effect.succeed(wrap(new URLSearchParams(init.params)));
     if (typeof init === "string")
         return Effect.succeed(wrap(new URLSearchParams(init)));
@@ -125,7 +125,7 @@ const constructURLSearchParams = (runner, init, proto) => {
         return Effect.succeed(wrap(new URLSearchParams(coerceToString(init))));
     }
     return Effect.gen(function* () {
-        const cursor = yield* runner.syncIterator(init);
+        const cursor = yield* ctx.iterate(init);
         if (cursor !== undefined) {
             const pairs = [];
             while (true) {
@@ -136,7 +136,7 @@ const constructURLSearchParams = (runner, init, proto) => {
                     }
                     return wrap(new URLSearchParams(pairs.map((entry) => [entry[0] ?? "", entry[1] ?? ""])));
                 }
-                pairs.push(yield* preserveConsumerError(cursor, readPair(runner, step.value)));
+                pairs.push(yield* preserveConsumerError(cursor, readPair(ctx, step.value)));
             }
         }
         if (isRuntimeReference(init)) {
@@ -144,30 +144,30 @@ const constructURLSearchParams = (runner, init, proto) => {
         }
         if (isWrapper(init))
             return wrap(new URLSearchParams());
-        if (!(init instanceof ProgramObject)) {
+        if (!(init instanceof Obj)) {
             throw typeError("new URLSearchParams(...) expects a query string, data object, iterable pairs, or URLSearchParams.");
         }
         return wrap(new URLSearchParams(Object.fromEntries(entries(init).map(([key, value]) => [key, coerceToString(value)]))));
     });
 };
-export const urlSearchParamsGlobal = (runner) => {
-    const protos = runner.prototypes;
-    const proto = protos.URLSearchParams;
-    const searchParams = constructor(protos, proto, {
+export const urlSearchParamsGlobal = (ctx) => {
+    const builtins = ctx.builtins;
+    const proto = builtins.URLSearchParams;
+    const searchParams = constructor(builtins, proto, {
         name: "URLSearchParams",
         call: requiresNew("URLSearchParams"),
-        construct: (args, newTarget) => constructURLSearchParams(runner, args[0], prototypeFrom(newTarget, proto)),
+        construct: (args, newTarget) => constructURLSearchParams(ctx, args[0], prototypeFrom(newTarget, proto)),
     });
-    const self = (thisValue, name) => receiver(ProgramURLSearchParams, thisValue, `URLSearchParams.prototype.${name}`);
-    const wrap = (items) => new ProgramArray(protos.Array, items);
-    const arg = (name, args, index) => uriArgument(protos, args[index], `URLSearchParams.${name} argument ${index + 1}`);
+    const self = (thisValue, name) => receiver(URLSearchParamsObj, thisValue, `URLSearchParams.prototype.${name}`);
+    const wrap = (items) => new Arr(builtins.Array, items);
+    const arg = (name, args, index) => uriArgument(builtins, args[index], `URLSearchParams.${name} argument ${index + 1}`);
     const requireArgs = (name, args, count) => {
         if (args.length < count) {
             throw typeError(`URLSearchParams.${name} requires ${count} argument${count === 1 ? "" : "s"}.`);
         }
     };
     defineAccessor(proto, "size", (thisValue) => self(thisValue, "size").params.size);
-    methods(protos, proto, [
+    methods(builtins, proto, [
         [
             "append",
             2,
@@ -248,7 +248,7 @@ export const urlSearchParamsGlobal = (runner) => {
             (thisValue, args) => {
                 requireArgs("forEach", args, 1);
                 const target = self(thisValue, "forEach");
-                const apply = applyCollectionCallback(runner, args[0], "URLSearchParams.forEach");
+                const apply = applyCollectionCallback(ctx, args[0], "URLSearchParams.forEach");
                 return Effect.gen(function* () {
                     for (const [key, value] of Array.from(target.params.entries()))
                         yield* apply([value, key, target]);

package/dist/stdlib/value.d.ts

@@ -1,9 +1,9 @@
-import { type NativeFunction } from "../interpreter/objects.js";
-import type { Runner } from "../interpreter/runner.js";
+import { type Native } from "../interpreter/objects.js";
+import type { Interpreter } from "../interpreter/interpreter.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;
 export type Coercion = "Number" | "String" | "Boolean" | "parseInt" | "parseFloat" | "isFinite" | "isNaN";
 /** A global coercion function such as `Number` or `parseInt`. */
-export declare const coercion: <R>(runner: Runner<R>, name: Coercion, length?: number) => NativeFunction<R>;
+export declare const coercion: <R>(ctx: Interpreter<R>, name: Coercion, length?: number) => Native<R>;

package/dist/stdlib/value.js

@@ -1,7 +1,7 @@
 import { toProgram } from "../data.js";
 import { fn } from "../interpreter/native.js";
 import { typeError } from "../interpreter/model.js";
-import { get, isWrapper, ProgramArray, ProgramDate, ProgramError, ProgramMap, ProgramRegExp, ProgramSet, ProgramURL, ProgramURLSearchParams, } from "../interpreter/objects.js";
+import { get, isWrapper, Arr, Bytes, DateObj, ErrorObj, MapObj, RegExpObj, SetObj, URLObj, URLSearchParamsObj, } from "../interpreter/objects.js";
 export const compoundOperators = new Set(["+=", "-=", "*=", "/=", "%=", "**=", "&=", "|=", "^=", "<<=", ">>=", ">>>="]);
 /** The built-in string form of a value, without consulting program-defined `toString` methods. */
 export const coerceToString = (value) => {
@@ -9,19 +9,21 @@ export const coerceToString = (value) => {
         return "null";
     if (value === undefined)
         return "undefined";
-    if (value instanceof ProgramDate)
+    if (value instanceof DateObj)
         return Number.isFinite(value.time) ? new Date(value.time).toISOString() : "Invalid Date";
-    if (value instanceof ProgramRegExp)
+    if (value instanceof RegExpObj)
         return `/${value.regex.source}/${value.regex.flags}`;
-    if (value instanceof ProgramMap)
+    if (value instanceof MapObj)
         return "[object Map]";
-    if (value instanceof ProgramSet)
+    if (value instanceof SetObj)
         return "[object Set]";
-    if (value instanceof ProgramURL)
+    if (value instanceof URLObj)
         return value.url.href;
-    if (value instanceof ProgramURLSearchParams)
+    if (value instanceof URLSearchParamsObj)
         return value.params.toString();
-    if (value instanceof ProgramError) {
+    if (value instanceof Bytes)
+        return value.bytes.join(",");
+    if (value instanceof ErrorObj) {
         // Match Error.prototype.toString: "name: message", or just one when the other is empty.
         const name = get(value, "name");
         const message = get(value, "message");
@@ -33,7 +35,7 @@ export const coerceToString = (value) => {
             return shownMessage;
         return `${shownName}: ${shownMessage}`;
     }
-    if (value instanceof ProgramArray) {
+    if (value instanceof Arr) {
         return value.items.map((item) => (item === null || item === undefined ? "" : coerceToString(item))).join(",");
     }
     if (typeof value === "object")
@@ -41,15 +43,17 @@ export const coerceToString = (value) => {
     return String(value);
 };
 export const coerceToNumber = (value) => {
-    if (value instanceof ProgramDate)
+    if (value instanceof DateObj)
         return value.time;
+    if (value instanceof Bytes)
+        return Number(coerceToString(value));
     if (isWrapper(value))
         return Number.NaN;
-    if (value instanceof ProgramArray)
+    if (value instanceof Arr)
         return Number(coerceToString(value));
     return value !== null && typeof value === "object" ? Number.NaN : Number(value);
 };
-const coerce = (runner, name, args) => {
+const coerce = (ctx, name, args) => {
     // Native: Number() is 0 and String() is "", unlike their undefined-argument forms; the
     // other coercers match native through the undefined-argument path below.
     if (args.length === 0) {
@@ -74,7 +78,7 @@ const coerce = (runner, name, args) => {
             return parseInt(coerceToString(raw));
         return parseFloat(coerceToString(raw));
     }
-    const value = toProgram(runner.prototypes, raw, `${name} input`);
+    const value = toProgram(ctx.builtins, raw, `${name} input`);
     if (name === "Number")
         return coerceToNumber(value);
     if (name === "Boolean")
@@ -95,4 +99,4 @@ const coerce = (runner, name, args) => {
     return coerceToString(value);
 };
 /** A global coercion function such as `Number` or `parseInt`. */
-export const coercion = (runner, name, length = 1) => fn(runner.prototypes, name, length, (_, args) => toProgram(runner.prototypes, coerce(runner, name, args), `${name} result`));
+export const coercion = (ctx, name, length = 1) => fn(ctx.builtins, name, length, (_, args) => toProgram(ctx.builtins, coerce(ctx, name, args), `${name} result`));

package/dist/stdlib/web.d.ts

@@ -1,4 +1,4 @@
-import { ProgramObject } from "../interpreter/objects.js";
-import type { Runner } from "../interpreter/runner.js";
-export declare const base64Global: <R>(runner: Runner<R>, name: "atob" | "btoa") => import("../interpreter/objects.js").NativeFunction<R>;
-export declare const cryptoGlobal: <R>(runner: Runner<R>) => ProgramObject;
+import { Obj } from "../interpreter/objects.js";
+import type { Interpreter } from "../interpreter/interpreter.js";
+export declare const base64Global: <R>(ctx: Interpreter<R>, name: "atob" | "btoa") => import("../interpreter/objects.js").Native<R>;
+export declare const cryptoGlobal: <R>(ctx: Interpreter<R>) => Obj;

package/dist/stdlib/web.js

@@ -1,10 +1,11 @@
 import { fn, methods } from "../interpreter/native.js";
 import { typeError } from "../interpreter/model.js";
-import { ProgramObject } from "../interpreter/objects.js";
+import { Bytes, Obj } from "../interpreter/objects.js";
+import { describeValue } from "../interpreter/references.js";
 import { coerceToString } from "./value.js";
 // WebIDL DOMString conversion: a missing argument is a TypeError, anything else stringifies. Invalid input is a
 // TypeError as well; browsers throw a DOMException named InvalidCharacterError, which CodeMode does not have.
-export const base64Global = (runner, name) => fn(runner.prototypes, name, 1, (_, args) => {
+export const base64Global = (ctx, name) => fn(ctx.builtins, name, 1, (_, args) => {
     if (args.length === 0)
         throw typeError(`${name} requires 1 argument (a string)`);
     const input = coerceToString(args[0]);
@@ -15,8 +16,21 @@ export const base64Global = (runner, name) => fn(runner.prototypes, name, 1, (_,
         throw typeError("The string contains invalid characters.");
     }
 });
-export const cryptoGlobal = (runner) => {
-    const object = new ProgramObject(runner.prototypes.Object);
-    methods(runner.prototypes, object, [["randomUUID", 0, () => crypto.randomUUID()]]);
+export const cryptoGlobal = (ctx) => {
+    const object = new Obj(ctx.builtins.Object);
+    methods(ctx.builtins, object, [
+        ["randomUUID", 0, () => crypto.randomUUID()],
+        [
+            "getRandomValues",
+            1,
+            (_, args) => {
+                if (!(args[0] instanceof Bytes)) {
+                    throw typeError(`crypto.getRandomValues expects a Uint8Array, received ${describeValue(args[0])}.`);
+                }
+                crypto.getRandomValues(args[0].bytes);
+                return args[0];
+            },
+        ],
+    ]);
     return object;
 };