@opencode/codemode 2.0.15 → 2.0.17

package/dist/data.d.ts

@@ -1,9 +1,9 @@
 export * as Data from "./data.js";
 import { Effect, type Schema } from "effect";
 import type { Interpreter } from "./interpreter/interpreter.js";
-import { type Value } from "./interpreter/objects.js";
+import { Obj, type Value } from "./interpreter/objects.js";
 export type Json = Schema.Json;
-type Replacer<R> = (args: Array<Value>) => Effect.Effect<Value, unknown, R>;
+type Replacer<R> = (args: Array<Value>, holder: Obj) => Effect.Effect<Value, unknown, R>;
 /**
  * What `JSON.stringify` would serialize for a program value, as host JSON: `toJSON` is honored, functions and
  * `undefined` vanish, non-finite numbers become null, and everything else is copied. Two departures from JS

package/dist/data.js

@@ -28,7 +28,7 @@ const walk = (ctx, value, replacer, boundary) => {
         const settled = raw instanceof PromiseObj ? yield* ctx.await(raw) : raw;
         const toJSON = settled instanceof Obj ? get(settled, "toJSON") : undefined;
         const own = toJSON instanceof Callable ? yield* ctx.call(toJSON, settled, [key]) : settled;
-        const value = replacer === undefined ? own : yield* replacer([key, own]);
+        const value = replacer === undefined ? own : yield* replacer([key, own], holder);
         if (value === undefined || typeofValue(value) === "function")
             return undefined;
         if (typeof value === "number")

package/dist/interpreter/callback.d.ts

@@ -4,14 +4,21 @@ import { Callable, type Cursor, type Value } from "./objects.js";
 /** IteratorClose: a consumer failure closes the iterator and wins over any close failure, except that a generator's
  * return() is a return completion, so a failing close wins over it, as after `break`. */
 export declare const preserveConsumerError: <A, R>(close: Cursor<R>["close"], effect: Effect.Effect<A, unknown, R>) => Effect.Effect<A, unknown, R>;
+export type Hint = "number" | "string" | "default";
 /**
  * ToPrimitive: calls `valueOf`/`toString` in hint order and returns the first primitive result. Dates treat the
- * default hint as "string", like their `Symbol.toPrimitive`.
+ * default hint as "string", like their `Symbol.toPrimitive`. Opaque values (functions, promises, generators, tool
+ * references) pass through unchanged so callers reject or describe them in their built-in form.
  */
-export declare const toPrimitive: <R>(ctx: Interpreter<R>, value: Value, hint: "number" | "string" | "default") => Effect.Effect<Value, unknown, R>;
+export declare const toPrimitive: <R>(ctx: Interpreter<R>, value: Value, hint: Hint) => Effect.Effect<Value, unknown, R>;
 /** Invoke(value, name): calls the method the value would find through its prototype. */
 export declare const invoke: <R>(ctx: Interpreter<R>, value: Value, name: string, label: string) => Effect.Effect<Value, unknown, R>;
 export declare const toPrimitiveString: <R>(ctx: Interpreter<R>, value: Value) => Effect.Effect<string, unknown, R>;
 export declare const toPrimitiveNumber: <R>(ctx: Interpreter<R>, value: Value) => Effect.Effect<number, unknown, R>;
+/**
+ * Runs a native body on its arguments after ToPrimitive, in order, with one hint for all positions or one per
+ * position. Primitive arguments skip the Effect entirely.
+ */
+export declare const withPrimitives: <R>(ctx: Interpreter<R>, hints: Hint | ReadonlyArray<Hint>, values: Array<Value>, body: (primitives: Array<Value>) => Value | Effect.Effect<Value, unknown, R>) => Value | Effect.Effect<Value, unknown, R>;
 export declare const isSupportedCallback: (value: Value) => value is Callable;
-export declare const applyCollectionCallback: <R>(ctx: Interpreter<R>, callback: Value, name: string) => ((args: Array<Value>) => Effect.Effect<Value, unknown, R>);
+export declare const applyCollectionCallback: <R>(ctx: Interpreter<R>, callback: Value, name: string) => ((args: Array<Value>, thisValue?: Value) => Effect.Effect<Value, unknown, R>);

package/dist/interpreter/callback.js

@@ -2,7 +2,7 @@ import { Cause, Effect, Exit } from "effect";
 import { primitivePrototype } from "./intrinsics.js";
 import { GeneratorReturn, typeError } from "./model.js";
 import { Callable, get, Native, DateObj, Obj, coerceToNumber, coerceToString, } from "./objects.js";
-import { typeofValue } from "./references.js";
+import { isOpaque, typeofValue } from "./references.js";
 /** IteratorClose: a consumer failure closes the iterator and wins over any close failure, except that a generator's
  * return() is a return completion, so a failing close wins over it, as after `break`. */
 export const preserveConsumerError = (close, effect) => Effect.flatMap(Effect.exit(effect), (exit) => {
@@ -17,10 +17,11 @@ export const preserveConsumerError = (close, effect) => Effect.flatMap(Effect.ex
 });
 /**
  * ToPrimitive: calls `valueOf`/`toString` in hint order and returns the first primitive result. Dates treat the
- * default hint as "string", like their `Symbol.toPrimitive`.
+ * default hint as "string", like their `Symbol.toPrimitive`. Opaque values (functions, promises, generators, tool
+ * references) pass through unchanged so callers reject or describe them in their built-in form.
  */
 export const toPrimitive = (ctx, value, hint) => {
-    if (!(value instanceof Obj))
+    if (!(value instanceof Obj) || isOpaque(value))
         return Effect.succeed(value);
     const asString = hint === "string" || (hint === "default" && value instanceof DateObj);
     const order = asString ? ["toString", "valueOf"] : ["valueOf", "toString"];
@@ -45,6 +46,18 @@ export const invoke = (ctx, value, name, label) => {
 };
 export const toPrimitiveString = (ctx, value) => Effect.map(toPrimitive(ctx, value, "string"), coerceToString);
 export const toPrimitiveNumber = (ctx, value) => Effect.map(toPrimitive(ctx, value, "number"), coerceToNumber);
+/**
+ * Runs a native body on its arguments after ToPrimitive, in order, with one hint for all positions or one per
+ * position. Primitive arguments skip the Effect entirely.
+ */
+export const withPrimitives = (ctx, hints, values, body) => {
+    if (!values.some((value) => value instanceof Obj))
+        return body(values);
+    return Effect.flatMap(Effect.forEach(values, (value, index) => toPrimitive(ctx, value, typeof hints === "string" ? hints : hints[index])), (primitives) => {
+        const result = body(primitives);
+        return Effect.isEffect(result) ? result : Effect.succeed(result);
+    });
+};
 // The single acceptance list for callbacks: collections, sort, string replacers,
 // Array.from mappers, and promise reactions all admit exactly these callables.
 // Admission means dispatchable, not necessarily invocable: new-requiring
@@ -57,5 +70,5 @@ export const applyCollectionCallback = (ctx, callback, name) => {
         }
         throw typeError(`${name} expects a function callback.`);
     }
-    return (callbackArgs) => ctx.call(callback, undefined, callbackArgs);
+    return (callbackArgs, thisValue) => ctx.call(callback, thisValue, callbackArgs);
 };

package/dist/interpreter/errors.js

@@ -6,6 +6,7 @@ import { containsRuntimeReference } from "./references.js";
 import { createErrorValue, isErrorType } from "./intrinsics.js";
 import { constructor, methods, prototypeFrom, receiver } from "./native.js";
 import { define, get, has, hidden, Arr, ErrorObj, Obj, coerceToString, } from "./objects.js";
+import { toPrimitiveString } from "./callback.js";
 import { formatValue } from "../stdlib/console.js";
 export const normalizeError = (error) => {
     if (error instanceof PendingThrow) {
@@ -109,15 +110,15 @@ export const createAggregateErrorValue = (ctx, errors, message, proto = ctx.buil
     return value;
 };
 const constructAggregateErrorValue = (ctx, args, proto) => Effect.gen(function* () {
+    const message = args[1] === undefined ? "" : yield* toPrimitiveString(ctx, args[1]);
     const cursor = yield* ctx.iterate(args[0]);
     if (cursor === undefined)
         throw typeError("new AggregateError(...) expects a synchronous iterable of errors.");
     const errors = [];
     while (true) {
         const step = yield* cursor.next;
-        if (step.done) {
-            return createAggregateErrorValue(ctx, errors, args[1] === undefined ? "" : coerceToString(args[1]), proto);
-        }
+        if (step.done)
+            return createAggregateErrorValue(ctx, errors, message, proto);
         errors.push(step.value);
     }
 });
@@ -129,7 +130,7 @@ export const errorGlobal = (type, ctx) => {
         const proto = prototypeFrom(newTarget, prototype);
         const created = type === "AggregateError"
             ? constructAggregateErrorValue(ctx, args, proto)
-            : Effect.sync(() => createErrorValue(proto, args[0] === undefined ? undefined : coerceToString(args[0])));
+            : Effect.map(args[0] === undefined ? Effect.undefined : toPrimitiveString(ctx, args[0]), (message) => createErrorValue(proto, message));
         // 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"))
@@ -150,6 +151,9 @@ export const errorGlobal = (type, ctx) => {
             ["toString", 0, (thisValue) => errorToString(receiver(Obj, thisValue, "Error.prototype.toString"))],
         ]);
         methods(builtins, ctor, [["isError", 1, (_, args) => args[0] instanceof ErrorObj]]);
+        return ctor;
     }
+    // Derived constructors extend Error itself, so its statics are inherited. The globals table creates Error first.
+    ctor.proto = get(builtins.Error, "constructor");
     return ctor;
 };

package/dist/interpreter/globals.d.ts

@@ -1,4 +1,4 @@
-import type { Value } from "./objects.js";
+import { type Value } from "./objects.js";
 import type { Interpreter } from "./interpreter.js";
 /** Names bound in every program before extensions apply. */
 export declare const globalNames: ReadonlySet<string>;

package/dist/interpreter/globals.js

@@ -1,7 +1,8 @@
 import { Effect } from "effect";
+import { Arr, Callable, coerceToInteger, coerceToString, get, Obj } from "./objects.js";
 import { arrayGlobal } from "../stdlib/array.js";
 import { textDecoderGlobal, textEncoderGlobal, uint8ArrayGlobal } from "../stdlib/bytes.js";
-import { mapGlobal, setGlobal } from "../stdlib/collections.js";
+import { mapGlobal, setGlobal, weakMapGlobal, weakSetGlobal } from "../stdlib/collections.js";
 import { consoleGlobal } from "../stdlib/console.js";
 import { dateGlobal } from "../stdlib/date.js";
 import { jsonGlobal } from "../stdlib/json.js";
@@ -14,12 +15,13 @@ import { uriGlobal, urlGlobal, urlSearchParamsGlobal } from "../stdlib/url.js";
 import { headersGlobal } from "../stdlib/headers.js";
 import { iteratorGlobals } from "../stdlib/iterator.js";
 import { coercion } from "../stdlib/value.js";
-import { base64Global, cryptoGlobal } from "../stdlib/web.js";
+import { base64Global, cryptoGlobal, structuredCloneGlobal } from "../stdlib/web.js";
 import { ToolReference } from "../tool-runtime.js";
 import { errorGlobal } from "./errors.js";
 import { errorTypes } from "./intrinsics.js";
-import { constants, constructor, native } from "./native.js";
+import { constants, constructor, methods, native, receiver } from "./native.js";
 import { AsyncIteratorSymbol, IteratorSymbol, typeError } from "./model.js";
+import { checkArrayLength } from "./limits.js";
 import { generatorGlobals } from "./generators.js";
 import { promiseGlobal } from "./promises.js";
 // Function.prototype.constructor exists so `fn.constructor === Function` holds; dynamic code is unsupported.
@@ -27,6 +29,24 @@ const functionGlobal = (ctx) => {
     const reject = () => Effect.sync(() => {
         throw typeError("The Function constructor is not supported; write the function inline.");
     });
+    const target = (thisValue, method) => receiver(Callable, thisValue, `Function.prototype.${method}`);
+    methods(ctx.builtins, ctx.builtins.Function, [
+        ["call", 1, (thisValue, args) => ctx.call(target(thisValue, "call"), args[0], args.slice(1))],
+        ["apply", 2, (thisValue, args) => ctx.call(target(thisValue, "apply"), args[0], listFromArrayLike(args[1]))],
+        [
+            "bind",
+            1,
+            (thisValue, args) => {
+                const fn = target(thisValue, "bind");
+                const bound = args.slice(1);
+                return native(ctx.builtins, {
+                    name: `bound ${coerceToString(get(fn, "name"))}`,
+                    length: Math.max(0, fn.length - bound.length),
+                    call: (_, rest) => ctx.call(fn, args[0], [...bound, ...rest]),
+                });
+            },
+        ],
+    ]);
     return constructor(ctx.builtins, ctx.builtins.Function, {
         name: "Function",
         length: 1,
@@ -34,6 +54,18 @@ const functionGlobal = (ctx) => {
         construct: reject,
     });
 };
+// CreateListFromArrayLike: `apply` reads `length` and the indexed properties of any object.
+const listFromArrayLike = (value) => {
+    if (value === undefined || value === null)
+        return [];
+    if (value instanceof Arr)
+        return [...value.items];
+    if (!(value instanceof Obj))
+        throw typeError("Function.prototype.apply expects an array-like argument list.");
+    const length = Math.max(0, coerceToInteger(get(value, "length")));
+    checkArrayLength(length);
+    return Array.from({ length }, (_, index) => get(value, String(index)));
+};
 const symbolGlobal = (ctx) => {
     const symbol = native(ctx.builtins, {
         name: "Symbol",
@@ -72,6 +104,8 @@ const table = {
     RegExp: (ctx) => regexpGlobal(ctx),
     Map: (ctx) => mapGlobal(ctx),
     Set: (ctx) => setGlobal(ctx),
+    WeakMap: (ctx) => weakMapGlobal(ctx),
+    WeakSet: (ctx) => weakSetGlobal(ctx),
     URL: (ctx) => urlGlobal(ctx),
     URLSearchParams: (ctx) => urlSearchParamsGlobal(ctx),
     Headers: (ctx) => headersGlobal(ctx),
@@ -85,6 +119,7 @@ const table = {
     atob: (ctx) => base64Global(ctx, "atob"),
     btoa: (ctx) => base64Global(ctx, "btoa"),
     crypto: (ctx) => cryptoGlobal(ctx),
+    structuredClone: (ctx) => structuredCloneGlobal(ctx),
     ...Object.fromEntries(errorTypes.map((type) => [type, (ctx) => errorGlobal(type, ctx)])),
 };
 /** Names bound in every program before extensions apply. */