@opencode/codemode 0.0.0-beta-19500 → 0.0.0-dev-19274

package/dist/interpreter/methods.js

@@ -1,18 +1,30 @@
 import { Effect } from "effect";
-import { toProgram } from "../data.js";
-import { dateSetterArgumentCount, invokeDateMethod } from "../stdlib/date.js";
-import { invokeNumberMethod } from "../stdlib/number.js";
-import { invokeRegExpMethod, matchToValue, toHostRegex } from "../stdlib/regexp.js";
-import { invokeURLMethod, uriArgument } from "../stdlib/url.js";
-import { coerceToNumber, coerceToString } from "../stdlib/value.js";
-import { compareText } from "../tool-runtime.js";
-import { Values } from "../values.js";
-import { IntrinsicReference, InterpreterRuntimeError } from "./model.js";
-import { get, ProgramArray, ProgramObject, record } from "./objects.js";
-import { containsOpaqueReference, rejectCircularInsertion, typeofValue } from "./references.js";
-import { applyCollectionCallback, isSupportedCallback, toPrimitive } from "./runner.js";
-export const invokeIntrinsic = (runner, ref, args, node) => Effect.map(invoke(runner, ref, args, node), (result) => (Array.isArray(result) ? new ProgramArray(result) : result));
-const invoke = (runner, ref, args, node) => {
+import { CodeModeFunction, CodeModeGenerator, CoercionFunction, ErrorConstructorReference, GlobalMethodReference, GlobalNamespace, IntrinsicReference, InterpreterRuntimeError, JsonMethodReference, PromiseCapabilityFunction, PromiseNamespace, UriFunction, } from "./model.js";
+import { containsOpaqueReference, isRuntimeReference, rejectCircularInsertion, typeofValue } from "./references.js";
+import { isBlockedMember } from "../tool-runtime.js";
+import { CodeModeDate, CodeModeMap, CodeModePromise, CodeModeRegExp, CodeModeSet, CodeModeURL, CodeModeURLSearchParams, isCodeModeValue, } from "../values.js";
+import { dateSetterArgumentCount, invokeDateMethod, invokeDateStatic } from "../stdlib/date.js";
+import { invokeMathMethod } from "../stdlib/math.js";
+import { invokeNumberMethod, invokeNumberStatic } from "../stdlib/number.js";
+import { invokeObjectMethod } from "../stdlib/object.js";
+import { invokeRegExpMethod, invokeRegExpStatic, matchToValue, toHostRegex } from "../stdlib/regexp.js";
+import { invokeStringStatic } from "../stdlib/string.js";
+import { invokeURLMethod, invokeURLStatic, uriArgument } from "../stdlib/url.js";
+import { boundedData, coerceToNumber, coerceToString, errorBrandName } from "../stdlib/value.js";
+import { preserveConsumerError } from "./iterator.js";
+export const isSupportedCallback = (value) => value instanceof CodeModeFunction ||
+    value instanceof CoercionFunction ||
+    value instanceof UriFunction ||
+    value instanceof PromiseCapabilityFunction ||
+    value instanceof GlobalMethodReference ||
+    value instanceof JsonMethodReference ||
+    value instanceof IntrinsicReference ||
+    value instanceof ErrorConstructorReference ||
+    // Callable namespaces dispatch like JS: Array/Object/Date/RegExp construct,
+    // new-requiring constructors throw a TypeError. Math/JSON/console stay non-callable.
+    (value instanceof GlobalNamespace && typeofValue(value) === "function") ||
+    value instanceof PromiseNamespace;
+export const invokeIntrinsic = (runner, ref, args, node) => {
     if (typeof ref.receiver === "string") {
         if (ref.name === "replace" || ref.name === "replaceAll") {
             if (isSupportedCallback(args[1]))
@@ -26,10 +38,10 @@ const invoke = (runner, ref, args, node) => {
     if (typeof ref.receiver === "number") {
         return Effect.succeed(invokeNumberMethod(ref.receiver, ref.name, args, node));
     }
-    if (ref.receiver instanceof ProgramArray) {
+    if (Array.isArray(ref.receiver)) {
         return invokeArrayMethod(runner, ref.receiver, ref.name, args, node);
     }
-    if (ref.receiver instanceof Values.Date) {
+    if (ref.receiver instanceof CodeModeDate) {
         const target = ref.receiver;
         const argumentCount = dateSetterArgumentCount(ref.name);
         if (argumentCount === undefined)
@@ -40,31 +52,70 @@ const invoke = (runner, ref, args, node) => {
             concurrency: 1,
         }), (values) => invokeDateMethod(target, ref.name, values, node, initialTime));
     }
-    if (ref.receiver instanceof Values.RegExp) {
+    if (ref.receiver instanceof CodeModeRegExp) {
         return Effect.succeed(invokeRegExpMethod(ref.receiver, ref.name, args, node));
     }
-    if (ref.receiver instanceof Values.Map) {
+    if (ref.receiver instanceof CodeModeMap) {
         return invokeMapMethod(runner, ref.receiver, ref.name, args, node);
     }
-    if (ref.receiver instanceof Values.Set) {
+    if (ref.receiver instanceof CodeModeSet) {
         return invokeSetMethod(runner, ref.receiver, ref.name, args, node);
     }
-    if (ref.receiver instanceof Values.URL) {
+    if (ref.receiver instanceof CodeModeURL) {
         return Effect.succeed(invokeURLMethod(ref.receiver, ref.name, node));
     }
-    if (ref.receiver instanceof Values.URLSearchParams) {
+    if (ref.receiver instanceof CodeModeURLSearchParams) {
         return invokeURLSearchParamsMethod(runner, ref.receiver, ref.name, args, node);
     }
     throw new InterpreterRuntimeError(`Method '${ref.name}' is not available.`, node);
 };
-/**
- * ToPrimitive: tries an object's own `valueOf`/`toString` in hint order and returns the first
- * primitive result. Runtime values behave like their JS counterparts (Date yields its time under a
- * number hint; the rest yield their string form). An inherited `toString` yields the default
- * string form, so plain objects become "[object Object]" and arrays join.
- */
-const coerceNumericArgument = (runner, value, node) => Effect.map(toPrimitive(runner, value, "number", node), coerceToNumber);
-// console is intercepted by the interpreter before reaching here.
+const coerceNumericArgument = (runner, value, node) => {
+    if (value === null || typeof value !== "object" || Array.isArray(value) || isCodeModeValue(value)) {
+        return Effect.succeed(coerceToNumber(value));
+    }
+    const object = value;
+    return Effect.gen(function* () {
+        if (Object.hasOwn(object, "valueOf") && typeofValue(object.valueOf) === "function") {
+            const result = yield* runner.invokeCallable(object.valueOf, [], node);
+            if (result === null || (typeof result !== "object" && typeof result !== "function")) {
+                return coerceToNumber(result);
+            }
+        }
+        if (!Object.hasOwn(object, "toString"))
+            return coerceToNumber(value);
+        if (typeofValue(object.toString) === "function") {
+            const result = yield* runner.invokeCallable(object.toString, [], node);
+            if (result === null || (typeof result !== "object" && typeof result !== "function")) {
+                return coerceToNumber(result);
+            }
+        }
+        throw new InterpreterRuntimeError("Cannot convert object to primitive value.", node).as("TypeError");
+    });
+};
+export const invokeGlobalMethod = (ref, args, node) => {
+    if (ref.namespace === "console")
+        throw new InterpreterRuntimeError(`console.${ref.name} is not available.`, node);
+    if (ref.namespace === "Object")
+        return invokeObjectMethod(ref.name, args, node);
+    if (ref.namespace === "Math")
+        return invokeMathMethod(ref.name, args, node);
+    if (ref.namespace === "Array")
+        return invokeArrayStatic(ref.name, args, node);
+    if (ref.namespace === "Number")
+        return invokeNumberStatic(ref.name, args, node);
+    if (ref.namespace === "String")
+        return invokeStringStatic(ref.name, args, node);
+    if (ref.namespace === "URL")
+        return invokeURLStatic(ref.name, args, node);
+    if (ref.namespace === "Date")
+        return invokeDateStatic(ref.name, args, node);
+    if (ref.namespace === "RegExp")
+        return invokeRegExpStatic(ref.name, args, node);
+    if (ref.namespace === "Map" || ref.namespace === "Set" || ref.namespace === "URLSearchParams") {
+        throw new InterpreterRuntimeError(`${ref.namespace}.${ref.name} is not available.`, node);
+    }
+    throw new InterpreterRuntimeError(`${ref.namespace}.${ref.name} is not available.`, node);
+};
 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");
@@ -78,7 +129,7 @@ const invokeStringMethod = (value, name, args, node) => {
     const optNum = (index) => (args[index] === undefined ? undefined : num(index));
     const optStr = (index) => (args[index] === undefined ? undefined : str(index));
     const rejectRegex = () => {
-        if (args[0] instanceof Values.RegExp) {
+        if (args[0] instanceof CodeModeRegExp) {
             throw new InterpreterRuntimeError(`String.${name} cannot take a regular expression; use regex.test(string) or String.search instead.`, node).as("TypeError");
         }
     };
@@ -94,11 +145,9 @@ const invokeStringMethod = (value, name, args, node) => {
             result = value.trim();
             break;
         case "trimStart":
-        case "trimLeft":
             result = value.trimStart();
             break;
         case "trimEnd":
-        case "trimRight":
             result = value.trimEnd();
             break;
         // Locale/options are deliberately unsupported; comparison uses the host default locale.
@@ -123,7 +172,7 @@ const invokeStringMethod = (value, name, args, node) => {
                 result = requestedLimit !== undefined && requestedLimit >>> 0 === 0 ? [] : [value];
                 break;
             }
-            if (args[0] instanceof Values.RegExp) {
+            if (args[0] instanceof CodeModeRegExp) {
                 result = value.split(args[0].regex, optNum(1));
                 break;
             }
@@ -154,7 +203,7 @@ const invokeStringMethod = (value, name, args, node) => {
             break;
         case "replace":
         case "replaceAll": {
-            if (args[0] instanceof Values.RegExp) {
+            if (args[0] instanceof CodeModeRegExp) {
                 const pattern = args[0].regex;
                 const replacement = str(1);
                 if (name === "replaceAll" && !pattern.global) {
@@ -177,7 +226,7 @@ const invokeStringMethod = (value, name, args, node) => {
                 return null;
             // Preserve the own `index` and `groups` properties on non-global matches.
             if (pattern.global)
-                return toProgram(matched, "String.match result");
+                return boundedData(matched, "String.match result");
             return matchToValue(matched);
         }
         case "matchAll": {
@@ -185,7 +234,7 @@ const invokeStringMethod = (value, name, args, node) => {
             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(Array.from(value.matchAll(pattern), matchToValue));
+            return Array.from(value.matchAll(pattern), matchToValue);
         }
         case "search": {
             result = value.search(toHostRegex(args[0], name, node));
@@ -213,15 +262,6 @@ const invokeStringMethod = (value, name, args, node) => {
         case "substring":
             result = value.substring(optNum(0) ?? 0, optNum(1));
             break;
-        case "substr":
-            result = value.substr(optNum(0) ?? 0, optNum(1));
-            break;
-        case "isWellFormed":
-            result = value.isWellFormed();
-            break;
-        case "toWellFormed":
-            result = value.toWellFormed();
-            break;
         case "charCodeAt":
             result = value.charCodeAt(optNum(0) ?? 0);
             break;
@@ -238,7 +278,138 @@ const invokeStringMethod = (value, name, args, node) => {
         default:
             throw new InterpreterRuntimeError(`String method '${name}' is not available.`, node);
     }
-    return toProgram(result, `String.${name} result`);
+    return boundedData(result, `String.${name} result`);
+};
+export const arrayStatics = new Set(["isArray", "of", "from"]);
+const invokeArrayStatic = (name, args, node) => {
+    switch (name) {
+        case "isArray":
+            return Array.isArray(args[0]);
+        case "of":
+            return [...args];
+        default:
+            throw new InterpreterRuntimeError(`Array.${name} is not available.`, node);
+    }
+};
+const arrayLikeSource = (source, node) => {
+    if (source instanceof CodeModePromise) {
+        throw new InterpreterRuntimeError("Array.from received an un-awaited Promise; await it before creating the array.", node, "InvalidDataValue");
+    }
+    if (source !== null &&
+        typeof source === "object" &&
+        (Object.getPrototypeOf(source) === Object.prototype || Object.getPrototypeOf(source) === null) &&
+        typeof source.length === "number") {
+        const length = source.length;
+        const normalized = Number.isNaN(length) || length <= 0 ? 0 : Math.trunc(length);
+        if (normalized > 4_294_967_295)
+            throw new RangeError("Invalid array length");
+        return { length: normalized, source };
+    }
+    throw new InterpreterRuntimeError("Array.from expects an array, string, Map, Set, or array-like value.", node, "InvalidDataValue");
+};
+export const invokeArrayFrom = (runner, args, node) => {
+    const source = args[0];
+    const apply = args.length < 2 || args[1] === undefined ? undefined : applyCollectionCallback(runner, args[1], "Array.from", node);
+    return Effect.gen(function* () {
+        const cursor = yield* runner.syncIterator(source, node);
+        if (cursor === undefined) {
+            if (source instanceof CodeModeGenerator) {
+                throw new InterpreterRuntimeError("Array.from expects a synchronous iterable or array-like value.", node).as("TypeError");
+            }
+            const arrayLike = arrayLikeSource(source, node);
+            const values = [];
+            for (let index = 0; index < arrayLike.length; index += 1) {
+                const item = Reflect.get(arrayLike.source, index);
+                values.push(apply === undefined ? item : yield* apply([item, index]));
+            }
+            return values;
+        }
+        const values = [];
+        let index = 0;
+        while (true) {
+            const step = yield* cursor.next;
+            if (step.done)
+                return values;
+            values.push(apply === undefined ? step.value : yield* preserveConsumerError(cursor, apply([step.value, index])));
+            index += 1;
+        }
+    });
+};
+export const invokeGroupBy = (runner, namespace, args, node) => {
+    const source = args[0];
+    if (source === null || source === undefined) {
+        throw new InterpreterRuntimeError(`${namespace}.groupBy expects an iterable collection.`, node).as("TypeError");
+    }
+    const apply = applyCollectionCallback(runner, args[1], `${namespace}.groupBy`, node);
+    return Effect.gen(function* () {
+        const cursor = yield* runner.syncIterator(source, node);
+        if (cursor === undefined) {
+            throw new InterpreterRuntimeError(`${namespace}.groupBy expects an iterable collection.`, node).as("TypeError");
+        }
+        if (namespace === "Map") {
+            const result = new CodeModeMap();
+            let index = 0;
+            while (true) {
+                const step = yield* cursor.next;
+                if (step.done)
+                    return result;
+                const item = step.value;
+                const key = yield* preserveConsumerError(cursor, apply([item, index]));
+                const group = result.map.get(key);
+                if (group === undefined)
+                    result.map.set(key, [item]);
+                else
+                    group.push(item);
+                index += 1;
+            }
+        }
+        const result = Object.create(null);
+        let index = 0;
+        while (true) {
+            const step = yield* cursor.next;
+            if (step.done)
+                return result;
+            const item = step.value;
+            const key = yield* preserveConsumerError(cursor, Effect.flatMap(apply([item, index]), (value) => coerceGroupByPropertyKey(runner, value, node)));
+            if (isBlockedMember(key)) {
+                return yield* preserveConsumerError(cursor, Effect.fail(new InterpreterRuntimeError(`Property '${key}' is not available.`, node)));
+            }
+            const group = result[key];
+            if (group === undefined)
+                result[key] = [item];
+            else
+                group.push(item);
+            index += 1;
+        }
+    });
+};
+const coerceGroupByPropertyKey = (runner, value, node) => {
+    if (value === null || typeof value !== "object" || Array.isArray(value) || isCodeModeValue(value)) {
+        return Effect.succeed(coerceToString(value));
+    }
+    if (value instanceof CodeModePromise)
+        return Effect.succeed("[object Promise]");
+    if (isRuntimeReference(value)) {
+        throw new InterpreterRuntimeError("Object.groupBy callback must return a data value.", node, "InvalidDataValue");
+    }
+    const object = value;
+    if (!Object.hasOwn(object, "toString"))
+        return Effect.succeed(coerceToString(value));
+    return Effect.gen(function* () {
+        if (typeofValue(object.toString) === "function") {
+            const result = yield* runner.invokeCallable(object.toString, [], node);
+            if (result === null || (typeof result !== "object" && typeof result !== "function")) {
+                return coerceToString(result);
+            }
+        }
+        if (Object.hasOwn(object, "valueOf") && typeofValue(object.valueOf) === "function") {
+            const result = yield* runner.invokeCallable(object.valueOf, [], node);
+            if (result === null || (typeof result !== "object" && typeof result !== "function")) {
+                return coerceToString(result);
+            }
+        }
+        throw new InterpreterRuntimeError("Cannot convert object to primitive value.", node).as("TypeError");
+    });
 };
 const invokeStringReplacer = (runner, value, name, args, node) => {
     const apply = applyCollectionCallback(runner, args[1], `String.${name}`, node);
@@ -251,13 +422,19 @@ const invokeStringReplacer = (runner, value, name, args, node) => {
         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(groups);
+        if (hasGroups) {
+            const safeGroups = Object.create(null);
+            for (const [key, group] of Object.entries(groups)) {
+                if (!isBlockedMember(key))
+                    safeGroups[key] = group;
+            }
+            callbackArgs[callbackArgs.length - 1] = safeGroups;
+        }
         matches.push({ match, offset, args: callbackArgs });
         return match;
     };
     const pattern = args[0];
-    if (pattern instanceof Values.RegExp) {
+    if (pattern instanceof CodeModeRegExp) {
         if (name === "replaceAll" && !pattern.regex.global) {
             throw new InterpreterRuntimeError(`String.replaceAll requires a regular expression with the global (g) flag: write /${pattern.regex.source}/${pattern.regex.flags}g, or use String.replace to replace only the first match.`, node);
         }
@@ -278,15 +455,27 @@ const invokeStringReplacer = (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 Values.Promise
+            // Error values are branded plain objects; boundedData would strip the brand before coercion.
+            output.push(value.slice(end, match.offset), replacement instanceof CodeModePromise
                 ? "[object Promise]"
-                : coerceToString(toProgram(replacement, `String.${name} replacer result`)));
+                : errorBrandName(replacement)
+                    ? coerceToString(replacement)
+                    : coerceToString(boundedData(replacement, `String.${name} replacer result`)));
             end = match.offset + match.match.length;
         }
         output.push(value.slice(end));
-        return toProgram(output.join(""), `String.${name} result`);
+        return boundedData(output.join(""), `String.${name} result`);
     });
 };
+export const applyCollectionCallback = (runner, callback, name, node) => {
+    if (!isSupportedCallback(callback)) {
+        if (typeofValue(callback) === "function") {
+            throw new InterpreterRuntimeError(`${name} cannot use this callable as a callback; wrap it in an arrow function, e.g. (value) => tools.ns.tool(value).`, node);
+        }
+        throw new InterpreterRuntimeError(`${name} expects a function callback.`, node).as("TypeError");
+    }
+    return (callbackArgs) => runner.invokeCallable(callback, callbackArgs, node);
+};
 const invokeMapMethod = (runner, target, name, args, node) => {
     switch (name) {
         case "get":
@@ -310,7 +499,7 @@ const invokeMapMethod = (runner, target, name, args, node) => {
         case "values":
             return Effect.sync(() => Array.from(target.map.values()));
         case "entries":
-            return Effect.sync(() => Array.from(target.map.entries(), ([key, item]) => new ProgramArray([key, item])));
+            return Effect.sync(() => Array.from(target.map.entries(), ([key, item]) => [key, item]));
         case "forEach": {
             const apply = applyCollectionCallback(runner, args[0], "Map.forEach", node);
             return Effect.gen(function* () {
@@ -343,7 +532,7 @@ const invokeSetMethod = (runner, target, name, args, node) => {
         case "values":
             return Effect.sync(() => Array.from(target.set.values()));
         case "entries":
-            return Effect.sync(() => Array.from(target.set.values(), (item) => new ProgramArray([item, item])));
+            return Effect.sync(() => Array.from(target.set.values(), (item) => [item, item]));
         case "forEach": {
             const apply = applyCollectionCallback(runner, args[0], "Set.forEach", node);
             return Effect.gen(function* () {
@@ -373,7 +562,7 @@ const invokeSetOperation = (runner, target, name, source, node) => Effect.gen(fu
         return result;
     }
     if (name === "intersection") {
-        const result = new Values.Set();
+        const result = new CodeModeSet();
         if (target.set.size <= other.size) {
             for (const item of target.set.values()) {
                 if (yield* other.has(item))
@@ -442,45 +631,46 @@ const invokeSetOperation = (runner, target, name, source, node) => Effect.gen(fu
     return true;
 });
 const copySet = (source) => {
-    const result = new Values.Set();
+    const result = new CodeModeSet();
     for (const item of source.set.values())
         result.set.add(item);
     return result;
 };
 const loadSetRecord = (runner, source, name, node) => {
-    if (source instanceof Values.Set) {
+    if (source instanceof CodeModeSet) {
         return Effect.succeed({
             size: source.set.size,
             has: (item) => Effect.succeed(source.set.has(item)),
             keys: () => Effect.succeed(source.set.values()),
         });
     }
-    if (source instanceof Values.Map) {
+    if (source instanceof CodeModeMap) {
         return Effect.succeed({
             size: source.map.size,
             has: (item) => Effect.succeed(source.map.has(item)),
             keys: () => Effect.succeed(source.map.keys()),
         });
     }
-    if (!(source instanceof ProgramObject)) {
+    if (source === null || typeof source !== "object" || isCodeModeValue(source)) {
         throw new InterpreterRuntimeError(`Set.${name} expects a Set-like object.`, node).as("TypeError");
     }
+    const object = source;
     return Effect.gen(function* () {
-        const size = yield* coerceNumericArgument(runner, get(source, "size"), node);
+        const size = yield* coerceNumericArgument(runner, object.size, node);
         if (Number.isNaN(size)) {
             throw new InterpreterRuntimeError(`Set.${name} received a Set-like object with an invalid size.`, node).as("TypeError");
         }
-        const has = get(source, "has");
-        const keys = get(source, "keys");
-        if (!isSupportedCallback(has) || !isSupportedCallback(keys)) {
+        if (!isSupportedCallback(object.has) || !isSupportedCallback(object.keys)) {
             throw new InterpreterRuntimeError(`Set.${name} expects callable 'has' and 'keys' methods.`, node).as("TypeError");
         }
+        const has = object.has;
+        const keys = object.keys;
         return {
             size: Math.max(Math.trunc(size), 0),
             has: (item) => Effect.map(runner.invokeCallable(has, [item], node), Boolean),
             keys: () => Effect.flatMap(runner.invokeCallable(keys, [], node), (result) => {
-                if (result instanceof ProgramArray)
-                    return Effect.succeed(result.items);
+                if (Array.isArray(result))
+                    return Effect.succeed(result);
                 throw new InterpreterRuntimeError(`Set.${name} expected 'keys' to return an iterator.`, node).as("TypeError");
             }),
         };
@@ -537,7 +727,7 @@ const invokeURLSearchParamsMethod = (runner, target, name, args, node) => {
         case "values":
             return Effect.sync(() => Array.from(target.params.values()));
         case "entries":
-            return Effect.sync(() => Array.from(target.params.entries(), ([key, value]) => new ProgramArray([key, value])));
+            return Effect.sync(() => Array.from(target.params.entries(), ([key, value]) => [key, value]));
         case "toString":
             return Effect.sync(() => target.params.toString());
         case "forEach": {
@@ -553,8 +743,7 @@ const invokeURLSearchParamsMethod = (runner, target, name, args, node) => {
             throw new InterpreterRuntimeError(`URLSearchParams method '${name}' is not available.`, node);
     }
 };
-const invokeArrayMethod = (runner, receiver, name, args, node) => {
-    const target = receiver.items;
+const invokeArrayMethod = (runner, target, name, args, node) => {
     const optNumber = (value, label) => {
         if (value === undefined)
             return undefined;
@@ -567,7 +756,8 @@ const invokeArrayMethod = (runner, receiver, name, args, node) => {
             if (args.length > 1 || (args.length === 1 && typeof args[0] !== "string")) {
                 throw new InterpreterRuntimeError("Array.join expects zero arguments or one string separator.", node);
             }
-            return Effect.succeed(target.map((item) => coerceToString(item ?? "")).join(args.length === 0 ? "," : args[0]));
+            const input = boundedData(target, "Array.join input");
+            return Effect.succeed(input.map((item) => coerceToString(item ?? "")).join(args.length === 0 ? "," : args[0]));
         }
         case "includes":
             if (args.length === 0 || args.length > 2)
@@ -584,14 +774,11 @@ const invokeArrayMethod = (runner, receiver, name, args, node) => {
         case "slice":
             return Effect.succeed(target.slice(optNumber(args[0], "start"), optNumber(args[1], "end")));
         case "concat":
-            return Effect.succeed(target.concat(...args.map((item) => (item instanceof ProgramArray ? item.items : item))));
-        case "flat": {
-            const flatten = (items, depth) => items.flatMap((item) => (item instanceof ProgramArray && depth > 0 ? flatten(item.items, depth - 1) : [item]));
-            return Effect.succeed(flatten(target, optNumber(args[0], "depth") ?? 1));
-        }
+            return Effect.succeed(target.concat(...args));
+        case "flat":
+            return Effect.succeed(target.flat(optNumber(args[0], "depth") ?? 1));
         case "reverse":
-            target.reverse();
-            return Effect.succeed(receiver);
+            return Effect.succeed(target.reverse());
         case "sort": {
             const length = target.length;
             const holeCount = Array.from({ length }, (_, index) => Object.hasOwn(target, index)).filter((own) => !own).length;
@@ -603,7 +790,7 @@ const invokeArrayMethod = (runner, receiver, name, args, node) => {
                 Array.from({ length: holeCount }, (_, index) => itemCount + index).forEach((index) => {
                     Reflect.deleteProperty(target, index);
                 });
-                return receiver;
+                return target;
             });
         }
         case "toSorted":
@@ -623,13 +810,13 @@ const invokeArrayMethod = (runner, receiver, name, args, node) => {
         case "push": {
             // Validate all insertions before mutating to avoid partial cyclic updates.
             for (const item of args)
-                rejectCircularInsertion(receiver, item, "Array.push result", node);
+                rejectCircularInsertion(target, item, "Array.push result", node);
             target.push(...args);
             return Effect.succeed(target.length);
         }
         case "unshift": {
             for (const item of args)
-                rejectCircularInsertion(receiver, item, "Array.unshift result", node);
+                rejectCircularInsertion(target, item, "Array.unshift result", node);
             target.unshift(...args);
             return Effect.succeed(target.length);
         }
@@ -646,7 +833,7 @@ const invokeArrayMethod = (runner, receiver, name, args, node) => {
             const deleteCount = optNumber(args[1], "delete count") ?? 0;
             const inserted = args.slice(2);
             for (const item of inserted)
-                rejectCircularInsertion(receiver, item, "Array.splice result", node);
+                rejectCircularInsertion(target, item, "Array.splice result", node);
             return Effect.succeed(target.splice(start, deleteCount, ...inserted));
         }
         case "toSpliced": {
@@ -664,19 +851,17 @@ const invokeArrayMethod = (runner, receiver, name, args, node) => {
             return Effect.succeed(copied);
         }
         case "fill": {
-            rejectCircularInsertion(receiver, args[0], "Array.fill result", node);
-            target.fill(args[0], optNumber(args[1], "start"), optNumber(args[2], "end"));
-            return Effect.succeed(receiver);
+            rejectCircularInsertion(target, args[0], "Array.fill result", node);
+            return Effect.succeed(target.fill(args[0], optNumber(args[1], "start"), optNumber(args[2], "end")));
         }
         case "copyWithin":
-            target.copyWithin(optNumber(args[0], "target index") ?? 0, optNumber(args[1], "start") ?? 0, optNumber(args[2], "end"));
-            return Effect.succeed(receiver);
+            return Effect.succeed(target.copyWithin(optNumber(args[0], "target index") ?? 0, optNumber(args[1], "start") ?? 0, optNumber(args[2], "end")));
         case "keys":
             return Effect.succeed(Array.from(target.keys()));
         case "values":
             return Effect.succeed([...target]);
         case "entries":
-            return Effect.succeed(Array.from(target.entries(), ([index, item]) => new ProgramArray([index, item])));
+            return Effect.succeed(Array.from(target.entries(), ([index, item]) => [index, item]));
     }
     const apply = applyCollectionCallback(runner, args[0], `Array.${name}`, node);
     return Effect.gen(function* () {
@@ -689,7 +874,7 @@ const invokeArrayMethod = (runner, receiver, name, args, node) => {
                 for (let index = 0; index < length; index += 1) {
                     if (!(index in target))
                         continue;
-                    values[index] = yield* apply([target[index], index, receiver]);
+                    values[index] = yield* apply([target[index], index, target]);
                 }
                 return values;
             }
@@ -698,9 +883,9 @@ const invokeArrayMethod = (runner, receiver, name, args, node) => {
                 for (let index = 0; index < length; index += 1) {
                     if (!(index in target))
                         continue;
-                    const mapped = yield* apply([target[index], index, receiver]);
-                    if (mapped instanceof ProgramArray)
-                        values.push(...mapped.items);
+                    const mapped = yield* apply([target[index], index, target]);
+                    if (Array.isArray(mapped))
+                        values.push(...mapped);
                     else
                         values.push(mapped);
                 }
@@ -712,7 +897,7 @@ const invokeArrayMethod = (runner, receiver, name, args, node) => {
                     if (!(index in target))
                         continue;
                     const item = target[index];
-                    if (yield* apply([item, index, receiver]))
+                    if (yield* apply([item, index, target]))
                         values.push(item);
                 }
                 return values;
@@ -720,13 +905,13 @@ const invokeArrayMethod = (runner, receiver, name, args, node) => {
             case "find":
                 for (let index = 0; index < length; index += 1) {
                     const item = target[index];
-                    if (yield* apply([item, index, receiver]))
+                    if (yield* apply([item, index, target]))
                         return item;
                 }
                 return undefined;
             case "findIndex":
                 for (let index = 0; index < length; index += 1) {
-                    if (yield* apply([target[index], index, receiver]))
+                    if (yield* apply([target[index], index, target]))
                         return index;
                 }
                 return -1;
@@ -734,7 +919,7 @@ const invokeArrayMethod = (runner, receiver, name, args, node) => {
                 for (let index = 0; index < length; index += 1) {
                     if (!(index in target))
                         continue;
-                    if (yield* apply([target[index], index, receiver]))
+                    if (yield* apply([target[index], index, target]))
                         return true;
                 }
                 return false;
@@ -742,14 +927,14 @@ const invokeArrayMethod = (runner, receiver, name, args, node) => {
                 for (let index = 0; index < length; index += 1) {
                     if (!(index in target))
                         continue;
-                    if (!(yield* apply([target[index], index, receiver])))
+                    if (!(yield* apply([target[index], index, target])))
                         return false;
                 }
                 return true;
             case "forEach":
                 for (let index = 0; index < length; index += 1) {
                     if (index in target)
-                        yield* apply([target[index], index, receiver]);
+                        yield* apply([target[index], index, target]);
                 }
                 return undefined;
             case "reduce": {
@@ -766,7 +951,7 @@ const invokeArrayMethod = (runner, receiver, name, args, node) => {
                 for (let index = start; index < length; index += 1) {
                     if (!(index in target))
                         continue;
-                    accumulator = yield* apply([accumulator, target[index], index, receiver]);
+                    accumulator = yield* apply([accumulator, target[index], index, target]);
                 }
                 return accumulator;
             }
@@ -784,20 +969,20 @@ const invokeArrayMethod = (runner, receiver, name, args, node) => {
                 for (let index = start; index >= 0; index -= 1) {
                     if (!(index in target))
                         continue;
-                    accumulator = yield* apply([accumulator, target[index], index, receiver]);
+                    accumulator = yield* apply([accumulator, target[index], index, target]);
                 }
                 return accumulator;
             }
             case "findLast":
                 for (let index = length - 1; index >= 0; index -= 1) {
                     const item = target[index];
-                    if (yield* apply([item, index, receiver]))
+                    if (yield* apply([item, index, target]))
                         return item;
                 }
                 return undefined;
             case "findLastIndex":
                 for (let index = length - 1; index >= 0; index -= 1) {
-                    if (yield* apply([target[index], index, receiver]))
+                    if (yield* apply([target[index], index, target]))
                         return index;
                 }
                 return -1;
@@ -807,7 +992,11 @@ const invokeArrayMethod = (runner, receiver, name, args, node) => {
 };
 const sortArray = (runner, target, comparator, name, node) => {
     if (comparator === undefined) {
-        return Effect.sync(() => [...target].sort((a, b) => compareText(coerceToString(a), coerceToString(b))));
+        return Effect.sync(() => [...target].sort((a, b) => {
+            const left = coerceToString(a);
+            const right = coerceToString(b);
+            return left < right ? -1 : left > right ? 1 : 0;
+        }));
     }
     const apply = applyCollectionCallback(runner, comparator, name, node);
     const mergeSort = (items) => {