@opencode/codemode 0.0.0-dev-19427 → 0.0.0-dev-19432

package/dist/interpreter/references.d.ts

@@ -5,3 +5,4 @@ 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

@@ -93,3 +93,11 @@ 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/runtime.js

@@ -8,7 +8,7 @@ import { HostFunction, HostNamespace } from "./host.js";
 import { invokeIntrinsic } from "./methods.js";
 import { preserveConsumerError } from "./runner.js";
 import { invokePromiseInstanceMethod, PromiseRuntime, resolvePromise, resolvePromiseValue } from "./promises.js";
-import { containsOpaqueReference, describeValue, isRuntimeReference, rejectCircularInsertion, typeofValue, } from "./references.js";
+import { containsOpaqueReference, describeValue, isRuntimeReference, parseArrayIndex, rejectCircularInsertion, typeofValue, } from "./references.js";
 import { ScopeStack } from "./scope.js";
 import { arrayMethods, mapMethods, setMethods } from "../stdlib/collections.js";
 import { dateMethods } from "../stdlib/date.js";
@@ -16,16 +16,9 @@ import { numberMethods } from "../stdlib/number.js";
 import { constructRegExp, regexpMethods, regexpProperties } from "../stdlib/regexp.js";
 import { stringMethods } from "../stdlib/string.js";
 import { uriArgument, urlMethods, urlProperties, urlSearchParamsMethods, urlWritableProperties } from "../stdlib/url.js";
+import { enumerableSource } from "../stdlib/object.js";
 import { coerceToNumber, coerceToString, compoundOperators, errorBrandName } from "../stdlib/value.js";
 import { Values } from "../values.js";
-const MAX_ARRAY_LENGTH = 4_294_967_295;
-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 calleeDescription = (callee) => {
     if (callee?.type === "Identifier")
         return callee.name;
@@ -673,17 +666,13 @@ class Frame {
             return value;
         throw new InterpreterRuntimeError(`${context} must be a function.`, node).as("TypeError");
     }
-    enumerableKeys(value) {
-        if (value instanceof ToolReference) {
+    // for...in over null/undefined iterates nothing, like JS.
+    enumerableKeys(value, node) {
+        if (value instanceof ToolReference)
             return [...this.runtime.toolKeys(value.path)];
-        }
-        if (Array.isArray(value)) {
-            return Object.keys(value);
-        }
-        if (value !== null && typeof value === "object" && !isRuntimeReference(value)) {
-            return Object.keys(value);
-        }
-        return undefined;
+        if (value === null || value === undefined)
+            return [];
+        return Object.keys(enumerableSource("for...in", value, node));
     }
     evaluateForInStatement(node, labels) {
         const left = node.left;
@@ -695,10 +684,7 @@ class Frame {
             if (declared?.lexical)
                 self.predeclarePattern(declared.pattern, declared.mutable, left);
             const right = yield* self.evaluateExpression(node.right);
-            const keys = self.enumerableKeys(right);
-            if (keys === undefined) {
-                throw new InterpreterRuntimeError("for...in requires a plain object, array, or tools reference. Use for...of for arrays/strings/Maps/Sets, or Object.keys(value) for a key list.", node);
-            }
+            const keys = self.enumerableKeys(right, node.right);
             if (left.type !== "Identifier" && left.type !== "VariableDeclaration") {
                 throw new InterpreterRuntimeError("Unsupported for...in binding.", left);
             }
@@ -1597,14 +1583,13 @@ class Frame {
             for (const property of node.properties) {
                 if (property.type === "SpreadElement") {
                     const spread = yield* self.evaluateExpression(property.argument);
-                    if (spread === null || spread === undefined || Values.isValue(spread))
+                    if (spread === null || spread === undefined)
                         continue;
-                    if (typeof spread !== "object" || Array.isArray(spread) || isRuntimeReference(spread)) {
-                        throw new InterpreterRuntimeError(`Object spread requires a data object, received ${describeValue(spread)}.`, property, "InvalidDataValue");
-                    }
-                    for (const [key, value] of Object.entries(spread))
+                    const from = enumerableSource("Object spread", spread, property);
+                    for (const [key, value] of Object.entries(from))
                         objectValue[key] = value;
-                    copyIteratorSymbols(spread, objectValue);
+                    if (typeof from === "object")
+                        copyIteratorSymbols(from, objectValue);
                     continue;
                 }
                 if (property.kind !== "init") {

package/dist/stdlib/object.d.ts

@@ -1,5 +1,6 @@
 import { HostFunction } from "../interpreter/host.js";
 import { type AstNode } from "../interpreter/model.js";
 import { type Runner } from "../interpreter/runner.js";
+export declare const enumerableSource: (label: string, value: unknown, node: AstNode) => Record<string, unknown>;
 export declare const objectAssign: (args: Array<unknown>, node: AstNode) => unknown;
 export declare const objectGlobal: <R>(runner: Runner<R>, toolKeys: (path: ReadonlyArray<string>) => ReadonlyArray<string>) => HostFunction<R>;

package/dist/stdlib/object.js

@@ -2,52 +2,62 @@ import { Effect } from "effect";
 import { toProgram } from "../data.js";
 import { HostFunction, sync, syncCall } from "../interpreter/host.js";
 import { AsyncIteratorSymbol, InterpreterRuntimeError, IteratorSymbol } from "../interpreter/model.js";
-import { containsOpaqueReference, describeValue, rejectCircularInsertion, typeofValue, } from "../interpreter/references.js";
+import { containsOpaqueReference, describeValue, isRuntimeReference, parseArrayIndex, rejectCircularInsertion, typeofValue, } from "../interpreter/references.js";
 import { preserveConsumerError } from "../interpreter/runner.js";
 import { ToolReference } from "../tool-runtime.js";
 import { Values } from "../values.js";
 import { groupBy } from "./collections.js";
 import { coerceToString } from "./value.js";
-const requireObject = (name, input, node) => {
-    if (Array.isArray(input))
-        return input;
-    if (Values.isValue(input))
-        return {};
-    const prototype = input === null || typeof input !== "object" ? undefined : Object.getPrototypeOf(input);
-    if (prototype !== null && prototype !== Object.prototype) {
-        throw new InterpreterRuntimeError(`Object.${name} expects a data object or array, received ${describeValue(input)}.`, node, "InvalidDataValue");
+// ToObject for enumeration. Strings return themselves: the host's Object.keys/entries/hasOwn index a
+// primitive string directly. Numbers, booleans, wrappers, and functions have no own enumerable keys.
+export const enumerableSource = (label, value, node) => {
+    if (value === null || value === undefined) {
+        throw new InterpreterRuntimeError(`${label} cannot convert ${describeValue(value)} to an object.`, node).as("TypeError");
+    }
+    if (value instanceof Values.Promise) {
+        throw new InterpreterRuntimeError(`${label} received an un-awaited Promise; await it before inspecting the result.`, node, "InvalidDataValue");
+    }
+    if (value instanceof ToolReference) {
+        throw new InterpreterRuntimeError(`${label} cannot read tool references: they are not plain data. Use Object.keys(tools) for names, or search({ query }) for signatures.`, node, "InvalidDataValue");
     }
-    return input;
+    if (typeof value === "string")
+        return value;
+    if (typeof value !== "object" || Values.isValue(value) || isRuntimeReference(value))
+        return {};
+    return value;
 };
 export const objectAssign = (args, node) => {
     const target = args[0];
-    if (target === null || typeof target !== "object" || Array.isArray(target) || Values.isValue(target)) {
-        throw new InterpreterRuntimeError("Object.assign expects a data object target.", node);
+    // JS would box a primitive target; wrappers and primitives cannot hold fields here.
+    if (target === null || typeof target !== "object" || Values.isValue(target) || isRuntimeReference(target)) {
+        throw new InterpreterRuntimeError(`Object.assign expects a data object or array target, received ${describeValue(target)}.`, node).as("TypeError");
     }
     const out = target;
     const seen = new Set();
     const guardedSet = (key, item) => {
+        // Arrays hold only indexed elements, as with direct assignment; Reflect.set would otherwise
+        // reach Array's length and Object.prototype's __proto__ setter.
+        if (Array.isArray(out) && (typeof key === "symbol" || parseArrayIndex(key) === undefined)) {
+            throw new InterpreterRuntimeError(`Object.assign cannot assign '${String(key)}' to an array: only array indexes may be assigned.`, node).as("TypeError");
+        }
         rejectCircularInsertion(out, item, "Object.assign result", node, seen);
         if (!Reflect.set(out, key, item))
             throw new InterpreterRuntimeError(`Object.assign could not assign property '${String(key)}'.`, node).as("TypeError");
     };
     for (const source of args.slice(1)) {
-        if (source === null || source === undefined || Values.isValue(source))
+        if (source === null || source === undefined)
+            continue;
+        const from = enumerableSource("Object.assign(...)", source, node);
+        if (typeof from !== "object") {
+            for (const [key, item] of Object.entries(from))
+                guardedSet(key, item);
             continue;
-        if (typeof source !== "object" || Array.isArray(source)) {
-            throw new InterpreterRuntimeError("Object.assign expects data objects.", node);
         }
-        for (const key of Reflect.ownKeys(source)) {
-            if (typeof key === "string") {
-                if (Object.prototype.propertyIsEnumerable.call(source, key))
-                    guardedSet(key, Reflect.get(source, key));
-                continue;
-            }
-            if (key !== AsyncIteratorSymbol && key !== IteratorSymbol)
+        for (const key of Reflect.ownKeys(from)) {
+            if (typeof key === "symbol" && key !== AsyncIteratorSymbol && key !== IteratorSymbol)
                 continue;
-            if (!Object.prototype.propertyIsEnumerable.call(source, key))
-                continue;
-            guardedSet(key, Reflect.get(source, key));
+            if (Object.prototype.propertyIsEnumerable.call(from, key))
+                guardedSet(key, Reflect.get(from, key));
         }
     }
     return out;
@@ -93,10 +103,7 @@ const rejectTools = (name, args, node) => {
         return;
     throw new InterpreterRuntimeError(`Object.${name}(...) cannot read tool references: they are not plain data. Use Object.keys(tools) for names, or search({ query }) for signatures.`, node, "InvalidDataValue");
 };
-const objectStatic = (name, impl) => sync(`Object.${name}`, (args, node) => {
-    rejectTools(name, args, node);
-    return impl(args, node);
-});
+const objectStatic = (name, impl) => sync(`Object.${name}`, impl);
 // Object constructs identically with or without new, like JS. Only `keys` copies its result into the
 // program; `values`, `entries`, `assign`, and `fromEntries` hand back the program's own values.
 export const objectGlobal = (runner, toolKeys) => new HostFunction({
@@ -107,10 +114,10 @@ export const objectGlobal = (runner, toolKeys) => new HostFunction({
     members: {
         keys: sync("Object.keys", (args, node) => toProgram(args[0] instanceof ToolReference
             ? [...toolKeys(args[0].path)]
-            : Object.keys(requireObject("keys", args[0], node)), "Object.keys result")),
-        values: objectStatic("values", (args, node) => Object.values(requireObject("values", args[0], node))),
-        entries: objectStatic("entries", (args, node) => Object.entries(requireObject("entries", args[0], node)).map(([key, item]) => [key, item])),
-        hasOwn: objectStatic("hasOwn", (args, node) => Object.hasOwn(requireObject("hasOwn", args[0], node), args[1] === AsyncIteratorSymbol || args[1] === IteratorSymbol ? args[1] : String(args[1]))),
+            : Object.keys(enumerableSource("Object.keys(...)", args[0], node)), "Object.keys result")),
+        values: objectStatic("values", (args, node) => Object.values(enumerableSource("Object.values(...)", args[0], node))),
+        entries: objectStatic("entries", (args, node) => Object.entries(enumerableSource("Object.entries(...)", args[0], node)).map(([key, item]) => [key, item])),
+        hasOwn: objectStatic("hasOwn", (args, node) => Object.hasOwn(enumerableSource("Object.hasOwn(...)", args[0], node), args[1] === AsyncIteratorSymbol || args[1] === IteratorSymbol ? args[1] : String(args[1]))),
         is: objectStatic("is", (args, node) => {
             if (containsOpaqueReference(args[0]) || containsOpaqueReference(args[1])) {
                 throw new InterpreterRuntimeError("Object.is requires data values.", node, "InvalidDataValue");

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/codemode",
-  "version": "0.0.0-dev-19427",
+  "version": "0.0.0-dev-19432",
   "description": "Effect-native confined code execution over schema-described tools",
   "type": "module",
   "license": "MIT",