@opencode/codemode 0.0.0-dev-19406 → 0.0.0-dev-19411

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/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";
@@ -811,7 +811,7 @@ class Frame {
                     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);
                 }
@@ -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);
                 }
@@ -1577,11 +1571,8 @@ class Frame {
                     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)) {
-                        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;
                 }
@@ -1602,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;
@@ -1695,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));
             }
@@ -1786,9 +1771,6 @@ class Frame {
             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/collections.js

@@ -1,5 +1,4 @@
 import { Effect } from "effect";
-import { isBlockedMember } from "../data.js";
 import { HostFunction, requiresNew } from "../interpreter/host.js";
 import { InterpreterRuntimeError, isRecord } from "../interpreter/model.js";
 import { describeValue, isRuntimeReference } from "../interpreter/references.js";
@@ -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,5 +1,5 @@
 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, describeValue, rejectCircularInsertion, typeofValue, } from "../interpreter/references.js";
@@ -27,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");
@@ -76,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];
             }));
         }
@@ -86,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-dev-19406",
+  "version": "0.0.0-dev-19411",
   "description": "Effect-native confined code execution over schema-described tools",
   "type": "module",
   "license": "MIT",