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

package/dist/data.d.ts

@@ -7,7 +7,6 @@ export declare class ToolRuntimeError extends Error {
     readonly suggestions: ReadonlyArray<string>;
     constructor(kind: Extract<DiagnosticKind, "UnknownTool" | "InvalidToolInput" | "InvalidToolOutput" | "InvalidDataValue" | "ToolCallLimitExceeded">, message: string, suggestions?: ReadonlyArray<string>);
 }
-export declare const isBlockedMember: (name: string) => boolean;
 /**
  * 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

package/dist/data.js

@@ -11,8 +11,6 @@ export class ToolRuntimeError extends Error {
         this.name = "ToolRuntimeError";
     }
 }
-const blockedMemberNames = new Set(["__proto__", "constructor", "prototype"]);
-export const isBlockedMember = (name) => blockedMemberNames.has(name);
 /**
  * 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
@@ -102,10 +100,7 @@ const copy = (value, label, mode, depth, seen) => {
             for (const [key, item] of Object.entries(value)) {
                 if (Object.hasOwn(copied, key))
                     continue;
-                if (isBlockedMember(key)) {
-                    throw new ToolRuntimeError("InvalidDataValue", `${label} contains blocked property '${key}'.`);
-                }
-                Reflect.set(copied, key, copy(item, label, mode, depth + 1, seen));
+                define(copied, key, copy(item, label, mode, depth + 1, seen));
             }
         }
         seen.delete(value);
@@ -117,14 +112,16 @@ const copy = (value, label, mode, depth, seen) => {
     }
     const copied = plain ? Object.create(null) : {};
     for (const [key, item] of Object.entries(value)) {
-        if (isBlockedMember(key)) {
-            throw new ToolRuntimeError("InvalidDataValue", `${label} contains blocked property '${key}'.`);
-        }
         const next = copy(item, label, mode, depth + 1, seen);
         if (next === undefined && mode === "json")
             continue;
-        copied[key] = next;
+        define(copied, key, next);
     }
     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.
+const define = (target, key, value) => {
+    Object.defineProperty(target, key, { value, enumerable: true, writable: true, configurable: true });
+};

package/dist/interpreter/methods.js

@@ -1,5 +1,5 @@
 import { Effect } from "effect";
-import { isBlockedMember, toProgram } from "../data.js";
+import { toProgram } from "../data.js";
 import { dateSetterArgumentCount, invokeDateMethod } from "../stdlib/date.js";
 import { invokeNumberMethod } from "../stdlib/number.js";
 import { invokeRegExpMethod, matchToValue, toHostRegex } from "../stdlib/regexp.js";
@@ -241,8 +241,7 @@ const invokeStringReplacer = (runner, value, name, args, node) => {
         if (hasGroups) {
             const safeGroups = Object.create(null);
             for (const [key, group] of Object.entries(groups)) {
-                if (!isBlockedMember(key))
-                    safeGroups[key] = group;
+                safeGroups[key] = group;
             }
             callbackArgs[callbackArgs.length - 1] = safeGroups;
         }

package/dist/interpreter/model.d.ts

@@ -72,7 +72,6 @@ export declare class GeneratorReturn {
     constructor(value: unknown);
 }
 export declare const OptionalShortCircuit: unique symbol;
-export declare const supportedSyntaxMessage = "Supported orchestration syntax: tools.* calls (they return promises - resolve them with await), data literals, destructuring, optional chaining, template literals, conditionals, switch, loops (incl. for...of and for...in over object/array/tools keys), arrow functions, spread, try/catch, array methods (map/filter/find/findIndex/some/every/reduce/flatMap/forEach/sort/slice/concat/indexOf/lastIndexOf/at/flat/reverse/includes/join), string methods (incl. match/matchAll/replace/split with regular expressions), Date/RegExp/Map/Set/URL/URLSearchParams, URI encoding helpers, Object/Math/JSON helpers, captured console.log/warn/error/dir/table, Promise.all/allSettled/race/any/resolve/reject over arrays mixing promises and plain values for parallel tool calls, promise chaining with .then/.catch/.finally, and new Promise((resolve, reject) => ...) construction.";
 export declare class InterpreterRuntimeError extends Error {
     readonly kind: DiagnosticKind;
     readonly suggestions?: ReadonlyArray<string> | undefined;
@@ -81,6 +80,7 @@ export declare class InterpreterRuntimeError extends Error {
     constructor(message: string, node?: AstNode, kind?: DiagnosticKind, suggestions?: ReadonlyArray<string> | undefined);
     as(errorName: string): this;
 }
+export declare const supportedSyntaxMessage = "This is a restricted JavaScript-like language. Supported: plain and async functions, data literals, destructuring, standard control flow, await and Promise, and built-ins such as Array, Object, Math, JSON, Date, RegExp, Map, Set, and URL. Unsupported: classes, this, getters/setters, tagged templates, BigInt, and custom Symbols. Use plain functions and data objects instead.";
 export declare const unsupportedSyntax: (kind: string, node: AstNode) => InterpreterRuntimeError;
 export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
 export declare const sourceLocation: (node: AstNode) => {

package/dist/interpreter/model.js

@@ -66,7 +66,6 @@ export class GeneratorReturn {
     }
 }
 export const OptionalShortCircuit = Symbol("codemode.optional-short-circuit");
-export const supportedSyntaxMessage = "Supported orchestration syntax: tools.* calls (they return promises - resolve them with await), data literals, destructuring, optional chaining, template literals, conditionals, switch, loops (incl. for...of and for...in over object/array/tools keys), arrow functions, spread, try/catch, array methods (map/filter/find/findIndex/some/every/reduce/flatMap/forEach/sort/slice/concat/indexOf/lastIndexOf/at/flat/reverse/includes/join), string methods (incl. match/matchAll/replace/split with regular expressions), Date/RegExp/Map/Set/URL/URLSearchParams, URI encoding helpers, Object/Math/JSON helpers, captured console.log/warn/error/dir/table, Promise.all/allSettled/race/any/resolve/reject over arrays mixing promises and plain values for parallel tool calls, promise chaining with .then/.catch/.finally, and new Promise((resolve, reject) => ...) construction.";
 export class InterpreterRuntimeError extends Error {
     kind;
     suggestions;
@@ -85,6 +84,8 @@ export class InterpreterRuntimeError extends Error {
         return this;
     }
 }
+// Orient the agent rather than enumerate JavaScript; interpreter-support.md is the full matrix.
+export const supportedSyntaxMessage = "This is a restricted JavaScript-like language. Supported: plain and async functions, data literals, destructuring, standard control flow, await and Promise, and built-ins such as Array, Object, Math, JSON, Date, RegExp, Map, Set, and URL. Unsupported: classes, this, getters/setters, tagged templates, BigInt, and custom Symbols. Use plain functions and data objects instead.";
 export const unsupportedSyntax = (kind, node) => new InterpreterRuntimeError(`Syntax '${kind}' is not supported. ${supportedSyntaxMessage}`, node, "UnsupportedSyntax", [supportedSyntaxMessage]);
 export const isRecord = (value) => typeof value === "object" && value !== null;
 export const sourceLocation = (node) => ({

package/dist/interpreter/references.d.ts

@@ -3,4 +3,5 @@ export declare const isRuntimeReference: (value: unknown) => boolean;
 export declare const containsRuntimeReference: (value: unknown) => boolean;
 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;

package/dist/interpreter/references.js

@@ -50,6 +50,35 @@ export const rejectCircularInsertion = (container, value, label, node, seen = ne
         throw new InterpreterRuntimeError(`${label} contains a circular value.`, node, "InvalidDataValue");
     }
 };
+export const describeValue = (value) => {
+    if (value === null)
+        return "null";
+    if (Array.isArray(value))
+        return "an array";
+    if (value instanceof Values.Promise)
+        return "an un-awaited Promise";
+    if (value instanceof ToolReference)
+        return "a tool reference";
+    if (value instanceof Values.Date)
+        return "a Date";
+    if (value instanceof Values.RegExp)
+        return "a RegExp";
+    if (value instanceof Values.Map)
+        return "a Map";
+    if (value instanceof Values.Set)
+        return "a Set";
+    if (value instanceof Values.URL)
+        return "a URL";
+    if (value instanceof Values.URLSearchParams)
+        return "a URLSearchParams";
+    if (value instanceof CodeModeGenerator)
+        return "a generator";
+    if (isRuntimeReference(value))
+        return "a function";
+    if (typeof value === "object")
+        return "a data object";
+    return `a ${typeof value}`;
+};
 export const typeofValue = (value) => {
     if (value instanceof HostFunction ||
         value instanceof CodeModeFunction ||

package/dist/interpreter/runtime.js

@@ -1,5 +1,5 @@
 import { Cause, Deferred, Effect, Exit } from "effect";
-import { isBlockedMember, ToolRuntimeError, toProgram } from "../data.js";
+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 { caughtErrorValue } from "./errors.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, isRuntimeReference, 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";
@@ -804,14 +804,14 @@ class Frame {
             }
             if (pattern.type === "ObjectPattern") {
                 if (value === null || typeof value !== "object" || isRuntimeReference(value)) {
-                    throw new InterpreterRuntimeError("Object destructuring requires a data object or array value.", pattern, "InvalidDataValue");
+                    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) && !isBlockedMember(key))
+                            if (!consumed.has(key))
                                 rest[key] = item;
                         }
                         copyIteratorSymbols(value, rest, consumed);
@@ -819,9 +819,6 @@ class Frame {
                         continue;
                     }
                     const key = yield* self.destructuringPropertyKey(property);
-                    if (isBlockedMember(String(key))) {
-                        throw new InterpreterRuntimeError(`Property '${String(key)}' is not available.`, property);
-                    }
                     consumed.add(typeof key === "symbol" ? key : String(key));
                     yield* self.declarePattern(property.value, self.destructuringPropertyValue(value, key), mutable, property, initialize);
                 }
@@ -851,7 +848,7 @@ class Frame {
             }
             if (pattern.type === "ObjectPattern") {
                 if (value === null || typeof value !== "object" || isRuntimeReference(value)) {
-                    throw new InterpreterRuntimeError("Object destructuring requires a data object or array value.", pattern, "InvalidDataValue");
+                    throw new InterpreterRuntimeError(`Object destructuring requires a data object or array value, received ${describeValue(value)}.`, pattern, "InvalidDataValue");
                 }
                 const source = value;
                 const consumed = new Set();
@@ -859,7 +856,7 @@ class Frame {
                     if (property.type === "RestElement") {
                         const rest = Object.create(null);
                         for (const [key, item] of Object.entries(source)) {
-                            if (!consumed.has(key) && !isBlockedMember(key))
+                            if (!consumed.has(key))
                                 rest[key] = item;
                         }
                         copyIteratorSymbols(source, rest, consumed);
@@ -867,9 +864,6 @@ class Frame {
                         continue;
                     }
                     const key = yield* self.destructuringPropertyKey(property);
-                    if (isBlockedMember(String(key))) {
-                        throw new InterpreterRuntimeError(`Property '${String(key)}' is not available.`, property);
-                    }
                     consumed.add(typeof key === "symbol" ? key : String(key));
                     yield* self.assignPattern(property.value, self.destructuringPropertyValue(source, key), property);
                 }
@@ -1014,8 +1008,18 @@ class Frame {
             const callee = yield* self.evaluateExpression(node.callee);
             // Globals are built with this interpreter's R; `instanceof` cannot recover the type argument.
             const construct = callee instanceof HostFunction ? callee.construct : undefined;
-            if (construct === undefined)
-                throw unsupportedSyntax("NewExpression", node);
+            if (construct === undefined) {
+                // `new` itself is supported, so a non-constructible callee is a TypeError like JS rather than
+                // unsupported syntax. Built-ins like Number are real constructors in JS, so do not claim
+                // otherwise; say `new` is unsupported for them and point at the plain call.
+                const name = calleeDescription(node.callee);
+                const message = callee instanceof CodeModeFunction
+                    ? `${name} cannot be constructed: user-defined constructors and classes are not supported. Call it as a function that returns a plain object instead.`
+                    : callee instanceof HostFunction
+                        ? `new ${name}(...) is not supported; call ${name}(...) without new instead.`
+                        : `${name} is not a constructor.`;
+                throw new InterpreterRuntimeError(message, node).as("TypeError");
+            }
             const args = yield* self.evaluateCallArguments(node.arguments);
             return yield* construct(args, node);
         });
@@ -1565,13 +1569,10 @@ class Frame {
                     if (spread === null || spread === undefined || Values.isValue(spread))
                         continue;
                     if (typeof spread !== "object" || Array.isArray(spread) || isRuntimeReference(spread)) {
-                        throw new InterpreterRuntimeError("Object spread requires a data object.", property, "InvalidDataValue");
+                        throw new InterpreterRuntimeError(`Object spread requires a data object, received ${describeValue(spread)}.`, property, "InvalidDataValue");
                     }
-                    for (const [key, value] of Object.entries(spread)) {
-                        if (isBlockedMember(key))
-                            throw new InterpreterRuntimeError(`Property '${key}' is not available.`, property);
+                    for (const [key, value] of Object.entries(spread))
                         objectValue[key] = value;
-                    }
                     copyIteratorSymbols(spread, objectValue);
                     continue;
                 }
@@ -1592,9 +1593,6 @@ class Frame {
                 else {
                     throw new InterpreterRuntimeError("Unsupported object property key shape.", keyNode);
                 }
-                if (isBlockedMember(String(key))) {
-                    throw new InterpreterRuntimeError(`Property '${String(key)}' is not available.`, keyNode);
-                }
                 Reflect.set(objectValue, key, yield* self.evaluateExpression(property.value));
             }
             return objectValue;
@@ -1685,9 +1683,6 @@ class Frame {
                 return new ToolReference([...objectValue.path, key]);
             }
             if (objectValue instanceof HostFunction || objectValue instanceof HostNamespace) {
-                if (typeof key === "string" && isBlockedMember(key)) {
-                    throw new InterpreterRuntimeError(`${objectValue.name}.${key} is not available.`, propertyNode);
-                }
                 // Unknown static members read as undefined so feature detection works like native JS.
                 return new ComputedValue(objectValue.member(key, propertyNode));
             }
@@ -1771,14 +1766,11 @@ class Frame {
                 return new ComputedValue(undefined);
             }
             if (isRuntimeReference(objectValue)) {
-                throw new InterpreterRuntimeError("Runtime references are opaque and do not expose properties.", objectNode, "InvalidDataValue");
+                throw new InterpreterRuntimeError(`Cannot read properties of ${describeValue(objectValue)}; only data values expose properties.`, objectNode, "InvalidDataValue");
             }
             if (typeof objectValue !== "object" || objectValue === null) {
                 throw new InterpreterRuntimeError("Cannot access a property on a non-object value.", objectNode);
             }
-            if (typeof key === "string" && isBlockedMember(key)) {
-                throw new InterpreterRuntimeError(`Property '${key}' is not available.`, propertyNode);
-            }
             if (Array.isArray(objectValue)) {
                 if (operation === "delete")
                     return { target: objectValue, key };

package/dist/openapi/spec.js

@@ -1,5 +1,4 @@
 import { fromSchemaOpenApi3_0, fromSchemaOpenApi3_1 } from "effect/JsonSchema";
-import { isBlockedMember } from "../data.js";
 export const methods = new Set(["get", "put", "post", "delete", "options", "head", "patch", "trace"]);
 const parameterLocations = ["path", "query", "header"];
 const ignoredHeaderParameters = new Set(["accept", "content-type", "authorization"]);
@@ -363,8 +362,7 @@ export const operationInput = (document, pathItem, operation) => {
         ok: true,
         value: {
             fields: fields.map((field) => {
-                const visibleName = isBlockedMember(field.name) ? `${field.name}_2` : field.name;
-                const base = conflicts.has(field.name) ? `${field.location}_${visibleName}` : visibleName;
+                const base = conflicts.has(field.name) ? `${field.location}_${field.name}` : field.name;
                 const next = (index) => {
                     const candidate = index === 1 ? base : `${base}_${index}`;
                     return used.has(candidate) ? next(index + 1) : candidate;
@@ -444,11 +442,10 @@ export const operationOutput = (document, operation, definitions) => {
     };
 };
 const sanitizeOperationSegment = (raw) => {
-    const base = raw
+    return (raw
         .replaceAll(/[^A-Za-z0-9_$]+/g, "_")
         .replace(/^_+|_+$/g, "")
-        .replace(/^([0-9])/, "_$1") || "operation";
-    return isBlockedMember(base) ? `${base}_2` : base;
+        .replace(/^([0-9])/, "_$1") || "operation");
 };
 const fallbackOperationId = (method, path) => [
     method,

package/dist/stdlib/array.js

@@ -1,8 +1,8 @@
 import { Effect } from "effect";
 import { HostFunction, sync, syncCall } from "../interpreter/host.js";
 import { CodeModeGenerator, InterpreterRuntimeError } from "../interpreter/model.js";
+import { describeValue } from "../interpreter/references.js";
 import { applyCollectionCallback, preserveConsumerError } from "../interpreter/runner.js";
-import { Values } from "../values.js";
 const constructArray = (args, node) => {
     if (args.length !== 1)
         return [...args];
@@ -16,9 +16,6 @@ const constructArray = (args, node) => {
     return new Array(first);
 };
 const arrayLikeSource = (source, node) => {
-    if (source instanceof Values.Promise) {
-        throw new InterpreterRuntimeError("Array.from received an un-awaited Promise; await it before creating the array.", node, "InvalidDataValue");
-    }
     if (source !== null &&
         typeof source === "object" &&
         (Object.getPrototypeOf(source) === Object.prototype || Object.getPrototypeOf(source) === null) &&
@@ -29,7 +26,7 @@ const arrayLikeSource = (source, node) => {
             throw new RangeError("Invalid array length");
         return { length: normalized, source };
     }
-    throw new InterpreterRuntimeError("Array.from expects an array, string, Map, Set, or array-like value.", node, "InvalidDataValue");
+    throw new InterpreterRuntimeError(`Array.from expects an array, string, Map, Set, or array-like value, received ${describeValue(source)}.`, node, "InvalidDataValue");
 };
 const arrayFrom = (runner, args, node) => {
     const source = args[0];

package/dist/stdlib/collections.js

@@ -1,8 +1,7 @@
 import { Effect } from "effect";
-import { isBlockedMember } from "../data.js";
 import { HostFunction, requiresNew } from "../interpreter/host.js";
 import { InterpreterRuntimeError, isRecord } from "../interpreter/model.js";
-import { isRuntimeReference } from "../interpreter/references.js";
+import { describeValue, isRuntimeReference } from "../interpreter/references.js";
 import { applyCollectionCallback, preserveConsumerError, toPrimitive } from "../interpreter/runner.js";
 import { Values } from "../values.js";
 import { coerceToString } from "./value.js";
@@ -66,7 +65,7 @@ const coerceGroupByPropertyKey = (runner, value, node) => {
     if (value instanceof Values.Promise)
         return Effect.succeed("[object Promise]");
     if (!Values.isValue(value) && isRuntimeReference(value)) {
-        throw new InterpreterRuntimeError("Object.groupBy callback must return a data value.", node, "InvalidDataValue");
+        throw new InterpreterRuntimeError(`Object.groupBy callback must return a data value, received ${describeValue(value)}.`, node, "InvalidDataValue");
     }
     return Effect.map(toPrimitive(runner, value, "string", node), coerceToString);
 };
@@ -109,9 +108,6 @@ export const groupBy = (runner, namespace) => new HostFunction({
                     return result;
                 const item = step.value;
                 const key = yield* preserveConsumerError(cursor, Effect.flatMap(apply([item, index]), (value) => coerceGroupByPropertyKey(runner, value, node)));
-                if (isBlockedMember(key)) {
-                    return yield* preserveConsumerError(cursor, Effect.fail(new InterpreterRuntimeError(`Property '${key}' is not available.`, node)));
-                }
                 const group = result[key];
                 if (group === undefined)
                     result[key] = [item];

package/dist/stdlib/json.d.ts

@@ -1,6 +1,3 @@
-import { Effect } from "effect";
 import { HostNamespace } from "../interpreter/host.js";
 import { type Runner } from "../interpreter/runner.js";
-import { type AstNode } from "../interpreter/model.js";
-export declare const invokeJsonMethod: <R>(runner: Runner<R>, name: "parse" | "stringify", args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
 export declare const jsonGlobal: <R>(runner: Runner<R>) => HostNamespace;

package/dist/stdlib/json.js

@@ -5,9 +5,6 @@ import { InterpreterRuntimeError } from "../interpreter/model.js";
 import { typeofValue } from "../interpreter/references.js";
 import { fromData, toData, toProgram } from "../data.js";
 import { Values } from "../values.js";
-export const invokeJsonMethod = (runner, name, args, node) => {
-    return name === "parse" ? parse(runner, args, node) : stringify(runner, args, node);
-};
 export const jsonGlobal = (runner) => new HostNamespace("JSON", {
     parse: new HostFunction({ name: "JSON.parse", call: (args, node) => parse(runner, args, node) }),
     stringify: new HostFunction({ name: "JSON.stringify", call: (args, node) => stringify(runner, args, node) }),

package/dist/stdlib/object.js

@@ -1,8 +1,8 @@
 import { Effect } from "effect";
-import { isBlockedMember, toProgram } from "../data.js";
+import { toProgram } from "../data.js";
 import { HostFunction, sync, syncCall } from "../interpreter/host.js";
 import { AsyncIteratorSymbol, InterpreterRuntimeError, IteratorSymbol } from "../interpreter/model.js";
-import { containsOpaqueReference, rejectCircularInsertion, typeofValue } from "../interpreter/references.js";
+import { containsOpaqueReference, describeValue, rejectCircularInsertion, typeofValue, } from "../interpreter/references.js";
 import { preserveConsumerError } from "../interpreter/runner.js";
 import { ToolReference } from "../tool-runtime.js";
 import { Values } from "../values.js";
@@ -13,15 +13,9 @@ const requireObject = (name, input, node) => {
         return input;
     if (Values.isValue(input))
         return {};
-    if (input instanceof Values.Promise) {
-        throw new InterpreterRuntimeError(`Object.${name} received an un-awaited Promise; await it before inspecting the result.`, node, "InvalidDataValue");
-    }
-    if (input === null || typeof input !== "object") {
-        throw new InterpreterRuntimeError(`Object.${name} expects a data object or array.`, node, "InvalidDataValue");
-    }
-    const prototype = Object.getPrototypeOf(input);
+    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.`, node, "InvalidDataValue");
+        throw new InterpreterRuntimeError(`Object.${name} expects a data object or array, received ${describeValue(input)}.`, node, "InvalidDataValue");
     }
     return input;
 };
@@ -33,8 +27,6 @@ export const objectAssign = (args, node) => {
     const out = target;
     const seen = new Set();
     const guardedSet = (key, item) => {
-        if (typeof key === "string" && isBlockedMember(key))
-            throw new InterpreterRuntimeError(`Property '${key}' is not available.`, node);
         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");
@@ -82,8 +74,6 @@ const objectFromEntries = (runner, source, node) => {
                 toProgram(entry[0], "Object.fromEntries key");
                 toProgram(entry[1], "Object.fromEntries value");
                 const key = coerceToString(entry[0]);
-                if (isBlockedMember(key))
-                    throw new InterpreterRuntimeError(`Property '${key}' is not available.`, node);
                 out[key] = entry[1];
             }));
         }
@@ -92,7 +82,7 @@ const objectFromEntries = (runner, source, node) => {
 const constructObject = (args, node) => {
     const first = args[0];
     if (first === null || first === undefined)
-        return {};
+        return Object.create(null);
     if (typeof first === "object")
         return first;
     throw new InterpreterRuntimeError(`Object(${typeof first}) wrapper objects are not supported; use the primitive value directly.`, node);

package/dist/stdlib/regexp.js

@@ -1,6 +1,5 @@
 import { sync, syncCall } from "../interpreter/host.js";
 import { InterpreterRuntimeError } from "../interpreter/model.js";
-import { isBlockedMember } from "../data.js";
 import { Values } from "../values.js";
 import { coerceToNumber, coerceToString } from "./value.js";
 export const regexpMethods = new Set(["test", "exec", "toString"]);
@@ -42,8 +41,7 @@ export const matchToValue = (match) => {
     if (match.groups) {
         const groups = Object.create(null);
         for (const [key, group] of Object.entries(match.groups)) {
-            if (!isBlockedMember(key))
-                groups[key] = group;
+            groups[key] = group;
         }
         result.groups = groups;
     }
@@ -118,8 +116,7 @@ const indicesToValue = (indices) => {
     if (indices.groups) {
         const groups = Object.create(null);
         for (const [key, range] of Object.entries(indices.groups)) {
-            if (!isBlockedMember(key))
-                groups[key] = range === undefined ? undefined : [...range];
+            groups[key] = range === undefined ? undefined : [...range];
         }
         result.groups = groups;
         return result;

package/package.json

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