@opencode/codemode 0.0.0-beta-19419 → 0.0.0-beta-19425

package/dist/interpreter/runtime.d.ts

@@ -10,6 +10,8 @@ export declare class Runtime<R> {
     readonly promises: PromiseRuntime<R>;
     readonly logs: Array<string>;
     readonly runner: Runner<R>;
+    /** Built-in globals by name, unaffected by program shadowing. */
+    readonly builtins: ReadonlyMap<string, unknown>;
     private readonly root;
     constructor(executeTool: (path: ReadonlyArray<string>, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>, search: (args: Array<unknown>) => Effect.Effect<unknown, unknown, R>, toolKeys: (path: ReadonlyArray<string>) => ReadonlyArray<string>, promises: PromiseRuntime<R>, logs?: Array<string>);
     run(program: Program): Effect.Effect<unknown, unknown, R>;

package/dist/interpreter/runtime.js

@@ -16,7 +16,7 @@ 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 { coerceToNumber, coerceToString, compoundOperators } from "../stdlib/value.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) => {
@@ -42,6 +42,34 @@ 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";
+    if (typeof value === "number")
+        return "Number";
+    if (typeof value === "boolean")
+        return "Boolean";
+    if (Array.isArray(value))
+        return "Array";
+    if (value instanceof Values.Date)
+        return "Date";
+    if (value instanceof Values.RegExp)
+        return "RegExp";
+    if (value instanceof Values.Map)
+        return "Map";
+    if (value instanceof Values.Set)
+        return "Set";
+    if (value instanceof Values.URL)
+        return "URL";
+    if (value instanceof Values.URLSearchParams)
+        return "URLSearchParams";
+    if (value instanceof Values.Promise)
+        return "Promise";
+    if (value === null || typeof value !== "object" || isRuntimeReference(value))
+        return undefined;
+    return errorBrandName(value) ?? "Object";
+};
 const instanceofValue = (lhs, rhs, node) => {
     if (rhs instanceof HostFunction && rhs.instanceOf !== undefined)
         return rhs.instanceOf(lhs);
@@ -105,6 +133,8 @@ export class Runtime {
     promises;
     logs;
     runner;
+    /** Built-in globals by name, unaffected by program shadowing. */
+    builtins;
     root;
     constructor(executeTool, search, toolKeys, promises, logs = []) {
         this.executeTool = executeTool;
@@ -121,7 +151,8 @@ export class Runtime {
             settlePromise: (promise) => this.root.settlePromise(promise),
             syncIterator: (value, node) => this.root.syncIterator(value, node),
         };
-        for (const [name, value] of globals(this))
+        this.builtins = new Map(globals(this));
+        for (const [name, value] of this.builtins)
             globalScope.set(name, { mutable: false, value });
     }
     run(program) {
@@ -1686,6 +1717,12 @@ class Frame {
                 // Unknown static members read as undefined so feature detection works like native JS.
                 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)) {
+                const name = constructorName(objectValue);
+                if (name !== undefined)
+                    return new ComputedValue(self.runtime.builtins.get(name));
+            }
             if (typeof objectValue === "string") {
                 if (key === "length")
                     return new ComputedValue(objectValue.length);
@@ -1836,7 +1873,7 @@ class Frame {
     modifyMember(node, compute) {
         const self = this;
         return Effect.gen(function* () {
-            const reference = yield* self.getMemberReference(node);
+            const reference = yield* self.getMemberReference(node, "write");
             if (reference === OptionalShortCircuit ||
                 reference instanceof ComputedValue ||
                 reference === undefined ||

package/package.json

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