@opencode/codemode 2.0.11 → 2.0.13

package/dist/data.d.ts

@@ -1,19 +1,20 @@
 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";
 export type Json = Schema.Json;
-type Replacer<R> = (args: Array<unknown>) => Effect.Effect<unknown, unknown, R>;
+type Replacer<R> = (args: Array<Value>) => 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
  * so a mistake is not a silent `{}`: an Error serializes as `{ name, message, ...own }`, and a promise throws.
  */
-export declare const toJson: <R>(ctx: Interpreter<R>, value: unknown, replacer?: Replacer<R>) => Effect.Effect<Schema.Json | undefined, unknown, R>;
+export declare const toJson: <R>(ctx: Interpreter<R>, value: Value, replacer?: Replacer<R>) => Effect.Effect<Schema.Json | undefined, unknown, R>;
 /**
  * The host boundary: `toJson`, plus what a program most likely meant when a value cannot be JSON. A promise is
  * awaited, a Set crosses as an array, a URLSearchParams as its query string, a Uint8Array asks to be encoded as
  * text first, and a `__proto__` key is dropped so host code can never receive one.
  */
-export declare const toBoundary: <R>(ctx: Interpreter<R>, value: unknown) => Effect.Effect<Schema.Json | undefined, unknown, R>;
+export declare const toBoundary: <R>(ctx: Interpreter<R>, value: Value) => Effect.Effect<Schema.Json | undefined, unknown, R>;
 /** Host JSON as program values: objects and arrays are copied, primitives pass through. */
-export declare const fromJson: <R>(ctx: Interpreter<R>, value: unknown) => unknown;
+export declare const fromJson: <R>(ctx: Interpreter<R>, value: Json | undefined) => Value;

package/dist/interpreter/callback.d.ts

@@ -1,20 +1,17 @@
 import { Effect } from "effect";
 import type { Interpreter } from "./interpreter.js";
-import { Callable } from "./objects.js";
-export type IteratorCursor<R> = {
-    readonly next: Effect.Effect<{
-        readonly done: boolean;
-        readonly value: unknown;
-    }, unknown, R>;
-    readonly close: Effect.Effect<void, unknown, R>;
-};
-export declare const preserveConsumerError: <A, R>(cursor: IteratorCursor<R>, effect: Effect.Effect<A, unknown, R>) => Effect.Effect<A, unknown, R>;
+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>;
 /**
  * ToPrimitive: calls `valueOf`/`toString` in hint order and returns the first primitive result. Dates treat the
  * default hint as "string", like their `Symbol.toPrimitive`.
  */
-export declare const toPrimitive: <R>(ctx: Interpreter<R>, value: unknown, hint: "number" | "string" | "default") => Effect.Effect<unknown, unknown, R>;
-export declare const toPrimitiveString: <R>(ctx: Interpreter<R>, value: unknown) => Effect.Effect<string, unknown, R>;
-export declare const toPrimitiveNumber: <R>(ctx: Interpreter<R>, value: unknown) => Effect.Effect<number, unknown, R>;
-export declare const isSupportedCallback: (value: unknown) => value is Callable;
-export declare const applyCollectionCallback: <R>(ctx: Interpreter<R>, callback: unknown, name: string) => ((args: Array<unknown>) => Effect.Effect<unknown, unknown, R>);
+export declare const toPrimitive: <R>(ctx: Interpreter<R>, value: Value, hint: "number" | "string" | "default") => 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>;
+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>);

package/dist/interpreter/callback.js

@@ -1,11 +1,20 @@
-import { Effect, Exit } from "effect";
-import { coerceToNumber, coerceToString } from "../stdlib/value.js";
-import { typeError } from "./model.js";
-import { Callable, get, Native, DateObj, Obj } from "./objects.js";
+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";
-export const preserveConsumerError = (cursor, effect) => Effect.flatMap(Effect.exit(effect), (exit) => Exit.isSuccess(exit)
-    ? Effect.succeed(exit.value)
-    : Effect.andThen(Effect.exit(cursor.close), Effect.failCause(exit.cause)));
+/** 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) => {
+    if (Exit.isSuccess(exit))
+        return Effect.succeed(exit.value);
+    return Effect.flatMap(Effect.exit(close), (closed) => {
+        if (!Exit.isSuccess(closed) && Cause.squash(exit.cause) instanceof GeneratorReturn) {
+            return Effect.failCause(closed.cause);
+        }
+        return Effect.failCause(exit.cause);
+    });
+});
 /**
  * ToPrimitive: calls `valueOf`/`toString` in hint order and returns the first primitive result. Dates treat the
  * default hint as "string", like their `Symbol.toPrimitive`.
@@ -27,6 +36,13 @@ export const toPrimitive = (ctx, value, hint) => {
         throw typeError("Cannot convert object to primitive value.");
     });
 };
+/** Invoke(value, name): calls the method the value would find through its prototype. */
+export const invoke = (ctx, value, name, label) => {
+    const target = value instanceof Obj ? value : primitivePrototype(ctx.builtins, value);
+    if (target === undefined)
+        throw typeError(`${label} called on null or undefined.`);
+    return ctx.call(get(target, name), value, []);
+};
 export const toPrimitiveString = (ctx, value) => Effect.map(toPrimitive(ctx, value, "string"), coerceToString);
 export const toPrimitiveNumber = (ctx, value) => Effect.map(toPrimitive(ctx, value, "number"), coerceToNumber);
 // The single acceptance list for callbacks: collections, sort, string replacers,

package/dist/interpreter/errors.d.ts

@@ -1,7 +1,7 @@
 import type { Diagnostic } from "../codemode.js";
 import { type AstNode } from "./model.js";
 import { type ErrorType } from "./intrinsics.js";
-import { type Native, ErrorObj, Obj } from "./objects.js";
+import { type Native, ErrorObj, Obj, type Value } from "./objects.js";
 import type { Interpreter } from "./interpreter.js";
 export declare const normalizeError: (error: unknown) => Diagnostic;
 /**
@@ -10,7 +10,7 @@ export declare const normalizeError: (error: unknown) => Diagnostic;
  */
 export declare const locate: (error: unknown, node?: AstNode) => unknown;
 /** The program value a handler receives for a failure; one failure always yields the same value. */
-export declare const materialize: <R>(ctx: Interpreter<R>, thrown: unknown) => unknown;
-export declare const createAggregateErrorValue: <R>(ctx: Interpreter<R>, errors: Array<unknown>, message: string, proto?: Obj) => ErrorObj;
+export declare const materialize: <R>(ctx: Interpreter<R>, thrown: unknown) => Value;
+export declare const createAggregateErrorValue: <R>(ctx: Interpreter<R>, errors: Array<Value>, message: string, proto?: Obj) => ErrorObj;
 /** An error constructor such as `Error` or `TypeError`; callable with or without `new`, like JS. */
 export declare const errorGlobal: <R>(type: ErrorType, ctx: Interpreter<R>) => Native<R>;

package/dist/interpreter/errors.js

@@ -5,9 +5,8 @@ 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, has, hidden, Arr, ErrorObj, Obj } from "./objects.js";
+import { define, get, has, hidden, Arr, ErrorObj, Obj, coerceToString, } from "./objects.js";
 import { formatValue } from "../stdlib/console.js";
-import { coerceToString } from "../stdlib/value.js";
 export const normalizeError = (error) => {
     if (error instanceof PendingThrow) {
         return {
@@ -150,6 +149,7 @@ export const errorGlobal = (type, ctx) => {
         methods(builtins, prototype, [
             ["toString", 0, (thisValue) => errorToString(receiver(Obj, thisValue, "Error.prototype.toString"))],
         ]);
+        methods(builtins, ctor, [["isError", 1, (_, args) => args[0] instanceof ErrorObj]]);
     }
     return ctor;
 };

package/dist/interpreter/execute.d.ts

@@ -1,5 +1,6 @@
 import { Effect } from "effect";
 import type { ResolvedExecutionLimits, Result } from "../codemode.js";
 import { ToolRuntime } from "../tool-runtime.js";
+import type { Value } from "./objects.js";
 import { Interpreter } from "./interpreter.js";
-export declare const executeProgram: <R>(code: string, prepared: ToolRuntime.Prepared<R>, limits: ResolvedExecutionLimits, hooks: ToolRuntime.Hooks<R>, globals?: (ctx: Interpreter<R>) => ReadonlyArray<readonly [string, unknown]>) => Effect.Effect<Result, never, R>;
+export declare const executeProgram: <R>(code: string, prepared: ToolRuntime.Prepared<R>, limits: ResolvedExecutionLimits, hooks: ToolRuntime.Hooks<R>, globals?: (ctx: Interpreter<R>) => ReadonlyArray<readonly [string, Value]>) => Effect.Effect<Result, never, R>;

package/dist/interpreter/extensions.d.ts

@@ -1,8 +1,9 @@
 import type { Extension } from "../extension.js";
 import type { Interpreter } from "./interpreter.js";
+import { type Value } from "./objects.js";
 /**
  * The global bindings of one run's extensions. Everything crossing the boundary is converted: plain data and
  * built-in wrappers are copied, a host function becomes a program function whose calls cross the same way, and a
  * host Promise becomes a program promise.
  */
-export declare const extensionGlobals: <R>(ctx: Interpreter<R>, extensions: ReadonlyArray<Extension>) => ReadonlyArray<readonly [string, unknown]>;
+export declare const extensionGlobals: <R>(ctx: Interpreter<R>, extensions: ReadonlyArray<Extension>) => ReadonlyArray<readonly [string, Value]>;

package/dist/interpreter/extensions.js

@@ -1,12 +1,11 @@
 import { Effect } from "effect";
-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 { PendingThrow, Throw, typeError } from "./model.js";
 import { fn } from "./native.js";
-import { Callable, define, entries, get, has, hidden, keys, Arr, Bytes, DateObj, ErrorObj, GeneratorObj, IteratorObj, MapObj, Obj, PromiseObj, RegExpObj, SetObj, URLObj, URLSearchParamsObj, HeadersObj, } from "./objects.js";
-import { describeValue } from "./references.js";
+import { define, get, has, hidden, keys, Arr, Bytes, DateObj, ErrorObj, HeadersObj, MapObj, Obj, RegExpObj, SetObj, URLObj, URLSearchParamsObj, coerceToString, } from "./objects.js";
+import { describeValue, isOpaque } from "./references.js";
 /**
  * The global bindings of one run's extensions. Everything crossing the boundary is converted: plain data and
  * built-in wrappers are copied, a host function becomes a program function whose calls cross the same way, and a
@@ -17,38 +16,15 @@ export const extensionGlobals = (ctx, extensions) => {
     const toHost = (value, label, depth = 0, seen = new Set()) => {
         if (depth > MAX_VALUE_DEPTH)
             throw typeError(`${label} exceeds the maximum value depth of ${MAX_VALUE_DEPTH}.`);
-        if (value === null || typeof value !== "object") {
-            if (isPrimitive(value))
-                return value;
-            throw typeError(`${label} contains ${describeValue(value)}, which cannot be passed to an extension.`);
-        }
-        if (value instanceof Bytes)
-            return new Uint8Array(value.bytes);
-        if (value instanceof DateObj)
-            return new Date(value.time);
-        if (value instanceof RegExpObj)
-            return new RegExp(value.regex.source, value.regex.flags);
-        if (value instanceof URLObj)
-            return new URL(value.url.href);
-        if (value instanceof URLSearchParamsObj)
-            return new URLSearchParams(value.params);
-        if (value instanceof HeadersObj)
-            return new Headers(value.headers);
-        const next = (item) => toHost(item, label, depth + 1, seen);
-        if (value instanceof MapObj)
-            return new Map([...value.map].map(([key, item]) => [next(key), next(item)]));
-        if (value instanceof SetObj)
-            return new Set([...value.set].map(next));
-        if (!(value instanceof Obj) ||
-            value instanceof Callable ||
-            value instanceof GeneratorObj ||
-            value instanceof IteratorObj ||
-            value instanceof PromiseObj) {
+        if (isPrimitive(value))
+            return value;
+        if (!(value instanceof Obj) || isOpaque(value)) {
             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);
+        const next = (item) => toHost(item, label, depth + 1, seen);
         if (value instanceof ErrorObj) {
             const name = coerceToString(get(value, "name"));
             const message = get(value, "message");
@@ -70,11 +46,7 @@ export const extensionGlobals = (ctx, extensions) => {
             seen.delete(value);
             return copied;
         }
-        const copied = value instanceof Arr
-            ? value.items.map(next)
-            : Object.fromEntries(entries(value)
-                .filter(([key]) => key !== "__proto__")
-                .map(([key, item]) => [key, next(item)]));
+        const copied = value.toHost(next);
         seen.delete(value);
         return copied;
     };

package/dist/interpreter/globals.d.ts

@@ -1,5 +1,6 @@
+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>;
 /** The immutable global bindings of every program, in declaration order. */
-export declare const globals: <R>(ctx: Interpreter<R>) => ReadonlyArray<readonly [string, unknown]>;
+export declare const globals: <R>(ctx: Interpreter<R>) => ReadonlyArray<readonly [string, Value]>;

package/dist/interpreter/globals.js

@@ -60,6 +60,7 @@ const table = {
     console: (ctx) => consoleGlobal(ctx),
     Promise: (ctx) => promiseGlobal(ctx),
     Symbol: (ctx) => symbolGlobal(ctx),
+    Iterator: (ctx) => iteratorGlobals(ctx),
     Number: (ctx) => numberGlobal(ctx),
     String: (ctx) => stringGlobal(ctx),
     Boolean: (ctx) => booleanGlobal(ctx),
@@ -91,6 +92,5 @@ export const globalNames = new Set(Object.keys(table));
 /** The immutable global bindings of every program, in declaration order. */
 export const globals = (ctx) => {
     generatorGlobals(ctx);
-    iteratorGlobals(ctx);
     return Object.entries(table).map(([name, factory]) => [name, factory(ctx)]);
 };

package/dist/interpreter/interpreter.d.ts

@@ -2,8 +2,8 @@ import type { Program } from "acorn";
 import { Effect } from "effect";
 import { type Json } from "../data.js";
 import { type ToolRuntime } from "../tool-runtime.js";
-import type { Builtins } from "./intrinsics.js";
-import { PromiseObj } from "./objects.js";
+import { type Builtins } from "./intrinsics.js";
+import { type Cursor, PromiseObj, type Value } from "./objects.js";
 import { Pending } from "./promises.js";
 /** One program execution: the tool bridge, promise scheduler, captured logs, and the global scope built once. */
 export declare class Interpreter<R> {
@@ -17,24 +17,13 @@ export declare class Interpreter<R> {
         readonly pending: Pending<R>;
         readonly builtins: Builtins;
         readonly logs?: Array<string>;
-        readonly globals?: (ctx: Interpreter<R>) => ReadonlyArray<readonly [string, unknown]>;
+        readonly globals?: (ctx: Interpreter<R>) => ReadonlyArray<readonly [string, Value]>;
     });
-    run(program: Program): Effect.Effect<unknown, unknown, R>;
-    call(callable: unknown, thisValue: unknown, args: Array<unknown>): Effect.Effect<unknown, unknown, R>;
-    await(promise: PromiseObj): Effect.Effect<unknown, unknown, never>;
-    iterate(value: unknown): Effect.Effect<{
-        next: Effect.Effect<{
-            done: boolean;
-            value: any;
-        }, never, never>;
-        close: Effect.Effect<void, never, never>;
-    }, never, never> | Effect.Effect<{
-        next: Effect.Effect<{
-            done: boolean;
-            value: unknown;
-        }, unknown, R>;
-        close: Effect.Effect<void, unknown, R>;
-    } | undefined, unknown, R>;
+    run(program: Program): Effect.Effect<Value, unknown, R>;
+    call(callable: Value, thisValue: Value, args: Array<Value>): Effect.Effect<Value, unknown, R>;
+    await(promise: PromiseObj): Effect.Effect<Value, unknown, never>;
+    iterate(value: Value): Effect.Effect<Cursor<R> | undefined, unknown, R>;
+    iterateDirect(value: Value): Cursor<R>;
     /** Runs one host tool: arguments cross as JSON and the result comes back as program values. */
-    tool(run: (args: Array<Json | undefined>) => Effect.Effect<Json | undefined, unknown, R>, args: Array<unknown>): Effect.Effect<unknown, unknown, R>;
+    tool(run: (args: Array<Json | undefined>) => Effect.Effect<Json | undefined, unknown, R>, args: Array<Value>): Effect.Effect<Value, unknown, R>;
 }