@opencode/codemode 0.0.0-dev-20097 → 0.0.0-dev-20103

package/dist/interpreter/interpreter.js

@@ -9,7 +9,7 @@ import { globals } from "./globals.js";
 import { assign, Callable, define, frozen, get, hostCursor, IteratorObj, has, hidden, hasPrototype, keys, Native, parseArrayIndex, Arr, Fn, GeneratorObj, Obj, PromiseObj, record, remove, set, coerceToNumber, coerceToString, } from "./objects.js";
 import { preserveConsumerError } from "./callback.js";
 import { Pending, resolvePromise, resolvePromiseValue } from "./promises.js";
-import { containsOpaqueReference, describeValue, rejectCircularInsertion, typeofValue } from "./references.js";
+import { describeValue, isOpaque, rejectCircularInsertion, typeofValue } from "./references.js";
 import { ScopeStack } from "./scope.js";
 import { constructRegExp } from "../stdlib/regexp.js";
 import { enumerableSource } from "../stdlib/object.js";
@@ -388,9 +388,6 @@ class Frame {
         const self = this;
         return Effect.gen(function* () {
             const discriminant = yield* self.evaluateExpression(node.discriminant);
-            if (containsOpaqueReference(discriminant)) {
-                throw invalidData("Switch discriminants must be data values.", node);
-            }
             self.scopes.push();
             return yield* Effect.gen(function* () {
                 const cases = node.cases;
@@ -405,11 +402,7 @@ class Frame {
                         defaultIndex = index;
                         continue;
                     }
-                    const candidate = yield* self.evaluateExpression(test);
-                    if (containsOpaqueReference(candidate)) {
-                        throw invalidData("Switch case values must be data values.", test);
-                    }
-                    if (candidate === discriminant) {
+                    if ((yield* self.evaluateExpression(test)) === discriminant) {
                         selected = index;
                         break;
                     }
@@ -1077,16 +1070,19 @@ class Frame {
             return lhs === rhs;
         if (operator === "!==")
             return lhs !== rhs;
-        if (operator === "in" && rhs instanceof Obj && !containsOpaqueReference(lhs)) {
+        if (operator === "==")
+            return this.looselyEqual(lhs, rhs, node);
+        if (operator === "!=")
+            return !this.looselyEqual(lhs, rhs, node);
+        if (operator === "in" && rhs instanceof Obj && !isOpaque(lhs)) {
             return has(rhs, lhs !== null && typeof lhs === "object" ? coerceToString(lhs) : lhs);
         }
-        if (containsOpaqueReference(lhs) || containsOpaqueReference(rhs)) {
+        if (isOpaque(lhs) || isOpaque(rhs)) {
             throw invalidData("Binary operators require data values.", node);
         }
-        // Addition and loose equality use the default hint; every other operator asks for a number.
-        const hint = operator === "+" || operator === "==" || operator === "!=" ? "default" : "number";
+        // Addition uses the default hint; every other operator asks for a number.
+        const hint = operator === "+" ? "default" : "number";
         const coerceOperand = (operand) => (operand instanceof Obj ? operand.toPrimitive(hint) : operand);
-        const bothObjects = lhs !== null && typeof lhs === "object" && rhs !== null && typeof rhs === "object";
         const l = coerceOperand(lhs);
         const r = coerceOperand(rhs);
         switch (operator) {
@@ -1106,10 +1102,6 @@ class Frame {
                 return l % r;
             case "**":
                 return l ** r;
-            case "==":
-                return bothObjects ? lhs === rhs : l == r;
-            case "!=":
-                return bothObjects ? lhs !== rhs : l != r;
             case "<":
                 return l < r;
             case "<=":
@@ -1139,6 +1131,22 @@ class Frame {
                 throw typeError(`Unsupported binary operator '${operator}'.`, node);
         }
     }
+    // IsLooselyEqual: objects (including functions and tool references) compare by identity, and only a
+    // data object facing a non-nullish primitive needs to coerce, so an opaque value is rejected only there.
+    looselyEqual(lhs, rhs, node) {
+        const lhsObject = lhs !== null && typeof lhs === "object";
+        const rhsObject = rhs !== null && typeof rhs === "object";
+        if (lhsObject === rhsObject)
+            return lhsObject ? lhs === rhs : lhs == rhs;
+        const object = lhsObject ? lhs : rhs;
+        const primitive = lhsObject ? rhs : lhs;
+        if (primitive === null || primitive === undefined)
+            return false;
+        if (!(object instanceof Obj) || isOpaque(object)) {
+            throw invalidData("Binary operators require data values.", node);
+        }
+        return object.toPrimitive("default") == primitive;
+    }
     evaluateLogicalExpression(node) {
         const operator = node.operator;
         return Effect.flatMap(this.evaluateExpression(node.left), (left) => {
@@ -1167,7 +1175,7 @@ class Frame {
                 return !value;
             if (operator === "void")
                 return undefined;
-            if (containsOpaqueReference(value)) {
+            if (isOpaque(value)) {
                 throw invalidData("Unary operators require data values.", node);
             }
             const operand = value instanceof Obj ? value.toPrimitive("number") : value;
@@ -1257,7 +1265,7 @@ class Frame {
         // CodeMode numeric coercion, not host Number(): null-prototype data objects would make
         // the host throw during ToPrimitive, and opaque runtime references must reject clearly.
         const operand = (current) => {
-            if (containsOpaqueReference(current)) {
+            if (isOpaque(current)) {
                 throw invalidData(`'${operator}' requires a data value.`, argument);
             }
             return coerceToNumber(current);

package/dist/stdlib/object.js

@@ -118,16 +118,7 @@ export const objectGlobal = (ctx) => {
             (_, args) => new Arr(builtins.Array, entries(enumerableSource(ctx, "Object.entries(...)", args[0])).map((entry) => new Arr(builtins.Array, entry))),
         ],
         ["hasOwn", 2, (_, args) => hasOwn(enumerableSource(ctx, "Object.hasOwn(...)", args[0]), propertyKey(args[1]))],
-        [
-            "is",
-            2,
-            (_, args) => {
-                if (containsOpaqueReference(args[0]) || containsOpaqueReference(args[1])) {
-                    throw invalidData("Object.is requires data values.");
-                }
-                return Object.is(args[0], args[1]);
-            },
-        ],
+        ["is", 2, (_, args) => Object.is(args[0], args[1])],
         ["assign", 2, (_, args) => objectAssign(ctx, args)],
         ["fromEntries", 1, (_, args) => objectFromEntries(ctx, args[0])],
     ]);

package/package.json

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