@opencode/codemode 2.0.5 → 2.0.6

package/dist/interpreter/errors.js

@@ -5,7 +5,7 @@ import { formatLocation, PendingThrow, Throw, sourceLocation, typeError } from "
 import { containsRuntimeReference } from "./references.js";
 import { createErrorValue, isErrorType } from "./intrinsics.js";
 import { constructor, methods, prototypeFrom, receiver } from "./native.js";
-import { define, get, hidden, Arr, ErrorObj, Obj } from "./objects.js";
+import { define, get, has, hidden, Arr, ErrorObj, Obj } from "./objects.js";
 import { formatValue } from "../stdlib/console.js";
 import { coerceToString } from "../stdlib/value.js";
 export const normalizeError = (error) => {
@@ -128,9 +128,17 @@ export const errorGlobal = (type, ctx) => {
     const prototype = builtins[type];
     const construct = (args, newTarget) => {
         const proto = prototypeFrom(newTarget, prototype);
-        return type === "AggregateError"
+        const created = type === "AggregateError"
             ? constructAggregateErrorValue(ctx, args, proto)
             : Effect.sync(() => createErrorValue(proto, args[0] === undefined ? undefined : coerceToString(args[0])));
+        // ES2022 `new Error(message, { cause })`: installed only when the options object has the property at all.
+        const options = args[type === "AggregateError" ? 2 : 1];
+        if (!(options instanceof Obj) || !has(options, "cause"))
+            return created;
+        return Effect.map(created, (value) => {
+            define(value, "cause", get(options, "cause"), hidden);
+            return value;
+        });
     };
     const ctor = constructor(builtins, prototype, {
         name: type,

package/dist/interpreter/extensions.js

@@ -3,9 +3,9 @@ import { coerceToString } from "../stdlib/value.js";
 import { hooked } from "../tool-runtime.js";
 import { createErrorValue, isErrorType } from "./intrinsics.js";
 import { MAX_VALUE_DEPTH } from "./limits.js";
-import { Throw, typeError } from "./model.js";
+import { PendingThrow, Throw, typeError } from "./model.js";
 import { fn } from "./native.js";
-import { Callable, define, entries, get, Arr, Bytes, DateObj, ErrorObj, GeneratorObj, MapObj, Obj, PromiseObj, RegExpObj, SetObj, URLObj, URLSearchParamsObj, } from "./objects.js";
+import { Callable, define, entries, get, has, hidden, keys, Arr, Bytes, DateObj, ErrorObj, GeneratorObj, MapObj, Obj, PromiseObj, RegExpObj, SetObj, URLObj, URLSearchParamsObj, } from "./objects.js";
 import { describeValue } from "./references.js";
 /**
  * The global bindings of one run's extensions. Everything crossing the boundary is converted: plain data and
@@ -43,15 +43,30 @@ export const extensionGlobals = (ctx, extensions) => {
             value instanceof PromiseObj) {
             throw typeError(`${label} contains ${describeValue(value)}, which cannot be passed to an extension.`);
         }
+        if (seen.has(value))
+            throw typeError(`${label} contains a circular value.`);
+        seen.add(value);
         if (value instanceof ErrorObj) {
             const name = coerceToString(get(value, "name"));
             const message = get(value, "message");
             const text = message === undefined ? "" : coerceToString(message);
-            return name === "AggregateError" ? new AggregateError([], text) : new (hostErrors.get(name) ?? Error)(text);
+            const copied = name === "AggregateError" ? new AggregateError([], text) : new (hostErrors.get(name) ?? Error)(text);
+            for (const key of new Set(["cause", ...keys(value)])) {
+                if (uncrossed.has(key) || !has(value, key))
+                    continue;
+                const item = crossing(() => next(get(value, key)));
+                if (item === left)
+                    continue;
+                Object.defineProperty(copied, key, {
+                    value: item,
+                    writable: true,
+                    configurable: true,
+                    enumerable: key !== "cause",
+                });
+            }
+            seen.delete(value);
+            return copied;
         }
-        if (seen.has(value))
-            throw typeError(`${label} contains a circular value.`);
-        seen.add(value);
         const copied = value instanceof Arr
             ? value.items.map(next)
             : Object.fromEntries(entries(value)
@@ -68,6 +83,7 @@ export const extensionGlobals = (ctx, extensions) => {
         if (typeof value === "function")
             return wrap(value, label);
         if (value !== null && typeof value === "object") {
+            const next = (item, path) => fromHost(item, path, depth + 1, seen);
             if (value instanceof Date)
                 return new DateObj(builtins.Date, value.getTime());
             if (value instanceof RegExp)
@@ -77,14 +93,27 @@ export const extensionGlobals = (ctx, extensions) => {
             if (value instanceof ArrayBuffer)
                 return new Bytes(builtins.Uint8Array, new Uint8Array(value.slice(0)));
             if (value instanceof Error) {
-                return createErrorValue(builtins[isErrorType(value.name) ? value.name : "Error"], value.message);
+                if (seen.has(value))
+                    throw typeError(`${label} produced a circular value.`);
+                seen.add(value);
+                const copied = createErrorValue(builtins[isErrorType(value.name) ? value.name : "Error"], value.message);
+                const fields = value;
+                for (const key of new Set(["cause", ...Object.keys(value)])) {
+                    if (uncrossed.has(key) || !(key in value) || typeof fields[key] === "function")
+                        continue;
+                    const item = crossing(() => next(fields[key], `${label}.${key}`));
+                    if (item === left)
+                        continue;
+                    define(copied, key, item, key === "cause" ? hidden : undefined);
+                }
+                seen.delete(value);
+                return copied;
             }
             if (value instanceof URL)
                 return new URLObj(builtins.URL, builtins.URLSearchParams, new URL(value.href));
             if (value instanceof URLSearchParams) {
                 return new URLSearchParamsObj(builtins.URLSearchParams, new URLSearchParams(value));
             }
-            const next = (item, path) => fromHost(item, path, depth + 1, seen);
             if (value instanceof Map) {
                 const wrapped = new MapObj(builtins.Map);
                 for (const [key, item] of value)
@@ -138,6 +167,23 @@ export const extensionGlobals = (ctx, extensions) => {
     });
     return extensions.flatMap((extension) => Object.entries(extension.globals).map(([name, value]) => [name, wrap(value, name, (args) => ({ extension: extension.name, name, args }))]));
 };
+/**
+ * An error crosses as its name, message, `cause`, and own enumerable fields, such as Node's `code`, `errno`,
+ * `syscall`, and `path`. `stack` stays on its own side, and no field may shadow an Error method. A field that cannot
+ * cross (a socket, a handle, a function) is left behind so the error itself always arrives.
+ */
+const uncrossed = new Set(["stack", "constructor", "toString", "__proto__"]);
+const left = Symbol("left behind");
+const crossing = (convert) => {
+    try {
+        return convert();
+    }
+    catch (reason) {
+        if (reason instanceof PendingThrow)
+            return left;
+        throw reason;
+    }
+};
 const hostErrors = new Map([
     ["TypeError", TypeError],
     ["RangeError", RangeError],

package/package.json

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