@opencode/codemode 0.0.0-beta-19422 → 0.0.0-beta-19500

package/dist/codemode.d.ts

@@ -136,7 +136,7 @@ export declare const Result: Schema.Union<readonly [Schema.Struct<{
 export type Result = typeof Result.Type;
 /** Reusable confined runtime over explicit tools. */
 export type Runtime<R = never> = {
-    readonly catalog: () => ReadonlyArray<ToolDescription>;
+    readonly catalog: ReadonlyArray<ToolDescription>;
     readonly execute: (code: string) => Effect.Effect<Result, never, R>;
 };
 /** Executes one Effect-native CodeMode program without constructing a reusable runtime. */

package/dist/codemode.js

@@ -60,7 +60,7 @@ export const make = (options = {}) => {
     const prepared = ToolRuntime.prepare((options.tools ?? {}));
     const limits = resolveExecutionLimits(options.limits);
     return {
-        catalog: () => prepared.catalog,
+        catalog: prepared.catalog,
         execute: (code) => executeProgram(code, prepared, limits, options),
     };
 };

package/dist/data.d.ts

@@ -1,21 +1,19 @@
 export * as Data from "./data.js";
 import type { DiagnosticKind } from "./codemode.js";
-/** A null-prototype object owned by the program. */
-export type SafeObject = Record<string, unknown>;
 export declare class ToolRuntimeError extends Error {
     readonly kind: Extract<DiagnosticKind, "UnknownTool" | "InvalidToolInput" | "InvalidToolOutput" | "InvalidDataValue" | "ToolCallLimitExceeded">;
     readonly suggestions: ReadonlyArray<string>;
     constructor(kind: Extract<DiagnosticKind, "UnknownTool" | "InvalidToolInput" | "InvalidToolOutput" | "InvalidDataValue" | "ToolCallLimitExceeded">, message: string, suggestions?: ReadonlyArray<string>);
 }
 /**
- * Brings a host-produced runtime value into the program: runtime values pass through, their host
- * counterparts (Date, RegExp, Map, Set, URL, URLSearchParams) are wrapped, and objects become
- * null-prototype copies. Arrays keep extra enumerable properties such as `index` and `groups`.
+ * Brings a host-produced value into the program: program and runtime values pass through, their
+ * host counterparts (Date, RegExp, Map, Set, URL, URLSearchParams) are wrapped, and host objects
+ * and arrays are copied.
  */
 export declare const toProgram: (value: unknown, label: string) => unknown;
 /**
  * Brings host data into the program: Date and URL become strings, other host collections become
- * empty objects, and objects become null-prototype copies. Used for tool results and parsed JSON.
+ * empty objects, and objects become program copies. Used for tool results and parsed JSON.
  */
 export declare const fromData: (value: unknown, label: string) => unknown;
 /**

package/dist/data.js

@@ -1,4 +1,5 @@
 export * as Data from "./data.js";
+import { ownEntries, parseArrayIndex, ProgramArray, ProgramFunction, ProgramObject, set, } from "./interpreter/objects.js";
 import { Values } from "./values.js";
 const MAX_VALUE_DEPTH = 32;
 export class ToolRuntimeError extends Error {
@@ -12,14 +13,14 @@ export class ToolRuntimeError extends Error {
     }
 }
 /**
- * Brings a host-produced runtime value into the program: runtime values pass through, their host
- * counterparts (Date, RegExp, Map, Set, URL, URLSearchParams) are wrapped, and objects become
- * null-prototype copies. Arrays keep extra enumerable properties such as `index` and `groups`.
+ * Brings a host-produced value into the program: program and runtime values pass through, their
+ * host counterparts (Date, RegExp, Map, Set, URL, URLSearchParams) are wrapped, and host objects
+ * and arrays are copied.
  */
 export const toProgram = (value, label) => copy(value, label, "program", 0, new Set());
 /**
  * Brings host data into the program: Date and URL become strings, other host collections become
- * empty objects, and objects become null-prototype copies. Used for tool results and parsed JSON.
+ * empty objects, and objects become program copies. Used for tool results and parsed JSON.
  */
 export const fromData = (value, label) => copy(value, label, "data", 0, new Set());
 /**
@@ -45,8 +46,12 @@ const copy = (value, label, mode, depth, seen) => {
     if (value instanceof Values.Promise) {
         throw new ToolRuntimeError("InvalidDataValue", `${label} contains an un-awaited Promise; await tool calls (e.g. \`const result = await tools.ns.tool(...)\`) before using their results.`);
     }
+    if (value instanceof ProgramFunction && mode !== "program") {
+        throw new ToolRuntimeError("InvalidDataValue", `${label} must contain data only.`);
+    }
+    const plain = mode === "program" || mode === "data";
     if (mode === "program") {
-        if (Values.isValue(value))
+        if (value instanceof ProgramObject || Values.isValue(value))
             return value;
         if (value instanceof Date)
             return new Values.Date(value.getTime());
@@ -70,7 +75,6 @@ const copy = (value, label, mode, depth, seen) => {
         if (value instanceof URLSearchParams)
             return new Values.URLSearchParams(new URLSearchParams(value));
     }
-    const plain = mode === "program" || mode === "data";
     if (value instanceof Values.Date)
         return Number.isFinite(value.time) ? new Date(value.time).toISOString() : null;
     if (value instanceof Date)
@@ -85,24 +89,39 @@ const copy = (value, label, mode, depth, seen) => {
         value instanceof Map ||
         value instanceof Set ||
         value instanceof URLSearchParams) {
-        return plain ? Object.create(null) : {};
+        return plain ? new ProgramObject() : {};
     }
     if (seen.has(value)) {
         throw new ToolRuntimeError("InvalidDataValue", `${label} contains a circular value.`);
     }
     seen.add(value);
+    if (value instanceof ProgramArray) {
+        const copied = Array.from(value.items, (item) => copy(item, label, mode, depth + 1, seen) ?? null);
+        seen.delete(value);
+        return copied;
+    }
+    if (value instanceof ProgramObject) {
+        const copied = {};
+        for (const [key, item] of ownEntries(value)) {
+            const next = copy(item, label, mode, depth + 1, seen);
+            if (next === undefined && mode === "json")
+                continue;
+            define(copied, key, next);
+        }
+        seen.delete(value);
+        return copied;
+    }
     if (Array.isArray(value)) {
-        // Host output densifies holes to null like JSON; program copies keep them.
-        const copied = plain
-            ? value.map((item) => copy(item, label, mode, depth + 1, seen))
-            : Array.from(value, (item) => copy(item, label, mode, depth + 1, seen) ?? null);
-        if (mode === "program") {
+        if (plain) {
+            const copied = new ProgramArray(value.map((item) => copy(item, label, mode, depth + 1, seen)));
             for (const [key, item] of Object.entries(value)) {
-                if (Object.hasOwn(copied, key))
-                    continue;
-                define(copied, key, copy(item, label, mode, depth + 1, seen));
+                if (parseArrayIndex(key) === undefined)
+                    set(copied, key, copy(item, label, mode, depth + 1, seen));
             }
+            seen.delete(value);
+            return copied;
         }
+        const copied = Array.from(value, (item) => copy(item, label, mode, depth + 1, seen) ?? null);
         seen.delete(value);
         return copied;
     }
@@ -110,7 +129,14 @@ const copy = (value, label, mode, depth, seen) => {
     if (prototype !== Object.prototype && prototype !== null) {
         throw new ToolRuntimeError("InvalidDataValue", `${label} must contain plain objects only.`);
     }
-    const copied = plain ? Object.create(null) : {};
+    if (plain) {
+        const copied = new ProgramObject();
+        for (const [key, item] of Object.entries(value))
+            set(copied, key, copy(item, label, mode, depth + 1, seen));
+        seen.delete(value);
+        return copied;
+    }
+    const copied = {};
     for (const [key, item] of Object.entries(value)) {
         const next = copy(item, label, mode, depth + 1, seen);
         if (next === undefined && mode === "json")
@@ -120,8 +146,8 @@ const copy = (value, label, mode, depth, seen) => {
     seen.delete(value);
     return copied;
 };
-// Own data property regardless of the target's prototype, so a "__proto__" key on a host object or
-// array never reaches the Object.prototype setter.
+// Own data property regardless of the target's prototype, so a "__proto__" key on a host object
+// never reaches the Object.prototype setter.
 const define = (target, key, value) => {
     Object.defineProperty(target, key, { value, enumerable: true, writable: true, configurable: true });
 };

package/dist/interpreter/errors.js

@@ -4,6 +4,7 @@ import { toData, ToolRuntimeError } from "../data.js";
 import { formatLocation, InterpreterRuntimeError, ProgramThrow, sourceLocation } from "./model.js";
 import { containsRuntimeReference } from "./references.js";
 import { HostFunction } from "./host.js";
+import { get, ProgramError, ProgramObject } from "./objects.js";
 import {} from "./runner.js";
 import { coerceToString, createAggregateErrorValue, createErrorValue, errorBrandName, errorConstructors, } from "../stdlib/value.js";
 export const normalizeError = (error) => {
@@ -35,10 +36,8 @@ export const normalizeError = (error) => {
         else if (typeof value === "string") {
             message = value;
         }
-        else if (value !== null &&
-            typeof value === "object" &&
-            typeof value.message === "string") {
-            message = value.message;
+        else if (value instanceof ProgramObject && typeof get(value, "message") === "string") {
+            message = get(value, "message");
         }
         else {
             try {

package/dist/interpreter/execute.d.ts

@@ -1,4 +1,5 @@
 import { Effect } from "effect";
 import type { ResolvedExecutionLimits, Result } from "../codemode.js";
 import { ToolRuntime } from "../tool-runtime.js";
-export declare const executeProgram: <R>(code: string, prepared: ToolRuntime.Prepared<R>, limits: ResolvedExecutionLimits, hooks: ToolRuntime.ToolCallHooks<R>) => Effect.Effect<Result, never, R>;
+import type { Host } from "./globals.js";
+export declare const executeProgram: <R>(code: string, prepared: ToolRuntime.Prepared<R>, limits: ResolvedExecutionLimits, hooks: ToolRuntime.ToolCallHooks<R>, extraGlobals?: (host: Host<R>) => ReadonlyArray<readonly [string, unknown]>) => Effect.Effect<Result, never, R>;

package/dist/interpreter/execute.js

@@ -9,7 +9,7 @@ import { normalizeError } from "./errors.js";
 import { InterpreterRuntimeError } from "./model.js";
 import { PromiseRuntime } from "./promises.js";
 import { Runtime } from "./runtime.js";
-export const executeProgram = (code, prepared, limits, hooks) => {
+export const executeProgram = (code, prepared, limits, hooks, extraGlobals) => {
     if (code.trim().length === 0) {
         return Effect.succeed({
             ok: false,
@@ -27,7 +27,7 @@ export const executeProgram = (code, prepared, limits, hooks) => {
         const base = Effect.acquireUseRelease(Scope.make("parallel"), (scope) => Effect.gen(function* () {
             const program = parseProgram(code);
             const promises = new PromiseRuntime(scope);
-            const value = yield* new Runtime(tools.execute, tools.search, tools.keys, promises, logs).run(program);
+            const value = yield* new Runtime(tools.execute, tools.search, tools.keys, promises, logs, extraGlobals).run(program);
             const result = toData(value, "Execution result", "result");
             returned = { value: result, promises };
             const warnings = yield* promises.interrupt();

package/dist/interpreter/globals.js

@@ -11,6 +11,7 @@ import { regexpGlobal } from "../stdlib/regexp.js";
 import { stringGlobal } from "../stdlib/string.js";
 import { uriGlobal, urlGlobal, urlSearchParamsGlobal } from "../stdlib/url.js";
 import { coercion, errorConstructors } from "../stdlib/value.js";
+import { atobGlobal, btoaGlobal, cryptoGlobal } from "../stdlib/web.js";
 import { ToolReference } from "../tool-runtime.js";
 import { errorGlobal } from "./errors.js";
 import { HostFunction } from "./host.js";
@@ -55,5 +56,8 @@ export const globals = (host) => [
     ["encodeURIComponent", uriGlobal("encodeURIComponent")],
     ["decodeURI", uriGlobal("decodeURI")],
     ["decodeURIComponent", uriGlobal("decodeURIComponent")],
+    ["atob", atobGlobal],
+    ["btoa", btoaGlobal],
+    ["crypto", cryptoGlobal],
     ...[...errorConstructors].map((name) => [name, errorGlobal(name, host.runner)]),
 ];

package/dist/interpreter/methods.js

@@ -4,13 +4,15 @@ 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, errorBrandName } from "../stdlib/value.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) => {
+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) => {
     if (typeof ref.receiver === "string") {
         if (ref.name === "replace" || ref.name === "replaceAll") {
             if (isSupportedCallback(args[1]))
@@ -24,7 +26,7 @@ export const invokeIntrinsic = (runner, ref, args, node) => {
     if (typeof ref.receiver === "number") {
         return Effect.succeed(invokeNumberMethod(ref.receiver, ref.name, args, node));
     }
-    if (Array.isArray(ref.receiver)) {
+    if (ref.receiver instanceof ProgramArray) {
         return invokeArrayMethod(runner, ref.receiver, ref.name, args, node);
     }
     if (ref.receiver instanceof Values.Date) {
@@ -92,9 +94,11 @@ 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.
@@ -181,7 +185,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 Array.from(value.matchAll(pattern), matchToValue);
+            return new ProgramArray(Array.from(value.matchAll(pattern), matchToValue));
         }
         case "search": {
             result = value.search(toHostRegex(args[0], name, node));
@@ -209,6 +213,15 @@ 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,13 +251,8 @@ 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) {
-            const safeGroups = Object.create(null);
-            for (const [key, group] of Object.entries(groups)) {
-                safeGroups[key] = group;
-            }
-            callbackArgs[callbackArgs.length - 1] = safeGroups;
-        }
+        if (hasGroups)
+            callbackArgs[callbackArgs.length - 1] = record(groups);
         matches.push({ match, offset, args: callbackArgs });
         return match;
     };
@@ -270,12 +278,9 @@ const invokeStringReplacer = (runner, value, name, args, node) => {
         let end = 0;
         for (const match of matches) {
             const replacement = yield* apply(match.args);
-            // Error values are branded plain objects; toProgram would strip the brand before coercion.
             output.push(value.slice(end, match.offset), replacement instanceof Values.Promise
                 ? "[object Promise]"
-                : errorBrandName(replacement)
-                    ? coerceToString(replacement)
-                    : coerceToString(toProgram(replacement, `String.${name} replacer result`)));
+                : coerceToString(toProgram(replacement, `String.${name} replacer result`)));
             end = match.offset + match.match.length;
         }
         output.push(value.slice(end));
@@ -305,7 +310,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]) => [key, item]));
+            return Effect.sync(() => Array.from(target.map.entries(), ([key, item]) => new ProgramArray([key, item])));
         case "forEach": {
             const apply = applyCollectionCallback(runner, args[0], "Map.forEach", node);
             return Effect.gen(function* () {
@@ -338,7 +343,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) => [item, item]));
+            return Effect.sync(() => Array.from(target.set.values(), (item) => new ProgramArray([item, item])));
         case "forEach": {
             const apply = applyCollectionCallback(runner, args[0], "Set.forEach", node);
             return Effect.gen(function* () {
@@ -457,26 +462,25 @@ const loadSetRecord = (runner, source, name, node) => {
             keys: () => Effect.succeed(source.map.keys()),
         });
     }
-    if (source === null || typeof source !== "object" || Values.isValue(source)) {
+    if (!(source instanceof ProgramObject)) {
         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, object.size, node);
+        const size = yield* coerceNumericArgument(runner, get(source, "size"), node);
         if (Number.isNaN(size)) {
             throw new InterpreterRuntimeError(`Set.${name} received a Set-like object with an invalid size.`, node).as("TypeError");
         }
-        if (!isSupportedCallback(object.has) || !isSupportedCallback(object.keys)) {
+        const has = get(source, "has");
+        const keys = get(source, "keys");
+        if (!isSupportedCallback(has) || !isSupportedCallback(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 (Array.isArray(result))
-                    return Effect.succeed(result);
+                if (result instanceof ProgramArray)
+                    return Effect.succeed(result.items);
                 throw new InterpreterRuntimeError(`Set.${name} expected 'keys' to return an iterator.`, node).as("TypeError");
             }),
         };
@@ -533,7 +537,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]) => [key, value]));
+            return Effect.sync(() => Array.from(target.params.entries(), ([key, value]) => new ProgramArray([key, value])));
         case "toString":
             return Effect.sync(() => target.params.toString());
         case "forEach": {
@@ -549,7 +553,8 @@ const invokeURLSearchParamsMethod = (runner, target, name, args, node) => {
             throw new InterpreterRuntimeError(`URLSearchParams method '${name}' is not available.`, node);
     }
 };
-const invokeArrayMethod = (runner, target, name, args, node) => {
+const invokeArrayMethod = (runner, receiver, name, args, node) => {
+    const target = receiver.items;
     const optNumber = (value, label) => {
         if (value === undefined)
             return undefined;
@@ -562,8 +567,7 @@ const invokeArrayMethod = (runner, target, 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);
             }
-            const input = toProgram(target, "Array.join input");
-            return Effect.succeed(input.map((item) => coerceToString(item ?? "")).join(args.length === 0 ? "," : args[0]));
+            return Effect.succeed(target.map((item) => coerceToString(item ?? "")).join(args.length === 0 ? "," : args[0]));
         }
         case "includes":
             if (args.length === 0 || args.length > 2)
@@ -580,11 +584,14 @@ const invokeArrayMethod = (runner, target, 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));
-        case "flat":
-            return Effect.succeed(target.flat(optNumber(args[0], "depth") ?? 1));
+            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));
+        }
         case "reverse":
-            return Effect.succeed(target.reverse());
+            target.reverse();
+            return Effect.succeed(receiver);
         case "sort": {
             const length = target.length;
             const holeCount = Array.from({ length }, (_, index) => Object.hasOwn(target, index)).filter((own) => !own).length;
@@ -596,7 +603,7 @@ const invokeArrayMethod = (runner, target, name, args, node) => {
                 Array.from({ length: holeCount }, (_, index) => itemCount + index).forEach((index) => {
                     Reflect.deleteProperty(target, index);
                 });
-                return target;
+                return receiver;
             });
         }
         case "toSorted":
@@ -616,13 +623,13 @@ const invokeArrayMethod = (runner, target, name, args, node) => {
         case "push": {
             // Validate all insertions before mutating to avoid partial cyclic updates.
             for (const item of args)
-                rejectCircularInsertion(target, item, "Array.push result", node);
+                rejectCircularInsertion(receiver, item, "Array.push result", node);
             target.push(...args);
             return Effect.succeed(target.length);
         }
         case "unshift": {
             for (const item of args)
-                rejectCircularInsertion(target, item, "Array.unshift result", node);
+                rejectCircularInsertion(receiver, item, "Array.unshift result", node);
             target.unshift(...args);
             return Effect.succeed(target.length);
         }
@@ -639,7 +646,7 @@ const invokeArrayMethod = (runner, target, name, args, node) => {
             const deleteCount = optNumber(args[1], "delete count") ?? 0;
             const inserted = args.slice(2);
             for (const item of inserted)
-                rejectCircularInsertion(target, item, "Array.splice result", node);
+                rejectCircularInsertion(receiver, item, "Array.splice result", node);
             return Effect.succeed(target.splice(start, deleteCount, ...inserted));
         }
         case "toSpliced": {
@@ -657,17 +664,19 @@ const invokeArrayMethod = (runner, target, name, args, node) => {
             return Effect.succeed(copied);
         }
         case "fill": {
-            rejectCircularInsertion(target, args[0], "Array.fill result", node);
-            return Effect.succeed(target.fill(args[0], optNumber(args[1], "start"), optNumber(args[2], "end")));
+            rejectCircularInsertion(receiver, args[0], "Array.fill result", node);
+            target.fill(args[0], optNumber(args[1], "start"), optNumber(args[2], "end"));
+            return Effect.succeed(receiver);
         }
         case "copyWithin":
-            return Effect.succeed(target.copyWithin(optNumber(args[0], "target index") ?? 0, optNumber(args[1], "start") ?? 0, optNumber(args[2], "end")));
+            target.copyWithin(optNumber(args[0], "target index") ?? 0, optNumber(args[1], "start") ?? 0, optNumber(args[2], "end"));
+            return Effect.succeed(receiver);
         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]) => [index, item]));
+            return Effect.succeed(Array.from(target.entries(), ([index, item]) => new ProgramArray([index, item])));
     }
     const apply = applyCollectionCallback(runner, args[0], `Array.${name}`, node);
     return Effect.gen(function* () {
@@ -680,7 +689,7 @@ const invokeArrayMethod = (runner, target, name, args, node) => {
                 for (let index = 0; index < length; index += 1) {
                     if (!(index in target))
                         continue;
-                    values[index] = yield* apply([target[index], index, target]);
+                    values[index] = yield* apply([target[index], index, receiver]);
                 }
                 return values;
             }
@@ -689,9 +698,9 @@ const invokeArrayMethod = (runner, target, name, args, node) => {
                 for (let index = 0; index < length; index += 1) {
                     if (!(index in target))
                         continue;
-                    const mapped = yield* apply([target[index], index, target]);
-                    if (Array.isArray(mapped))
-                        values.push(...mapped);
+                    const mapped = yield* apply([target[index], index, receiver]);
+                    if (mapped instanceof ProgramArray)
+                        values.push(...mapped.items);
                     else
                         values.push(mapped);
                 }
@@ -703,7 +712,7 @@ const invokeArrayMethod = (runner, target, name, args, node) => {
                     if (!(index in target))
                         continue;
                     const item = target[index];
-                    if (yield* apply([item, index, target]))
+                    if (yield* apply([item, index, receiver]))
                         values.push(item);
                 }
                 return values;
@@ -711,13 +720,13 @@ const invokeArrayMethod = (runner, target, name, args, node) => {
             case "find":
                 for (let index = 0; index < length; index += 1) {
                     const item = target[index];
-                    if (yield* apply([item, index, target]))
+                    if (yield* apply([item, index, receiver]))
                         return item;
                 }
                 return undefined;
             case "findIndex":
                 for (let index = 0; index < length; index += 1) {
-                    if (yield* apply([target[index], index, target]))
+                    if (yield* apply([target[index], index, receiver]))
                         return index;
                 }
                 return -1;
@@ -725,7 +734,7 @@ const invokeArrayMethod = (runner, target, name, args, node) => {
                 for (let index = 0; index < length; index += 1) {
                     if (!(index in target))
                         continue;
-                    if (yield* apply([target[index], index, target]))
+                    if (yield* apply([target[index], index, receiver]))
                         return true;
                 }
                 return false;
@@ -733,14 +742,14 @@ const invokeArrayMethod = (runner, target, name, args, node) => {
                 for (let index = 0; index < length; index += 1) {
                     if (!(index in target))
                         continue;
-                    if (!(yield* apply([target[index], index, target])))
+                    if (!(yield* apply([target[index], index, receiver])))
                         return false;
                 }
                 return true;
             case "forEach":
                 for (let index = 0; index < length; index += 1) {
                     if (index in target)
-                        yield* apply([target[index], index, target]);
+                        yield* apply([target[index], index, receiver]);
                 }
                 return undefined;
             case "reduce": {
@@ -757,7 +766,7 @@ const invokeArrayMethod = (runner, target, name, args, node) => {
                 for (let index = start; index < length; index += 1) {
                     if (!(index in target))
                         continue;
-                    accumulator = yield* apply([accumulator, target[index], index, target]);
+                    accumulator = yield* apply([accumulator, target[index], index, receiver]);
                 }
                 return accumulator;
             }
@@ -775,20 +784,20 @@ const invokeArrayMethod = (runner, target, name, args, node) => {
                 for (let index = start; index >= 0; index -= 1) {
                     if (!(index in target))
                         continue;
-                    accumulator = yield* apply([accumulator, target[index], index, target]);
+                    accumulator = yield* apply([accumulator, target[index], index, receiver]);
                 }
                 return accumulator;
             }
             case "findLast":
                 for (let index = length - 1; index >= 0; index -= 1) {
                     const item = target[index];
-                    if (yield* apply([item, index, target]))
+                    if (yield* apply([item, index, receiver]))
                         return item;
                 }
                 return undefined;
             case "findLastIndex":
                 for (let index = length - 1; index >= 0; index -= 1) {
-                    if (yield* apply([target[index], index, target]))
+                    if (yield* apply([target[index], index, receiver]))
                         return index;
                 }
                 return -1;

package/dist/interpreter/model.d.ts

@@ -1,7 +1,7 @@
-import type { BlockStatement, Expression, Node, Pattern } from "acorn";
+import type { Node } from "acorn";
 import type { Effect } from "effect";
 import type { DiagnosticKind } from "../codemode.js";
-import type { SafeObject } from "../data.js";
+import type { ProgramObject } from "./objects.js";
 import type { Values } from "../values.js";
 /** Any parsed node; the interpreter narrows on `type` and reads `loc` for diagnostics. */
 export type AstNode = Node;
@@ -23,17 +23,9 @@ export type StatementResult = {
     label?: string;
 };
 export type MemberReference = {
-    target: SafeObject | Array<unknown> | Values.RegExp | Values.URL;
+    target: ProgramObject | Values.RegExp | Values.URL;
     key: PropertyKey;
 };
-export declare class CodeModeFunction {
-    readonly parameters: ReadonlyArray<Pattern>;
-    readonly body: BlockStatement | Expression;
-    readonly capturedScopes: ReadonlyArray<Map<string, Binding>>;
-    readonly async: boolean;
-    readonly generator: boolean;
-    constructor(parameters: ReadonlyArray<Pattern>, body: BlockStatement | Expression, capturedScopes: ReadonlyArray<Map<string, Binding>>, async: boolean, generator: boolean);
-}
 export type GeneratorRequestKind = "next" | "return" | "throw";
 export declare class CodeModeGenerator {
     readonly asynchronous: boolean;

package/dist/interpreter/model.js

@@ -1,17 +1,3 @@
-export class CodeModeFunction {
-    parameters;
-    body;
-    capturedScopes;
-    async;
-    generator;
-    constructor(parameters, body, capturedScopes, async, generator) {
-        this.parameters = parameters;
-        this.body = body;
-        this.capturedScopes = capturedScopes;
-        this.async = async;
-        this.generator = generator;
-    }
-}
 export class CodeModeGenerator {
     asynchronous;
     request;