@opencode/codemode 2.0.12 → 2.0.14

package/dist/interpreter/objects.d.ts

@@ -1,5 +1,7 @@
 import type { BlockStatement, Expression, Pattern } from "acorn";
-import type { Effect, Fiber } from "effect";
+import { Effect, type Fiber } from "effect";
+import { ToolReference } from "../tool-runtime.js";
+import type { Builtins } from "./intrinsics.js";
 import { type Binding, type GeneratorRequestKind, type PendingThrow } from "./model.js";
 /** Property attributes, as in a JS property descriptor. */
 export type Attributes = {
@@ -7,11 +9,11 @@ export type Attributes = {
     readonly enumerable: boolean;
     readonly configurable: boolean;
 };
-export type Getter = (receiver: unknown) => unknown;
-export type Setter = (receiver: unknown, value: unknown) => void;
+export type Getter = (receiver: Value) => Value;
+export type Setter = (receiver: Value, value: Value) => void;
 /** One own property: a data slot or a native accessor pair. */
 export type Slot = {
-    value: unknown;
+    value: Value;
     writable: boolean;
     enumerable: boolean;
     configurable: boolean;
@@ -29,34 +31,69 @@ export declare const hidden: Attributes;
 export declare const readonly: Attributes;
 /** Constants such as `Math.PI` and a constructor's `prototype`. */
 export declare const frozen: Attributes;
-/** An object owned by the program: own properties plus a prototype link. */
+/**
+ * An object owned by the program: own properties plus a prototype link. Subclasses answer, in one place, how a
+ * built-in kind of object prints, coerces, iterates, and crosses to the host.
+ */
 export declare class Obj {
     proto: Obj | null;
     readonly props: Map<string | symbol, Slot>;
     constructor(proto: Obj | null);
+    /** The class name `Object.prototype.toString` reports: `[object Map]`. */
+    readonly tag: string;
+    /** How diagnostics refer to a value of this kind. */
+    get describe(): string;
+    /** ToString without consulting program-defined methods. */
+    toString(): string;
+    /** ToPrimitive without consulting program-defined methods: only a Date answers a number hint differently. */
+    toPrimitive(hint: "default" | "number" | "string"): string | number;
+    /** ToNumber without consulting program-defined methods. */
+    toNumber(): number;
+    /** How `console.log` shows the value; `item` formats a child with cycle and depth tracking. */
+    inspect(item: (value: Value) => string): string;
+    /** A copy the host can hold; `item` converts a child. A `__proto__` key never reaches host code. */
+    toHost(item: (value: Value) => unknown): unknown;
+    /** The built-in iteration `for...of` and spread use, when this kind of object has one. */
+    iterator(builtins: Builtins): Iterator<Value, undefined> | undefined;
 }
 export declare class Arr extends Obj {
-    readonly items: Array<unknown>;
-    constructor(proto: Obj, items?: Array<unknown>);
+    readonly items: Array<Value>;
+    readonly tag = "Array";
+    constructor(proto: Obj, items?: Array<Value>);
+    get describe(): string;
+    toString(): string;
+    inspect(item: (value: Value) => string): string;
+    toHost(item: (value: Value) => unknown): unknown[];
+    iterator(): ArrayIterator<Value>;
 }
 /** An object with the [[ErrorData]] slot: what `Error.prototype.toString` and the host boundary recognize as an error. */
 export declare class ErrorObj extends Obj {
+    readonly tag = "Error";
     /** The interpreter failure this error materialized from, so rethrowing it keeps the diagnostic kind and location. */
     host?: PendingThrow;
+    /** Error.prototype.toString: "name: message", or just one when the other is empty. */
+    toString(): string;
+    inspect(): string;
 }
-export declare abstract class Callable extends Obj {
+/** Interpreter machinery a program can hold but never inspect, serialize, or hand to the host. */
+export declare abstract class Opaque extends Obj {
+    inspect(): string;
+}
+export declare abstract class Callable extends Opaque {
+    readonly tag = "Function";
     constructor(proto: Obj, name: string, length: number);
+    get describe(): string;
 }
 export declare class Fn extends Callable {
     readonly parameters: ReadonlyArray<Pattern>;
     readonly body: BlockStatement | Expression;
-    readonly capturedScopes: ReadonlyArray<Map<string, Binding>>;
+    readonly capturedScopes: Array<Map<string, Binding>>;
     readonly async: boolean;
     readonly generator: boolean;
-    constructor(proto: Obj, name: string, parameters: ReadonlyArray<Pattern>, body: BlockStatement | Expression, capturedScopes: ReadonlyArray<Map<string, Binding>>, async: boolean, generator: boolean);
+    constructor(proto: Obj, name: string, parameters: ReadonlyArray<Pattern>, body: BlockStatement | Expression, capturedScopes: Array<Map<string, Binding>>, async: boolean, generator: boolean);
 }
-export type NativeCall<R> = (thisValue: unknown, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>;
-export type NativeConstruct<R> = (args: Array<unknown>, newTarget: Callable) => Effect.Effect<unknown, unknown, R>;
+export type NativeCall<R> = (thisValue: Value, args: Array<Value>) => Effect.Effect<Value, unknown, R>;
+export type NativeConstruct<R> = (args: Array<Value>, newTarget: Callable) => Effect.Effect<Value, unknown, R>;
 export type NativeOptions<R> = {
     readonly name: string;
     readonly length?: number;
@@ -72,67 +109,131 @@ export declare class Native<R = never> extends Callable {
     readonly callback: boolean;
     constructor(proto: Obj, options: NativeOptions<R>);
 }
-export declare class PromiseObj extends Obj {
-    readonly fiber: Fiber.Fiber<unknown, unknown>;
-    constructor(proto: Obj, fiber: Fiber.Fiber<unknown, unknown>);
+export declare class PromiseObj extends Opaque {
+    readonly fiber: Fiber.Fiber<Value, unknown>;
+    readonly tag = "Promise";
+    constructor(proto: Obj, fiber: Fiber.Fiber<Value, unknown>);
+    get describe(): string;
+    inspect(): string;
 }
-export declare class GeneratorObj extends Obj {
+export declare class GeneratorObj extends Opaque {
     readonly asynchronous: boolean;
-    readonly request: (kind: GeneratorRequestKind, value: unknown) => Effect.Effect<unknown, unknown, unknown>;
-    constructor(proto: Obj, asynchronous: boolean, request: (kind: GeneratorRequestKind, value: unknown) => Effect.Effect<unknown, unknown, unknown>);
-}
-/** A built-in collection iterator: live over the host collection, yielding program values. */
-export declare class IteratorObj extends Obj {
-    readonly iterator: IteratorObject<unknown>;
-    constructor(proto: Obj, iterator: IteratorObject<unknown>);
-}
-export declare class DateObj extends Obj {
+    readonly request: (kind: GeneratorRequestKind, value: Value) => Effect.Effect<Value, unknown, unknown>;
+    readonly tag = "Generator";
+    constructor(proto: Obj, asynchronous: boolean, request: (kind: GeneratorRequestKind, value: Value) => Effect.Effect<Value, unknown, unknown>);
+    get describe(): string;
+}
+/** One pull from an iterator, as `for...of` sees it. */
+export type Step = {
+    readonly done: boolean;
+    readonly value: Value;
+};
+/** How the interpreter drives any iterator: pull the next step, or close it early. */
+export type Cursor<R = unknown> = {
+    readonly next: Effect.Effect<Step, unknown, R>;
+    readonly close: Effect.Effect<void, unknown, R>;
+};
+/** A cursor over a host iterator; there is nothing to close. */
+export declare const hostCursor: (iterator: Iterator<Value, undefined>) => Cursor<never>;
+/** A built-in iterator: a live cursor over a host collection or an iterator helper, yielding program values. */
+export declare class IteratorObj extends Opaque {
+    readonly cursor: Cursor;
+    readonly tag = "Iterator";
+    constructor(proto: Obj, cursor: Cursor);
+    get describe(): string;
+}
+/** A built-in iterator over a host iterator, e.g. `array.values()`. */
+export declare const hostIterator: (builtins: Builtins, iterator: Iterator<Value, undefined>) => IteratorObj;
+/** A built-in object around a host value: data-like, so it prints as itself and crosses to extensions as a copy. */
+export declare abstract class Wrapper extends Obj {
+    inspect(item: (value: Value) => string): string;
+}
+export declare class DateObj extends Wrapper {
     time: number;
+    readonly tag = "Date";
     constructor(proto: Obj, time: number);
+    toString(): string;
+    toPrimitive(hint: "default" | "number" | "string"): string | number;
+    toHost(): Date;
 }
-export declare class RegExpObj extends Obj {
+export declare class RegExpObj extends Wrapper {
+    readonly tag = "RegExp";
     readonly regex: RegExp;
     constructor(proto: Obj, pattern: string, flags: string);
-}
-export declare class MapObj extends Obj {
-    readonly map: Map<unknown, unknown>;
-}
-export declare class SetObj extends Obj {
-    readonly set: Set<unknown>;
-}
-export declare class URLSearchParamsObj extends Obj {
+    toString(): string;
+    toHost(): RegExp;
+}
+export declare class MapObj extends Wrapper {
+    readonly tag = "Map";
+    readonly map: Map<Value, Value>;
+    inspect(item: (value: Value) => string): string;
+    toHost(item: (value: Value) => unknown): Map<unknown, unknown>;
+    iterator(builtins: Builtins): IteratorObject<Arr, undefined, unknown>;
+}
+export declare class SetObj extends Wrapper {
+    readonly tag = "Set";
+    readonly set: Set<Value>;
+    inspect(item: (value: Value) => string): string;
+    toHost(item: (value: Value) => unknown): Set<unknown>;
+    iterator(): SetIterator<Value>;
+}
+export declare class URLSearchParamsObj extends Wrapper {
     readonly params: URLSearchParams;
+    readonly tag = "URLSearchParams";
     constructor(proto: Obj, params: URLSearchParams);
+    toString(): string;
+    toHost(): URLSearchParams;
+    iterator(builtins: Builtins): IteratorObject<Arr, undefined, unknown>;
 }
-export declare class HeadersObj extends Obj {
+export declare class HeadersObj extends Wrapper {
     readonly headers: Headers;
+    readonly tag = "Headers";
     constructor(proto: Obj, headers: Headers);
+    inspect(): string;
+    toHost(): Headers;
+    iterator(builtins: Builtins): IteratorObject<Arr, undefined, unknown>;
 }
-export declare class URLObj extends Obj {
+export declare class URLObj extends Wrapper {
     readonly url: URL;
+    readonly tag = "URL";
     readonly searchParams: URLSearchParamsObj;
     constructor(proto: Obj, searchParamsProto: Obj, url: URL);
+    toString(): string;
+    toHost(): URL;
 }
 /** A `Uint8Array`: the host array does the byte clamping and ignores out-of-range writes, as JS does. */
-export declare class Bytes extends Obj {
+export declare class Bytes extends Wrapper {
     readonly bytes: Uint8Array;
+    readonly tag = "Uint8Array";
     constructor(proto: Obj, bytes: Uint8Array);
-}
-/** Built-in objects that wrap a host value; data-like, but never plain data. */
-export declare const isWrapper: (value: unknown) => value is DateObj | RegExpObj | MapObj | SetObj | URLObj | URLSearchParamsObj | HeadersObj | Bytes;
+    toString(): string;
+    inspect(): string;
+    toHost(): Uint8Array<ArrayBuffer>;
+    iterator(): ArrayIterator<number>;
+}
+/** Every value a program can hold. Host values never appear here; they are copied in at the boundaries. */
+export type Value = string | number | boolean | null | undefined | symbol | Obj | ToolReference;
+/** ToString without consulting program-defined methods. */
+export declare const coerceToString: (value: Value) => string;
+/** ToNumber without consulting program-defined methods; tool references are not numbers. */
+export declare const coerceToNumber: (value: Value) => number;
+/** ToIntegerOrInfinity: NaN is 0, fractions truncate. */
+export declare const coerceToInteger: (value: Value) => number;
+/** Values that cannot cross the data boundary: opaque machinery and host-backed wrappers. */
+export declare const isRuntimeReference: (value: Value) => boolean;
 export declare const parseArrayIndex: (key: string | number) => number | undefined;
 /** The own property under `key`, including an array's live indexes and `length`. */
 export declare const own: (target: Obj, key: PropertyKey) => Slot | undefined;
 export declare const hasOwn: (target: Obj, key: PropertyKey) => boolean;
-export declare const getOwn: (target: Obj, key: PropertyKey) => unknown;
+export declare const getOwn: (target: Obj, key: PropertyKey) => Value;
 /** [[Get]]: walks the prototype chain; accessors see `receiver`, which is the primitive for wrapper prototypes. */
-export declare const get: (target: Obj, key: PropertyKey, receiver?: unknown) => unknown;
+export declare const get: (target: Obj, key: PropertyKey, receiver?: Value) => Value;
 export declare const has: (target: Obj, key: PropertyKey) => boolean;
-export declare const hasPrototype: (value: unknown, proto: Obj) => boolean;
+export declare const hasPrototype: (value: Value, proto: Obj) => boolean;
 /** [[Set]]: an inherited setter or read-only property decides before an own data property is created. */
-export declare const set: (target: Obj, key: PropertyKey, value: unknown) => boolean;
+export declare const set: (target: Obj, key: PropertyKey, value: Value) => boolean;
 /** [[DefineOwnProperty]] for a data property, ignoring the chain. */
-export declare const define: (target: Obj, key: PropertyKey, value: unknown, attrs?: Attributes) => void;
+export declare const define: (target: Obj, key: PropertyKey, value: Value, attrs?: Attributes) => void;
 export declare const defineAccessor: (target: Obj, key: PropertyKey, get: Getter | undefined, set?: Setter) => void;
 export declare const remove: (target: Obj, key: PropertyKey) => boolean;
 export declare const ownKeys: (target: Obj) => Array<string | symbol>;
@@ -141,6 +242,6 @@ export declare const enumerableKeys: (target: Obj) => Array<string | symbol>;
 /** Own enumerable string keys: `Object.keys`. */
 export declare const keys: (target: Obj) => Array<string>;
 /** Own enumerable string entries: `Object.entries` and serialization. */
-export declare const entries: (target: Obj) => Array<[string, unknown]>;
-export declare const record: (proto: Obj, fields: Record<string, unknown>) => Obj;
+export declare const entries: (target: Obj) => Array<[string, Value]>;
+export declare const record: (proto: Obj, fields: Record<string, Value>) => Obj;
 export declare const assign: (target: Obj, source: Obj, skip?: ReadonlySet<PropertyKey>) => void;

package/dist/interpreter/objects.js

@@ -1,3 +1,5 @@
+import { Effect } from "effect";
+import { ToolReference } from "../tool-runtime.js";
 import { checkArrayLength } from "./limits.js";
 import { AsyncIteratorSymbol, IteratorSymbol, } from "./model.js";
 /** Ordinary assignment: writable, enumerable, configurable. */
@@ -8,32 +10,113 @@ export const hidden = { writable: true, enumerable: false, configurable: true };
 export const readonly = { writable: false, enumerable: false, configurable: true };
 /** Constants such as `Math.PI` and a constructor's `prototype`. */
 export const frozen = { writable: false, enumerable: false, configurable: false };
-/** An object owned by the program: own properties plus a prototype link. */
+/**
+ * An object owned by the program: own properties plus a prototype link. Subclasses answer, in one place, how a
+ * built-in kind of object prints, coerces, iterates, and crosses to the host.
+ */
 export class Obj {
     proto;
     props = new Map();
     constructor(proto) {
         this.proto = proto;
     }
+    /** The class name `Object.prototype.toString` reports: `[object Map]`. */
+    tag = "Object";
+    /** How diagnostics refer to a value of this kind. */
+    get describe() {
+        if (this.tag === "Object")
+            return "a data object";
+        return `${/^[AEIO]/.test(this.tag) ? "an" : "a"} ${this.tag}`;
+    }
+    /** ToString without consulting program-defined methods. */
+    toString() {
+        return `[object ${this.tag}]`;
+    }
+    /** ToPrimitive without consulting program-defined methods: only a Date answers a number hint differently. */
+    toPrimitive(hint) {
+        return this.toString();
+    }
+    /** ToNumber without consulting program-defined methods. */
+    toNumber() {
+        return Number(this.toPrimitive("number"));
+    }
+    /** How `console.log` shows the value; `item` formats a child with cycle and depth tracking. */
+    inspect(item) {
+        return `{${entries(this)
+            .map(([key, value]) => `${JSON.stringify(key)}:${item(value)}`)
+            .join(",")}}`;
+    }
+    /** A copy the host can hold; `item` converts a child. A `__proto__` key never reaches host code. */
+    toHost(item) {
+        return Object.fromEntries(entries(this)
+            .filter(([key]) => key !== "__proto__")
+            .map(([key, value]) => [key, item(value)]));
+    }
+    /** The built-in iteration `for...of` and spread use, when this kind of object has one. */
+    iterator(builtins) {
+        return undefined;
+    }
 }
 export class Arr extends Obj {
     items;
+    tag = "Array";
     constructor(proto, items = []) {
         super(proto);
         this.items = items;
     }
+    get describe() {
+        return "an array";
+    }
+    toString() {
+        return this.items.map((item) => (item === null || item === undefined ? "" : coerceToString(item))).join(",");
+    }
+    inspect(item) {
+        return `[${this.items.map(item).join(",")}]`;
+    }
+    toHost(item) {
+        return this.items.map(item);
+    }
+    iterator() {
+        return this.items.values();
+    }
 }
 /** An object with the [[ErrorData]] slot: what `Error.prototype.toString` and the host boundary recognize as an error. */
 export class ErrorObj extends Obj {
+    tag = "Error";
     /** The interpreter failure this error materialized from, so rethrowing it keeps the diagnostic kind and location. */
     host;
+    /** Error.prototype.toString: "name: message", or just one when the other is empty. */
+    toString() {
+        const name = get(this, "name");
+        const message = get(this, "message");
+        const shownName = typeof name === "string" ? name : "Error";
+        const shownMessage = typeof message === "string" ? message : "";
+        if (shownMessage === "")
+            return shownName;
+        if (shownName === "")
+            return shownMessage;
+        return `${shownName}: ${shownMessage}`;
+    }
+    inspect() {
+        return this.toString();
+    }
+}
+/** Interpreter machinery a program can hold but never inspect, serialize, or hand to the host. */
+export class Opaque extends Obj {
+    inspect() {
+        return "[opaque reference]";
+    }
 }
-export class Callable extends Obj {
+export class Callable extends Opaque {
+    tag = "Function";
     constructor(proto, name, length) {
         super(proto);
         define(this, "length", length, readonly);
         define(this, "name", name, readonly);
     }
+    get describe() {
+        return "a function";
+    }
 }
 export class Fn extends Callable {
     parameters;
@@ -62,90 +145,205 @@ export class Native extends Callable {
         this.callback = options.callback ?? true;
     }
 }
-export class PromiseObj extends Obj {
+export class PromiseObj extends Opaque {
     fiber;
+    tag = "Promise";
     constructor(proto, fiber) {
         super(proto);
         this.fiber = fiber;
     }
+    get describe() {
+        return "an un-awaited Promise";
+    }
+    inspect() {
+        return "[Promise (await it to get its value)]";
+    }
 }
-export class GeneratorObj extends Obj {
+export class GeneratorObj extends Opaque {
     asynchronous;
     request;
+    tag = "Generator";
     constructor(proto, asynchronous, request) {
         super(proto);
         this.asynchronous = asynchronous;
         this.request = request;
     }
+    get describe() {
+        return "a generator";
+    }
 }
-/** A built-in collection iterator: live over the host collection, yielding program values. */
-export class IteratorObj extends Obj {
-    iterator;
-    constructor(proto, iterator) {
+/** A cursor over a host iterator; there is nothing to close. */
+export const hostCursor = (iterator) => ({
+    next: Effect.sync(() => {
+        const step = iterator.next();
+        return { done: Boolean(step.done), value: step.value };
+    }),
+    close: Effect.void,
+});
+/** A built-in iterator: a live cursor over a host collection or an iterator helper, yielding program values. */
+export class IteratorObj extends Opaque {
+    cursor;
+    tag = "Iterator";
+    constructor(proto, cursor) {
         super(proto);
-        this.iterator = iterator;
+        this.cursor = cursor;
+    }
+    get describe() {
+        return "an iterator";
     }
 }
-export class DateObj extends Obj {
+/** A built-in iterator over a host iterator, e.g. `array.values()`. */
+export const hostIterator = (builtins, iterator) => new IteratorObj(builtins.Iterator, hostCursor(iterator));
+/** A built-in object around a host value: data-like, so it prints as itself and crosses to extensions as a copy. */
+export class Wrapper extends Obj {
+    inspect(item) {
+        return this.toString();
+    }
+}
+export class DateObj extends Wrapper {
     time;
+    tag = "Date";
     constructor(proto, time) {
         super(proto);
         this.time = time;
     }
+    toString() {
+        return Number.isFinite(this.time) ? new Date(this.time).toISOString() : "Invalid Date";
+    }
+    toPrimitive(hint) {
+        return hint === "number" ? this.time : this.toString();
+    }
+    toHost() {
+        return new Date(this.time);
+    }
 }
-export class RegExpObj extends Obj {
+export class RegExpObj extends Wrapper {
+    tag = "RegExp";
     regex;
     constructor(proto, pattern, flags) {
         super(proto);
         this.regex = new RegExp(pattern, flags);
     }
+    toString() {
+        return `/${this.regex.source}/${this.regex.flags}`;
+    }
+    toHost() {
+        return new RegExp(this.regex.source, this.regex.flags);
+    }
 }
-export class MapObj extends Obj {
+export class MapObj extends Wrapper {
+    tag = "Map";
     map = new Map();
+    inspect(item) {
+        return `Map(${this.map.size}) [${[...this.map].map(([key, value]) => `[${item(key)},${item(value)}]`).join(",")}]`;
+    }
+    toHost(item) {
+        return new Map([...this.map].map(([key, value]) => [item(key), item(value)]));
+    }
+    iterator(builtins) {
+        return this.map.entries().map((entry) => new Arr(builtins.Array, entry));
+    }
 }
-export class SetObj extends Obj {
+export class SetObj extends Wrapper {
+    tag = "Set";
     set = new Set();
+    inspect(item) {
+        return `Set(${this.set.size}) [${[...this.set].map(item).join(",")}]`;
+    }
+    toHost(item) {
+        return new Set([...this.set].map(item));
+    }
+    iterator() {
+        return this.set.values();
+    }
 }
-export class URLSearchParamsObj extends Obj {
+export class URLSearchParamsObj extends Wrapper {
     params;
+    tag = "URLSearchParams";
     constructor(proto, params) {
         super(proto);
         this.params = params;
     }
+    toString() {
+        return this.params.toString();
+    }
+    toHost() {
+        return new URLSearchParams(this.params);
+    }
+    iterator(builtins) {
+        return this.params.entries().map((entry) => new Arr(builtins.Array, entry));
+    }
 }
-export class HeadersObj extends Obj {
+export class HeadersObj extends Wrapper {
     headers;
+    tag = "Headers";
     constructor(proto, headers) {
         super(proto);
         this.headers = headers;
     }
+    inspect() {
+        return `Headers ${JSON.stringify(Object.fromEntries(this.headers))}`;
+    }
+    toHost() {
+        return new Headers(this.headers);
+    }
+    iterator(builtins) {
+        // Bun's Headers typings lack the iterator helpers, so the host iterator is lifted first.
+        return Iterator.from(this.headers.entries()).map((entry) => new Arr(builtins.Array, entry));
+    }
 }
-export class URLObj extends Obj {
+export class URLObj extends Wrapper {
     url;
+    tag = "URL";
     searchParams;
     constructor(proto, searchParamsProto, url) {
         super(proto);
         this.url = url;
         this.searchParams = new URLSearchParamsObj(searchParamsProto, url.searchParams);
     }
+    toString() {
+        return this.url.href;
+    }
+    toHost() {
+        return new URL(this.url.href);
+    }
 }
 /** A `Uint8Array`: the host array does the byte clamping and ignores out-of-range writes, as JS does. */
-export class Bytes extends Obj {
+export class Bytes extends Wrapper {
     bytes;
+    tag = "Uint8Array";
     constructor(proto, bytes) {
         super(proto);
         this.bytes = bytes;
     }
+    toString() {
+        return this.bytes.join(",");
+    }
+    inspect() {
+        return `Uint8Array(${this.bytes.length}) [${this.bytes.join(",")}]`;
+    }
+    toHost() {
+        return new Uint8Array(this.bytes);
+    }
+    iterator() {
+        return this.bytes.values();
+    }
 }
-/** Built-in objects that wrap a host value; data-like, but never plain data. */
-export const isWrapper = (value) => value instanceof DateObj ||
-    value instanceof RegExpObj ||
-    value instanceof MapObj ||
-    value instanceof SetObj ||
-    value instanceof URLObj ||
-    value instanceof URLSearchParamsObj ||
-    value instanceof HeadersObj ||
-    value instanceof Bytes;
+/** ToString without consulting program-defined methods. */
+export const coerceToString = (value) => (value instanceof Obj ? value.toString() : String(value));
+/** ToNumber without consulting program-defined methods; tool references are not numbers. */
+export const coerceToNumber = (value) => {
+    if (value instanceof Obj)
+        return value.toNumber();
+    return value instanceof ToolReference ? Number.NaN : Number(value);
+};
+/** ToIntegerOrInfinity: NaN is 0, fractions truncate. */
+export const coerceToInteger = (value) => {
+    const number = coerceToNumber(value);
+    return Number.isNaN(number) ? 0 : Math.trunc(number);
+};
+/** Values that cannot cross the data boundary: opaque machinery and host-backed wrappers. */
+export const isRuntimeReference = (value) => value instanceof Opaque || value instanceof Wrapper || value instanceof ToolReference;
 const MAX_ARRAY_INDEX = 4_294_967_295;
 export const parseArrayIndex = (key) => {
     const property = String(key);

package/dist/interpreter/promises.d.ts

@@ -1,6 +1,6 @@
 import { Effect, Exit, Scope } from "effect";
 import type { Diagnostic } from "../codemode.js";
-import { Obj, PromiseObj } from "./objects.js";
+import { Obj, PromiseObj, type Value } from "./objects.js";
 import type { Interpreter } from "./interpreter.js";
 export declare class Pending<R> {
     private readonly scope;
@@ -13,16 +13,16 @@ export declare class Pending<R> {
     constructor(scope: Scope.Scope, proto: Obj);
     createWithSelf(body: (self: {
         promise?: PromiseObj;
-    }) => Effect.Effect<unknown, unknown, R>): Effect.Effect<PromiseObj, never, R>;
-    create(effect: Effect.Effect<unknown, unknown, R>): Effect.Effect<PromiseObj, never, R>;
+    }) => Effect.Effect<Value, unknown, R>): Effect.Effect<PromiseObj, never, R>;
+    create(effect: Effect.Effect<Value, unknown, R>): Effect.Effect<PromiseObj, never, R>;
     markObserved(promise: PromiseObj): void;
-    await(promise: PromiseObj): Effect.Effect<Exit.Exit<unknown, unknown>>;
+    await(promise: PromiseObj): Effect.Effect<Exit.Exit<Value, unknown>>;
     fork(effect: Effect.Effect<unknown, unknown, R>): Effect.Effect<void, never, R>;
     diagnostics(): Array<Diagnostic>;
     interrupt(): Effect.Effect<Array<Diagnostic>>;
 }
-export declare const resolvePromiseValue: <R>(ctx: Interpreter<R>, value: unknown, own?: {
+export declare const resolvePromiseValue: <R>(ctx: Interpreter<R>, value: Value, own?: {
     promise?: PromiseObj;
-}) => Effect.Effect<unknown, unknown, R>;
-export declare const resolvePromise: <R>(ctx: Interpreter<R>, value: unknown) => Effect.Effect<PromiseObj, never, R>;
+}) => Effect.Effect<Value, unknown, R>;
+export declare const resolvePromise: <R>(ctx: Interpreter<R>, value: Value) => Effect.Effect<PromiseObj, never, R>;
 export declare const promiseGlobal: <R>(ctx: Interpreter<R>) => import("./objects.js").Native<R>;