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

package/dist/interpreter/promises.js

@@ -1,5 +1,6 @@
 import { Cause, Deferred, Effect, Exit, Fiber, Scope } from "effect";
 import { CodeModeFunction, InterpreterRuntimeError, ProgramThrow, PromiseInstanceMethodReference, } from "./model.js";
+import { get, ProgramArray, ProgramObject, record } from "./objects.js";
 import { HostFunction, requiresNew, sync } from "./host.js";
 import { caughtErrorValue, normalizeError } from "./errors.js";
 import { typeofValue } from "./references.js";
@@ -88,9 +89,9 @@ export const resolvePromiseValue = (runner, value, node, own) => {
         return Effect.fail(selfResolutionError(node));
     if (value instanceof Values.Promise)
         return runner.settlePromise(value);
-    if (value === null || typeof value !== "object" || !Object.hasOwn(value, "then"))
+    if (!(value instanceof ProgramObject))
         return Effect.succeed(value);
-    const then = value.then;
+    const then = get(value, "then");
     if (typeofValue(then) !== "function")
         return Effect.succeed(value);
     return Effect.gen(function* () {
@@ -136,25 +137,22 @@ const invokePromiseMethod = (runner, promises, name, args, node) => {
             items.push(item);
         }
         if (name === "all") {
-            return yield* settleAfterTurn(Effect.all(items.map((item) => Effect.flatten(promises.await(item))), { concurrency: "unbounded" }));
+            return new ProgramArray(yield* settleAfterTurn(Effect.all(items.map((item) => Effect.flatten(promises.await(item))), { concurrency: "unbounded" })));
         }
         if (name === "allSettled") {
             const outcomes = [];
             for (const item of items) {
                 const exit = yield* promises.await(item);
                 if (Exit.isSuccess(exit)) {
-                    outcomes.push(Object.assign(Object.create(null), { status: "fulfilled", value: exit.value }));
+                    outcomes.push(record({ status: "fulfilled", value: exit.value }));
                     continue;
                 }
                 if (Cause.hasInterruptsOnly(exit.cause))
                     return yield* Effect.failCause(exit.cause);
-                outcomes.push(Object.assign(Object.create(null), {
-                    status: "rejected",
-                    reason: caughtErrorValue(Cause.squash(exit.cause)),
-                }));
+                outcomes.push(record({ status: "rejected", reason: caughtErrorValue(Cause.squash(exit.cause)) }));
             }
             yield* Effect.yieldNow;
-            return outcomes;
+            return new ProgramArray(outcomes);
         }
         if (name === "race") {
             if (items.length === 0) {

package/dist/interpreter/references.d.ts

@@ -5,4 +5,3 @@ export declare const containsOpaqueReference: (value: unknown) => boolean;
 export declare const rejectCircularInsertion: (container: object, value: unknown, label: string, node: AstNode, seen?: Set<object>) => void;
 export declare const describeValue: (value: unknown) => string;
 export declare const typeofValue: (value: unknown) => string;
-export declare const parseArrayIndex: (key: string | number) => number | undefined;

package/dist/interpreter/references.js

@@ -1,7 +1,8 @@
 import { ToolReference } from "../tool-runtime.js";
 import { Values } from "../values.js";
 import { HostFunction, HostNamespace } from "./host.js";
-import { AsyncIteratorSymbol, CodeModeFunction, CodeModeGenerator, GeneratorMethodReference, InterpreterRuntimeError, IntrinsicReference, IteratorSymbol, PromiseInstanceMethodReference, } from "./model.js";
+import { CodeModeFunction, CodeModeGenerator, GeneratorMethodReference, InterpreterRuntimeError, IntrinsicReference, PromiseInstanceMethodReference, } from "./model.js";
+import { getOwn, ownKeys, ProgramArray, ProgramObject } from "./objects.js";
 export const isRuntimeReference = (value) => value instanceof HostFunction ||
     value instanceof HostNamespace ||
     value instanceof CodeModeFunction ||
@@ -13,13 +14,10 @@ export const isRuntimeReference = (value) => value instanceof HostFunction ||
     value instanceof Values.Promise ||
     Values.isValue(value);
 function* childValues(value) {
-    for (const key of Reflect.ownKeys(value)) {
-        if (!Object.prototype.propertyIsEnumerable.call(value, key))
-            continue;
-        if (typeof key === "symbol" && key !== AsyncIteratorSymbol && key !== IteratorSymbol)
-            continue;
-        yield Reflect.get(value, key);
-    }
+    if (!(value instanceof ProgramObject))
+        return;
+    for (const key of ownKeys(value))
+        yield getOwn(value, key);
 }
 // Depth-first search over a value tree. `match` stops the walk; `skip` prunes a subtree without matching it.
 const find = (value, match, skip, seen) => {
@@ -53,7 +51,7 @@ export const rejectCircularInsertion = (container, value, label, node, seen = ne
 export const describeValue = (value) => {
     if (value === null)
         return "null";
-    if (Array.isArray(value))
+    if (value instanceof ProgramArray)
         return "an array";
     if (value instanceof Values.Promise)
         return "an un-awaited Promise";
@@ -93,11 +91,3 @@ export const typeofValue = (value) => {
         return value.path.length > 0 ? "function" : "object";
     return typeof value;
 };
-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;
-};

package/dist/interpreter/runner.js

@@ -3,6 +3,7 @@ import { Values } from "../values.js";
 import { coerceToString } from "../stdlib/value.js";
 import { HostFunction } from "./host.js";
 import { CodeModeFunction, InterpreterRuntimeError, IntrinsicReference } from "./model.js";
+import { get, has, ProgramObject } from "./objects.js";
 import { typeofValue } from "./references.js";
 export const preserveConsumerError = (cursor, effect) => Effect.flatMap(Effect.exit(effect), (exit) => Exit.isSuccess(exit)
     ? Effect.succeed(exit.value)
@@ -13,15 +14,17 @@ export const toPrimitive = (runner, value, hint, node) => {
     if (Values.isValue(value)) {
         return Effect.succeed(value instanceof Values.Date && hint === "number" ? value.time : coerceToString(value));
     }
-    const object = value;
+    if (!(value instanceof ProgramObject))
+        return Effect.succeed(value);
     const order = hint === "number" ? ["valueOf", "toString"] : ["toString", "valueOf"];
     return Effect.gen(function* () {
         for (const method of order) {
-            if (method === "toString" && !Object.hasOwn(object, "toString"))
+            if (method === "toString" && !has(value, "toString"))
                 return coerceToString(value);
-            if (!Object.hasOwn(object, method) || typeofValue(object[method]) !== "function")
+            const callable = get(value, method);
+            if (typeofValue(callable) !== "function")
                 continue;
-            const result = yield* runner.invokeCallable(object[method], [], node);
+            const result = yield* runner.invokeCallable(callable, [], node);
             if (result === null || (typeof result !== "object" && typeof result !== "function"))
                 return result;
         }

package/dist/interpreter/runtime.js

@@ -1,14 +1,15 @@
 import { Cause, Deferred, Effect, Exit } from "effect";
 import { ToolRuntimeError, toProgram } from "../data.js";
 import { ToolReference } from "../tool-runtime.js";
-import { AsyncIteratorSymbol, CodeModeFunction, CodeModeGenerator, ComputedValue, GeneratorMethodReference, GeneratorReturn, IntrinsicReference, InterpreterRuntimeError, isRecord, IteratorSymbol, IteratorSymbols, OptionalShortCircuit, PromiseInstanceMethodReference, ProgramThrow, unsupportedSyntax, } from "./model.js";
+import { AsyncIteratorSymbol, CodeModeFunction, CodeModeGenerator, ComputedValue, GeneratorMethodReference, GeneratorReturn, IntrinsicReference, InterpreterRuntimeError, IteratorSymbol, OptionalShortCircuit, PromiseInstanceMethodReference, ProgramThrow, unsupportedSyntax, } from "./model.js";
 import { caughtErrorValue } from "./errors.js";
 import { globals } from "./globals.js";
 import { HostFunction, HostNamespace } from "./host.js";
 import { invokeIntrinsic } from "./methods.js";
+import { assign, get, has, ownKeys, parseArrayIndex, ProgramArray, ProgramObject, record, remove, set, } from "./objects.js";
 import { preserveConsumerError } from "./runner.js";
 import { invokePromiseInstanceMethod, PromiseRuntime, resolvePromise, resolvePromiseValue } from "./promises.js";
-import { containsOpaqueReference, describeValue, isRuntimeReference, parseArrayIndex, rejectCircularInsertion, typeofValue, } from "./references.js";
+import { containsOpaqueReference, describeValue, isRuntimeReference, rejectCircularInsertion, typeofValue, } from "./references.js";
 import { ScopeStack } from "./scope.js";
 import { arrayMethods, mapMethods, setMethods } from "../stdlib/collections.js";
 import { dateMethods } from "../stdlib/date.js";
@@ -49,7 +50,6 @@ const calleeDescription = (callee) => {
     }
     return "The called value";
 };
-const hasOwn = (value, key) => value !== null && typeof value === "object" && Object.hasOwn(value, key);
 const constructorName = (value) => {
     if (typeof value === "string")
         return "String";
@@ -57,7 +57,7 @@ const constructorName = (value) => {
         return "Number";
     if (typeof value === "boolean")
         return "Boolean";
-    if (Array.isArray(value))
+    if (value instanceof ProgramArray)
         return "Array";
     if (value instanceof Values.Date)
         return "Date";
@@ -73,7 +73,7 @@ const constructorName = (value) => {
         return "URLSearchParams";
     if (value instanceof Values.Promise)
         return "Promise";
-    if (value === null || typeof value !== "object" || isRuntimeReference(value))
+    if (!(value instanceof ProgramObject))
         return undefined;
     return errorBrandName(value) ?? "Object";
 };
@@ -174,12 +174,6 @@ const isOpaqueMemberReference = (value) => value instanceof ToolReference ||
     value instanceof PromiseInstanceMethodReference ||
     value instanceof IntrinsicReference ||
     value instanceof GeneratorMethodReference;
-const copyIteratorSymbols = (source, target, consumed) => {
-    for (const symbol of IteratorSymbols) {
-        if (!consumed?.has(symbol) && Object.hasOwn(source, symbol))
-            Reflect.set(target, symbol, Reflect.get(source, symbol));
-    }
-};
 const promiseResolutionNode = { type: "PromiseResolution", start: 0, end: 0 };
 /** One program execution: the tool bridge, promise scheduler, captured logs, and the global scope built once. */
 export class Runtime {
@@ -574,8 +568,8 @@ class Frame {
         });
     }
     syncIterator(value, node) {
-        const iterator = Array.isArray(value)
-            ? value[Symbol.iterator]()
+        const iterator = value instanceof ProgramArray
+            ? value.items[Symbol.iterator]()
             : typeof value === "string"
                 ? value[Symbol.iterator]()
                 : value instanceof Values.Map
@@ -589,7 +583,10 @@ class Frame {
             return Effect.succeed({
                 next: Effect.sync(() => {
                     const step = iterator.next();
-                    return { done: Boolean(step.done), value: step.value };
+                    return {
+                        done: Boolean(step.done),
+                        value: Array.isArray(step.value) ? new ProgramArray(step.value) : step.value,
+                    };
                 }),
                 close: Effect.void,
             });
@@ -612,10 +609,10 @@ class Frame {
                 asynchronous: value.asynchronous,
             });
         }
-        if (!isRecord(value) || isRuntimeReference(value))
+        if (!(value instanceof ProgramObject))
             return Effect.undefined;
-        const asyncMethod = allowAsync ? Reflect.get(value, AsyncIteratorSymbol) : undefined;
-        const method = asyncMethod ?? Reflect.get(value, IteratorSymbol);
+        const asyncMethod = allowAsync ? get(value, AsyncIteratorSymbol) : undefined;
+        const method = asyncMethod ?? get(value, IteratorSymbol);
         if (method === undefined || method === null)
             return Effect.undefined;
         const self = this;
@@ -625,7 +622,7 @@ class Frame {
                 iterator: object,
                 next: object instanceof CodeModeGenerator
                     ? new GeneratorMethodReference(object, "next")
-                    : self.requireIteratorMethod(object.next, "Iterator next", node),
+                    : self.requireIteratorMethod(get(object, "next"), "Iterator next", node),
                 asynchronous: asyncMethod !== undefined && asyncMethod !== null,
             };
         });
@@ -635,7 +632,7 @@ class Frame {
         return Effect.gen(function* () {
             if (iterator.asynchronous) {
                 const object = self.requireIteratorObject(yield* self.awaitValue(yield* self.invokeCallable(iterator.next, [], node)), "Iterator next() result", node);
-                return { done: Boolean(object.done), value: object.value };
+                return { done: Boolean(get(object, "done")), value: get(object, "value") };
             }
             const called = yield* Effect.exit(self.invokeCallable(iterator.next, [], node));
             if (!Exit.isSuccess(called)) {
@@ -645,7 +642,7 @@ class Frame {
             }
             const captured = yield* Effect.exit(Effect.sync(() => {
                 const object = self.requireIteratorObject(called.value, "Iterator next() result", node);
-                return { done: Boolean(object.done), value: object.value };
+                return { done: Boolean(get(object, "done")), value: get(object, "value") };
             }));
             if (!Exit.isSuccess(captured)) {
                 if (awaiting)
@@ -663,7 +660,7 @@ class Frame {
     closeIterator(iterator, node, awaiting = true) {
         const close = iterator.iterator instanceof CodeModeGenerator
             ? new GeneratorMethodReference(iterator.iterator, "return")
-            : iterator.iterator.return;
+            : get(iterator.iterator, "return");
         if (close === undefined || close === null)
             return iterator.asynchronous || !awaiting ? Effect.void : Effect.yieldNow;
         const self = this;
@@ -679,7 +676,7 @@ class Frame {
                     yield* Effect.yieldNow;
                 return yield* Effect.failCause(called.cause);
             }
-            const captured = yield* Effect.exit(Effect.sync(() => self.requireIteratorObject(called.value, "Iterator return() result", node).value));
+            const captured = yield* Effect.exit(Effect.sync(() => get(self.requireIteratorObject(called.value, "Iterator return() result", node), "value")));
             if (!Exit.isSuccess(captured)) {
                 if (awaiting)
                     yield* Effect.yieldNow;
@@ -690,7 +687,7 @@ class Frame {
         });
     }
     requireIteratorObject(value, context, node) {
-        if (isRecord(value) && !isRuntimeReference(value))
+        if (value instanceof ProgramObject)
             return value;
         throw new InterpreterRuntimeError(`${context} must be an object.`, node).as("TypeError");
     }
@@ -710,7 +707,7 @@ class Frame {
             return [...this.runtime.toolKeys(value.path)];
         if (value === null || value === undefined)
             return [];
-        return Object.keys(enumerableSource("for...in", value, node));
+        return ownKeys(enumerableSource("for...in", value, node)).filter((key) => typeof key === "string");
     }
     evaluateForInStatement(node, labels) {
         const left = node.left;
@@ -856,18 +853,14 @@ class Frame {
                 return;
             }
             if (pattern.type === "ObjectPattern") {
-                if (value === null || typeof value !== "object" || isRuntimeReference(value)) {
+                if (!(value instanceof ProgramObject)) {
                     throw new InterpreterRuntimeError(`Object destructuring requires a data object or array value, received ${describeValue(value)}.`, pattern, "InvalidDataValue");
                 }
                 const consumed = new Set();
                 for (const property of pattern.properties) {
                     if (property.type === "RestElement") {
-                        const rest = Object.create(null);
-                        for (const [key, item] of Object.entries(value)) {
-                            if (!consumed.has(key))
-                                rest[key] = item;
-                        }
-                        copyIteratorSymbols(value, rest, consumed);
+                        const rest = new ProgramObject();
+                        assign(rest, value, consumed);
                         yield* self.declarePattern(property.argument, rest, mutable, property, initialize);
                         continue;
                     }
@@ -900,25 +893,20 @@ class Frame {
                 return;
             }
             if (pattern.type === "ObjectPattern") {
-                if (value === null || typeof value !== "object" || isRuntimeReference(value)) {
+                if (!(value instanceof ProgramObject)) {
                     throw new InterpreterRuntimeError(`Object destructuring requires a data object or array value, received ${describeValue(value)}.`, pattern, "InvalidDataValue");
                 }
-                const source = value;
                 const consumed = new Set();
                 for (const property of pattern.properties) {
                     if (property.type === "RestElement") {
-                        const rest = Object.create(null);
-                        for (const [key, item] of Object.entries(source)) {
-                            if (!consumed.has(key))
-                                rest[key] = item;
-                        }
-                        copyIteratorSymbols(source, rest, consumed);
+                        const rest = new ProgramObject();
+                        assign(rest, value, consumed);
                         yield* self.assignPattern(property.argument, rest, property);
                         continue;
                     }
                     const key = yield* self.destructuringPropertyKey(property);
                     consumed.add(typeof key === "symbol" ? key : String(key));
-                    yield* self.assignPattern(property.value, self.destructuringPropertyValue(source, key), property);
+                    yield* self.assignPattern(property.value, self.destructuringPropertyValue(value, key), property);
                 }
                 return;
             }
@@ -940,7 +928,7 @@ class Frame {
                 if (done) {
                     if (element === null)
                         continue;
-                    yield* consume(element.type === "RestElement" ? element.argument : element, element.type === "RestElement" ? [] : undefined, element);
+                    yield* consume(element.type === "RestElement" ? element.argument : element, element.type === "RestElement" ? new ProgramArray() : undefined, element);
                     if (element.type === "RestElement")
                         return;
                     continue;
@@ -959,7 +947,7 @@ class Frame {
                         if (!done)
                             rest.push(next.value);
                     }
-                    yield* consume(element.argument, rest, element);
+                    yield* consume(element.argument, new ProgramArray(rest), element);
                     return;
                 }
                 const consumed = consume(element, step.done ? undefined : step.value, pattern);
@@ -984,14 +972,10 @@ class Frame {
         throw unsupportedSyntax(keyNode.type, keyNode);
     }
     destructuringPropertyValue(source, key) {
-        if (!Array.isArray(source))
-            return Reflect.get(source, key);
-        if (key === "length")
-            return source.length;
-        if (typeof key === "number")
-            return source[key];
-        if (Object.hasOwn(source, key))
-            return Reflect.get(source, key);
+        if (!(source instanceof ProgramArray))
+            return get(source, key);
+        if (has(source, key))
+            return get(source, key);
         if (typeof key === "string" && arrayMethods.has(key))
             return new IntrinsicReference(source, key);
         return undefined;
@@ -1148,11 +1132,10 @@ class Frame {
             case ">>>":
                 return l >>> r;
             case "in":
-                if (rhs === null || typeof rhs !== "object") {
+                if (!(rhs instanceof ProgramObject)) {
                     throw new InterpreterRuntimeError("The 'in' operator requires a data object on the right-hand side.", node);
                 }
-                // Never expose properties inherited from host prototypes.
-                return Object.hasOwn(rhs, coerceOperand(lhs));
+                return has(rhs, coerceOperand(lhs));
             default:
                 throw new InterpreterRuntimeError(`Unsupported binary operator '${operator}'.`, node);
         }
@@ -1387,7 +1370,7 @@ class Frame {
             }
             for (const [index, parameter] of fn.parameters.entries()) {
                 if (parameter.type === "RestElement") {
-                    yield* invocation.declarePattern(parameter.argument, args.slice(index), true, parameter, true);
+                    yield* invocation.declarePattern(parameter.argument, new ProgramArray(args.slice(index)), true, parameter, true);
                     break;
                 }
                 yield* invocation.declarePattern(parameter, args[index], true, parameter, true);
@@ -1429,13 +1412,13 @@ class Frame {
             if (state.completed) {
                 if (kind === "throw")
                     return Effect.fail(new ProgramThrow(value));
-                return Effect.succeed({ value: kind === "return" ? value : undefined, done: true });
+                return Effect.succeed(record({ value: kind === "return" ? value : undefined, done: true }));
             }
             if (!state.started && kind !== "next") {
                 state.completed = true;
                 if (kind === "throw")
                     return Effect.fail(new ProgramThrow(value));
-                return Effect.succeed({ value, done: true });
+                return Effect.succeed(record({ value, done: true }));
             }
             state.pending.push(request);
             if (state.available) {
@@ -1455,7 +1438,7 @@ class Frame {
                     const active = state.active;
                     state.active = undefined;
                     if (active) {
-                        Deferred.doneUnsafe(active.response, Exit.isSuccess(exit) ? Exit.succeed({ value: exit.value, done: true }) : exit);
+                        Deferred.doneUnsafe(active.response, Exit.isSuccess(exit) ? Exit.succeed(record({ value: exit.value, done: true })) : exit);
                     }
                     yield* invocation.completeGeneratorRequests(state, asynchronous);
                     state.completed = true;
@@ -1479,10 +1462,10 @@ class Frame {
                 }
                 if (asynchronous && pending.kind === "return") {
                     const resolved = yield* Effect.exit(self.awaitValue(pending.value));
-                    Deferred.doneUnsafe(pending.response, Exit.isSuccess(resolved) ? Exit.succeed({ value: resolved.value, done: true }) : resolved);
+                    Deferred.doneUnsafe(pending.response, Exit.isSuccess(resolved) ? Exit.succeed(record({ value: resolved.value, done: true })) : resolved);
                     continue;
                 }
-                Deferred.doneUnsafe(pending.response, Exit.succeed({ value: pending.kind === "return" ? pending.value : undefined, done: true }));
+                Deferred.doneUnsafe(pending.response, Exit.succeed(record({ value: pending.kind === "return" ? pending.value : undefined, done: true })));
             }
         });
     }
@@ -1523,7 +1506,7 @@ class Frame {
         const state = this.generatorState;
         if (!state?.active)
             throw new InterpreterRuntimeError("Generator has no active request.", node);
-        Deferred.doneUnsafe(state.active.response, Exit.succeed({ value, done: false }));
+        Deferred.doneUnsafe(state.active.response, Exit.succeed(record({ value, done: false })));
         state.active = undefined;
         return Effect.flatMap(this.takeGeneratorRequest(state), (request) => {
             state.active = request;
@@ -1539,7 +1522,7 @@ class Frame {
     delegateYield(value, node) {
         const self = this;
         return Effect.gen(function* () {
-            if (Array.isArray(value) ||
+            if (value instanceof ProgramArray ||
                 typeof value === "string" ||
                 value instanceof Values.Map ||
                 value instanceof Values.Set ||
@@ -1576,7 +1559,7 @@ class Frame {
                     ? iterator.next
                     : iterator.iterator instanceof CodeModeGenerator
                         ? new GeneratorMethodReference(iterator.iterator, kind)
-                        : iterator.iterator[kind];
+                        : get(iterator.iterator, kind);
                 if (method === undefined || method === null) {
                     if (kind === "return")
                         return yield* Effect.fail(new GeneratorReturn(input));
@@ -1585,10 +1568,10 @@ class Frame {
                 }
                 const called = yield* self.invokeCallable(self.requireIteratorMethod(method, `Iterator ${kind}`, node), [input], node);
                 const result = self.requireIteratorObject(iterator.asynchronous ? yield* self.awaitValue(called) : called, `Iterator ${kind}() result`, node);
-                const done = Boolean(result.done);
+                const done = Boolean(get(result, "done"));
                 const resultValue = self.generatorAsync && !iterator.asynchronous
-                    ? yield* self.awaitAsyncFromSyncValue(iterator, result.value, node, kind !== "return" && !done)
-                    : result.value;
+                    ? yield* self.awaitAsyncFromSyncValue(iterator, get(result, "value"), node, kind !== "return" && !done)
+                    : get(result, "value");
                 if (done) {
                     if (kind === "return")
                         return yield* Effect.fail(new GeneratorReturn(resultValue));
@@ -1610,7 +1593,7 @@ class Frame {
         });
     }
     evaluateObjectExpression(node) {
-        const objectValue = Object.create(null);
+        const objectValue = new ProgramObject();
         const self = this;
         return Effect.gen(function* () {
             for (const property of node.properties) {
@@ -1618,11 +1601,7 @@ class Frame {
                     const spread = yield* self.evaluateExpression(property.argument);
                     if (spread === null || spread === undefined)
                         continue;
-                    const from = enumerableSource("Object spread", spread, property);
-                    for (const [key, value] of Object.entries(from))
-                        objectValue[key] = value;
-                    if (typeof from === "object")
-                        copyIteratorSymbols(from, objectValue);
+                    assign(objectValue, enumerableSource("Object spread", spread, property));
                     continue;
                 }
                 if (property.kind !== "init") {
@@ -1642,7 +1621,7 @@ class Frame {
                 else {
                     throw new InterpreterRuntimeError("Unsupported object property key shape.", keyNode);
                 }
-                Reflect.set(objectValue, key, yield* self.evaluateExpression(property.value));
+                set(objectValue, key, yield* self.evaluateExpression(property.value));
             }
             return objectValue;
         });
@@ -1673,7 +1652,7 @@ class Frame {
                     values.push(yield* self.evaluateExpression(element));
                 }
             }
-            return values;
+            return new ProgramArray(values);
         });
     }
     evaluateTemplateLiteral(node) {
@@ -1736,7 +1715,9 @@ class Frame {
                 return new ComputedValue(objectValue.member(key, propertyNode));
             }
             // Values have no prototype chain, so `.constructor` resolves to the owning built-in directly.
-            if (operation === "read" && key === "constructor" && !hasOwn(objectValue, key)) {
+            if (operation === "read" &&
+                key === "constructor" &&
+                !(objectValue instanceof ProgramObject && has(objectValue, key))) {
                 const name = constructorName(objectValue);
                 if (name !== undefined)
                     return new ComputedValue(self.runtime.builtins.get(name));
@@ -1823,25 +1804,14 @@ class Frame {
             if (isRuntimeReference(objectValue)) {
                 throw new InterpreterRuntimeError(`Cannot read properties of ${describeValue(objectValue)}; only data values expose properties.`, objectNode, "InvalidDataValue");
             }
-            if (typeof objectValue !== "object" || objectValue === null) {
+            if (!(objectValue instanceof ProgramObject)) {
                 throw new InterpreterRuntimeError("Cannot access a property on a non-object value.", objectNode);
             }
-            if (Array.isArray(objectValue)) {
-                if (operation === "delete")
-                    return { target: objectValue, key };
-                const index = typeof key === "symbol" ? undefined : parseArrayIndex(key);
-                if (key !== "length" && !(typeof key === "string" && arrayMethods.has(key)) && index === undefined) {
-                    if (typeof key === "string" && Object.hasOwn(objectValue, key)) {
-                        return new ComputedValue(objectValue[key]);
-                    }
-                    return new ComputedValue(undefined);
-                }
-                return { target: objectValue, key: index ?? key };
-            }
             return { target: objectValue, key };
         });
     }
     readMember(node) {
+        const self = this;
         return Effect.map(this.getMemberReference(node), (reference) => {
             if (reference === OptionalShortCircuit)
                 return OptionalShortCircuit;
@@ -1849,19 +1819,15 @@ class Frame {
                 return reference.value;
             if (reference === undefined || isOpaqueMemberReference(reference))
                 return reference;
-            if (Array.isArray(reference.target)) {
-                if (reference.key === "length")
-                    return reference.target.length;
-                if (typeof reference.key === "string")
-                    return new IntrinsicReference(reference.target, reference.key);
-                return Reflect.get(reference.target, reference.key);
-            }
-            if (reference.target instanceof Values.RegExp)
-                return reference.target.lastIndex;
-            if (reference.target instanceof Values.URL) {
-                return Reflect.get(reference.target.url, reference.key);
-            }
-            return Reflect.get(reference.target, reference.key);
+            const value = self.readReferenceValue(reference, reference.key);
+            if (value === undefined &&
+                reference.target instanceof ProgramArray &&
+                typeof reference.key === "string" &&
+                arrayMethods.has(reference.key) &&
+                !has(reference.target, reference.key)) {
+                return new IntrinsicReference(reference.target, reference.key);
+            }
+            return value;
         });
     }
     writeMember(node, value) {
@@ -1884,7 +1850,7 @@ class Frame {
             if (reference.target instanceof Values.RegExp) {
                 return Reflect.deleteProperty(reference.target.regex, reference.key);
             }
-            return Reflect.deleteProperty(reference.target, reference.key);
+            return remove(reference.target, reference.key);
         });
     }
     // Resolve side-effecting object and key expressions exactly once.
@@ -1898,13 +1864,6 @@ class Frame {
                 isOpaqueMemberReference(reference)) {
                 throw new InterpreterRuntimeError("Only data fields may be assigned.", node);
             }
-            if (Array.isArray(reference.target)) {
-                if (reference.key === "length")
-                    throw new InterpreterRuntimeError("Array length cannot be assigned.", node);
-                if (typeof reference.key === "string" && arrayMethods.has(reference.key)) {
-                    throw new InterpreterRuntimeError("Array methods cannot be assigned.", node);
-                }
-            }
             const key = reference.key;
             const { write, next, result } = yield* compute(self.readReferenceValue(reference, key));
             if (write)
@@ -1918,18 +1877,9 @@ class Frame {
         }
         if (reference.target instanceof Values.RegExp)
             return reference.target.lastIndex;
-        return Reflect.get(reference.target, key);
+        return get(reference.target, key);
     }
     assignToReference(reference, key, next, node) {
-        if (Array.isArray(reference.target)) {
-            const target = reference.target;
-            if (typeof key !== "number" || parseArrayIndex(key) === undefined) {
-                throw new InterpreterRuntimeError("Array assignment index must be a valid array index.", node, "InvalidDataValue");
-            }
-            rejectCircularInsertion(target, next, "Array assignment result", node);
-            target[key] = next;
-            return;
-        }
         if (reference.target instanceof Values.URL) {
             const property = key;
             if (!urlWritableProperties.has(property)) {
@@ -1951,8 +1901,9 @@ class Frame {
             return;
         }
         const target = reference.target;
-        rejectCircularInsertion(target, next, "Object assignment result", node);
-        Reflect.set(target, key, next);
+        rejectCircularInsertion(target, next, target instanceof ProgramArray ? "Array assignment result" : "Object assignment result", node);
+        if (!set(target, key, next))
+            throw new InterpreterRuntimeError("Invalid array length", node).as("RangeError");
     }
     toPropertyKey(value, node) {
         if (typeof value === "string" || typeof value === "number") {