@opencode/codemode 0.0.0-dev-19484 → 0.0.0-dev-19486

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, 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,9 @@ 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.`);
     }
+    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 +72,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 +86,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 +126,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 +143,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/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) {
@@ -183,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));
@@ -249,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;
     };
@@ -281,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));
@@ -316,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* () {
@@ -349,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* () {
@@ -468,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");
             }),
         };
@@ -544,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": {
@@ -560,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;
@@ -573,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)
@@ -591,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;
@@ -607,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":
@@ -627,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);
         }
@@ -650,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": {
@@ -668,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* () {
@@ -691,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;
             }
@@ -700,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);
                 }
@@ -714,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;
@@ -722,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;
@@ -736,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;
@@ -744,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": {
@@ -768,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;
             }
@@ -786,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 { 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,7 +23,7 @@ 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 {

package/dist/interpreter/objects.d.ts

@@ -0,0 +1,25 @@
+/** An object owned by the program: own properties plus a prototype link. */
+export declare class ProgramObject {
+    proto: ProgramObject | null;
+    readonly props: Map<PropertyKey, unknown>;
+    constructor(proto?: ProgramObject | null);
+}
+export declare class ProgramArray extends ProgramObject {
+    readonly items: Array<unknown>;
+    constructor(items?: Array<unknown>);
+}
+export declare class ProgramError extends ProgramObject {
+    readonly errorName: string;
+    constructor(errorName: string);
+}
+export declare const parseArrayIndex: (key: string | number) => number | undefined;
+export declare const hasOwn: (target: ProgramObject, key: PropertyKey) => boolean;
+export declare const getOwn: (target: ProgramObject, key: PropertyKey) => unknown;
+export declare const get: (target: ProgramObject, key: PropertyKey) => unknown;
+export declare const has: (target: ProgramObject, key: PropertyKey) => boolean;
+export declare const set: (target: ProgramObject, key: PropertyKey, value: unknown) => boolean;
+export declare const remove: (target: ProgramObject, key: PropertyKey) => boolean;
+export declare const ownKeys: (target: ProgramObject) => Array<string | symbol>;
+export declare const ownEntries: (target: ProgramObject) => Array<[string, unknown]>;
+export declare const record: (entries: Record<string, unknown>) => ProgramObject;
+export declare const assign: (target: ProgramObject, source: ProgramObject, skip?: ReadonlySet<PropertyKey>) => void;

package/dist/interpreter/objects.js

@@ -0,0 +1,122 @@
+import { AsyncIteratorSymbol, IteratorSymbol } from "./model.js";
+/** An object owned by the program: own properties plus a prototype link. */
+export class ProgramObject {
+    proto;
+    props = new Map();
+    constructor(proto = null) {
+        this.proto = proto;
+    }
+}
+export class ProgramArray extends ProgramObject {
+    items;
+    constructor(items = []) {
+        super();
+        this.items = items;
+    }
+}
+export class ProgramError extends ProgramObject {
+    errorName;
+    constructor(errorName) {
+        super();
+        this.errorName = errorName;
+    }
+}
+const MAX_ARRAY_LENGTH = 4_294_967_295;
+export const parseArrayIndex = (key) => {
+    const property = String(key);
+    if (!/^(0|[1-9]\d*)$/.test(property))
+        return undefined;
+    const index = Number(property);
+    return index < MAX_ARRAY_LENGTH ? index : undefined;
+};
+const canonical = (key) => (typeof key === "symbol" ? key : String(key));
+const index = (target, key) => target instanceof ProgramArray && typeof key === "string" ? parseArrayIndex(key) : undefined;
+export const hasOwn = (target, key) => {
+    const name = canonical(key);
+    const at = index(target, name);
+    if (at !== undefined)
+        return at in target.items;
+    if (name === "length" && target instanceof ProgramArray)
+        return true;
+    return target.props.has(name);
+};
+export const getOwn = (target, key) => {
+    const name = canonical(key);
+    const at = index(target, name);
+    if (at !== undefined)
+        return target.items[at];
+    if (name === "length" && target instanceof ProgramArray)
+        return target.items.length;
+    return target.props.get(name);
+};
+export const get = (target, key) => {
+    for (let current = target; current !== null; current = current.proto) {
+        if (hasOwn(current, key))
+            return getOwn(current, key);
+    }
+    return undefined;
+};
+export const has = (target, key) => {
+    for (let current = target; current !== null; current = current.proto) {
+        if (hasOwn(current, key))
+            return true;
+    }
+    return false;
+};
+export const set = (target, key, value) => {
+    const name = canonical(key);
+    const at = index(target, name);
+    if (at !== undefined) {
+        ;
+        target.items[at] = value;
+        return true;
+    }
+    if (name === "length" && target instanceof ProgramArray) {
+        const length = typeof value === "number" ? value : Number(value);
+        if (!Number.isInteger(length) || length < 0 || length > 4_294_967_295)
+            return false;
+        target.items.length = length;
+        return true;
+    }
+    target.props.set(name, value);
+    return true;
+};
+export const remove = (target, key) => {
+    const name = canonical(key);
+    const at = index(target, name);
+    if (at !== undefined)
+        return delete target.items[at];
+    if (name === "length" && target instanceof ProgramArray)
+        return false;
+    target.props.delete(name);
+    return true;
+};
+// JS order: array indexes, integer-like keys ascending, other strings, then symbols.
+export const ownKeys = (target) => {
+    const strings = [...target.props.keys()].filter((key) => typeof key === "string");
+    const symbols = [...target.props.keys()].filter((key) => typeof key === "symbol");
+    return [
+        ...(target instanceof ProgramArray ? Object.keys(target.items) : []),
+        ...strings.filter((key) => parseArrayIndex(key) !== undefined).sort((a, b) => Number(a) - Number(b)),
+        ...strings.filter((key) => parseArrayIndex(key) === undefined),
+        ...symbols,
+    ];
+};
+export const ownEntries = (target) => ownKeys(target)
+    .filter((key) => typeof key === "string")
+    .map((key) => [key, getOwn(target, key)]);
+export const record = (entries) => {
+    const target = new ProgramObject();
+    for (const [key, value] of Object.entries(entries))
+        set(target, key, value);
+    return target;
+};
+export const assign = (target, source, skip) => {
+    for (const key of ownKeys(source)) {
+        if (skip?.has(key))
+            continue;
+        if (typeof key === "symbol" && key !== IteratorSymbol && key !== AsyncIteratorSymbol)
+            continue;
+        set(target, key, getOwn(source, key));
+    }
+};