@opencode/codemode 2.0.2 → 2.0.4

package/dist/stdlib/string.js

@@ -1,27 +1,27 @@
 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 { checkArrayLength, checkStringLength } from "../interpreter/limits.js";
+import { invalidData, rangeError, typeError } from "../interpreter/model.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.
-const requireDataArgument = (name, index, arg, node) => {
+const requireDataArgument = (name, index, arg) => {
     if (containsOpaqueReference(arg)) {
-        throw new InterpreterRuntimeError(`String.${name} expects argument ${index + 1} to be a data value.`, node, "InvalidDataValue");
+        throw invalidData(`String.${name} expects argument ${index + 1} to be a data value.`);
     }
     return arg;
 };
-const replaceAllNeedsGlobal = (pattern, node) => {
+const replaceAllNeedsGlobal = (pattern) => {
     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);
+        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, node) => {
-    const protos = runner.prototypes;
-    const apply = applyCollectionCallback(runner, args[1], `String.${name}`, node);
+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];
@@ -29,24 +29,24 @@ const replaceWithCallback = (runner, value, name, args, node) => {
         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);
+            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, node);
+            replaceAllNeedsGlobal(pattern.regex);
         if (name === "replace")
             value.replace(pattern.regex, collect);
         else
             value.replaceAll(pattern.regex, collect);
     }
     else {
-        const search = coerceToString(requireDataArgument(name, 0, pattern, node));
+        const search = coerceToString(requireDataArgument(name, 0, pattern));
         if (name === "replace")
             value.replace(search, collect);
         else
@@ -57,73 +57,75 @@ const replaceWithCallback = (runner, value, name, args, node) => {
         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`)));
+            output.push(value.slice(end, match.offset), replacement instanceof PromiseObj ? "[object Promise]" : coerceToString(replacement));
             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,
         1,
-        (_, args, node) => op(...args.map((arg) => {
+        (_, args) => op(...args.map((arg) => {
             if (typeof arg !== "number") {
-                throw new InterpreterRuntimeError(`String.${name} expects number arguments.`, node);
+                throw typeError(`String.${name} expects number arguments.`);
             }
             return arg;
         })),
     ];
-    methods(protos, string, [
+    methods(builtins, string, [
         codeUnits("fromCharCode", String.fromCharCode),
         codeUnits("fromCodePoint", String.fromCodePoint),
     ]);
-    const self = (thisValue, name, node) => {
+    const self = (thisValue, name) => {
         if (typeof thisValue === "string")
             return thisValue;
         if (thisValue === null || thisValue === undefined) {
-            throw new InterpreterRuntimeError(`String.prototype.${name} called on null or undefined.`, node);
+            throw typeError(`String.prototype.${name} called on null or undefined.`);
         }
         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 str = (name, args, index) => coerceToString(requireDataArgument(name, index, args[index]));
+    const num = (name, args, index) => coerceToNumber(requireDataArgument(name, index, args[index]));
+    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 RegExpObj) {
+            throw typeError(`String.${name} cannot take a regular expression; use regex.test(string) or String.search instead.`);
         }
     };
-    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) => {
+    const simple = (name, length, op) => [
+        name,
+        length,
+        (thisValue, args) => op(self(thisValue, name), args),
+    ];
+    const replace = (name) => simple(name, 2, (value, args) => {
         if (isSupportedCallback(args[1]))
-            return replaceWithCallback(runner, value, name, args, node);
+            return replaceWithCallback(ctx, value, name, args);
         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);
+            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, node);
+            const replacement = str(name, args, 1);
             if (name === "replaceAll")
-                replaceAllNeedsGlobal(pattern, node);
+                replaceAllNeedsGlobal(pattern);
             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));
+            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()),
@@ -134,81 +136,101 @@ export const stringGlobal = (runner) => {
         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);
+        simple("localeCompare", 1, (value, args) => value.localeCompare(str("localeCompare", args, 0))),
+        simple("normalize", 0, (value, args) => {
+            const form = optStr("normalize", args, 0);
             try {
                 return value.normalize(form);
             }
             catch {
-                throw rangeError(`String.normalize expects the form "NFC", "NFD", "NFKC", or "NFKD" (got ${JSON.stringify(form)}).`, node);
+                throw rangeError(`String.normalize expects the form "NFC", "NFD", "NFKC", or "NFKD" (got ${JSON.stringify(form)}).`);
             }
         }),
-        simple("split", 2, (value, args, node) => {
-            const wrap = (parts) => new ProgramArray(protos.Array, parts);
+        simple("split", 2, (value, args) => {
+            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, node);
+            const requestedLimit = optNum("split", args, 1);
             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));
+            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);
+            return wrap(parts);
         }),
-        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("slice", 2, (value, args) => value.slice(optNum("slice", args, 0), optNum("slice", args, 1))),
+        simple("includes", 1, (value, args) => {
+            rejectRegex("includes", args);
+            return value.includes(str("includes", args, 0), optNum("includes", args, 1));
         }),
-        simple("startsWith", 1, (value, args, node) => {
-            rejectRegex("startsWith", args, node);
-            return value.startsWith(str("startsWith", args, 0, node), optNum("startsWith", args, 1, node));
+        simple("startsWith", 1, (value, args) => {
+            rejectRegex("startsWith", args);
+            return value.startsWith(str("startsWith", args, 0), optNum("startsWith", args, 1));
         }),
-        simple("endsWith", 1, (value, args, node) => {
-            rejectRegex("endsWith", args, node);
-            return value.endsWith(str("endsWith", args, 0, node), optNum("endsWith", args, 1, node));
+        simple("endsWith", 1, (value, args) => {
+            rejectRegex("endsWith", args);
+            return value.endsWith(str("endsWith", args, 0), optNum("endsWith", args, 1));
         }),
-        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))),
+        simple("indexOf", 1, (value, args) => value.indexOf(str("indexOf", args, 0), optNum("indexOf", args, 1))),
+        simple("lastIndexOf", 1, (value, args) => value.lastIndexOf(str("lastIndexOf", args, 0), optNum("lastIndexOf", args, 1))),
         replace("replace"),
         replace("replaceAll"),
-        simple("match", 1, (value, args, node) => {
-            const pattern = toHostRegex(args[0], "match", node);
+        simple("match", 1, (value, args) => {
+            const pattern = toHostRegex(args[0], "match");
             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);
+                return new Arr(builtins.Array, [...matched]);
+            return matchToValue(builtins, matched);
         }),
-        simple("matchAll", 1, (value, args, node) => {
-            const pattern = toHostRegex(args[0], "matchAll", node, "g");
+        simple("matchAll", 1, (value, args) => {
+            const pattern = toHostRegex(args[0], "matchAll", "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);
+                throw typeError(`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.`);
+            }
+            const matches = [];
+            for (const match of value.matchAll(pattern)) {
+                checkArrayLength(matches.length + 1);
+                matches.push(matchToValue(builtins, match));
             }
-            return new ProgramArray(protos.Array, Array.from(value.matchAll(pattern), (match) => matchToValue(protos, match)));
+            return new Arr(builtins.Array, matches);
         }),
-        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);
+        simple("search", 1, (value, args) => value.search(toHostRegex(args[0], "search"))),
+        simple("repeat", 1, (value, args) => {
+            const count = num("repeat", args, 0);
             if (!Number.isFinite(count) || count < 0) {
-                throw rangeError("String.repeat expects a finite non-negative count.", node);
+                throw rangeError("String.repeat expects a finite non-negative count.");
             }
+            checkStringLength(value.length * count);
             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("padStart", 1, (value, args) => {
+            const length = num("padStart", args, 0);
+            checkStringLength(length);
+            return value.padStart(length, optStr("padStart", args, 1));
+        }),
+        simple("padEnd", 1, (value, args) => {
+            const length = num("padEnd", args, 0);
+            checkStringLength(length);
+            return value.padEnd(length, optStr("padEnd", args, 1));
+        }),
+        simple("charAt", 1, (value, args) => value.charAt(optNum("charAt", args, 0) ?? 0)),
+        simple("at", 1, (value, args) => value.at(optNum("at", args, 0) ?? 0)),
+        simple("substring", 2, (value, args) => value.substring(optNum("substring", args, 0) ?? 0, optNum("substring", args, 1))),
+        simple("substr", 2, (value, args) => value.substr(optNum("substr", args, 0) ?? 0, optNum("substr", args, 1))),
         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)))),
+        simple("charCodeAt", 1, (value, args) => value.charCodeAt(optNum("charCodeAt", args, 0) ?? 0)),
+        simple("codePointAt", 1, (value, args) => value.codePointAt(optNum("codePointAt", args, 0) ?? 0)),
+        simple("concat", 1, (value, args) => {
+            const joined = value.concat(...args.map((_, index) => str("concat", args, index)));
+            checkStringLength(joined.length);
+            return joined;
+        }),
     ]);
     return string;
 };

package/dist/stdlib/url.d.ts

@@ -1,8 +1,6 @@
-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 { Interpreter } from "../interpreter/interpreter.js";
 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 {};