@opencode/codemode 0.0.0-dev-19530 → 2.0.0

package/dist/interpreter/promises.d.ts

@@ -1,30 +1,31 @@
 import { Effect, Exit, Scope } from "effect";
 import type { Diagnostic } from "../codemode.js";
-import { type AstNode, InterpreterRuntimeError } from "./model.js";
-import { ProgramObject, ProgramPromise } from "./objects.js";
+import { type AstNode, InterpreterRuntimeError, PromiseInstanceMethodReference } from "./model.js";
+import { HostFunction } from "./host.js";
+import { Values } from "../values.js";
 import { type Runner } from "./runner.js";
 export declare class PromiseRuntime<R> {
     private readonly scope;
-    private readonly proto;
     private readonly active;
     private readonly ids;
     private readonly observed;
     private readonly failures;
     private nextID;
-    constructor(scope: Scope.Scope, proto: ProgramObject);
+    constructor(scope: Scope.Scope);
     createWithSelf(body: (self: {
-        promise?: ProgramPromise;
-    }) => Effect.Effect<unknown, unknown, R>): Effect.Effect<ProgramPromise, never, R>;
-    create(effect: Effect.Effect<unknown, unknown, R>): Effect.Effect<ProgramPromise, never, R>;
-    markObserved(promise: ProgramPromise): void;
-    await(promise: ProgramPromise): Effect.Effect<Exit.Exit<unknown, unknown>>;
+        promise?: Values.Promise;
+    }) => Effect.Effect<unknown, unknown, R>): Effect.Effect<Values.Promise, never, R>;
+    create(effect: Effect.Effect<unknown, unknown, R>): Effect.Effect<Values.Promise, never, R>;
+    markObserved(promise: Values.Promise): void;
+    await(promise: Values.Promise): Effect.Effect<Exit.Exit<unknown, unknown>>;
     fork(effect: Effect.Effect<unknown, unknown, R>): Effect.Effect<void, never, R>;
     diagnostics(): Array<Diagnostic>;
     interrupt(): Effect.Effect<Array<Diagnostic>>;
 }
 export declare const selfResolutionError: (node?: AstNode) => InterpreterRuntimeError;
 export declare const resolvePromiseValue: <R>(runner: Runner<R>, value: unknown, node: AstNode, own?: {
-    promise?: ProgramPromise;
+    promise?: Values.Promise;
 }) => Effect.Effect<unknown, unknown, R>;
-export declare const resolvePromise: <R>(runner: Runner<R>, promises: PromiseRuntime<R>, value: unknown, node: AstNode) => Effect.Effect<ProgramPromise, never, R>;
-export declare const promiseGlobal: <R>(runner: Runner<R>, promises: PromiseRuntime<R>) => import("./objects.js").NativeFunction<R>;
+export declare const resolvePromise: <R>(runner: Runner<R>, promises: PromiseRuntime<R>, value: unknown, node: AstNode) => Effect.Effect<Values.Promise, never, R>;
+export declare const invokePromiseInstanceMethod: <R>(runner: Runner<R>, promises: PromiseRuntime<R>, ref: PromiseInstanceMethodReference, args: Array<unknown>, node: AstNode) => Effect.Effect<Values.Promise, never, R>;
+export declare const promiseGlobal: <R>(runner: Runner<R>, promises: PromiseRuntime<R>) => HostFunction<R>;

package/dist/interpreter/promises.js

@@ -1,27 +1,27 @@
 import { Cause, Deferred, Effect, Exit, Fiber, Scope } from "effect";
-import { InterpreterRuntimeError, ProgramThrow } from "./model.js";
-import { Callable, define, get, hidden, ProgramArray, ProgramFunction, ProgramObject, ProgramPromise, record, } from "./objects.js";
-import { constructor, fn, methods, native, receiver, requiresNew } from "./native.js";
-import { caughtErrorValue, createAggregateErrorValue, normalizeError } from "./errors.js";
+import { InterpreterRuntimeError, ProgramThrow, PromiseInstanceMethodReference } from "./model.js";
+import { get, ProgramArray, ProgramFunction, ProgramObject, record } from "./objects.js";
+import { HostFunction, requiresNew, sync } from "./host.js";
+import { caughtErrorValue, normalizeError } from "./errors.js";
 import { typeofValue } from "./references.js";
+import { createAggregateErrorValue } from "../stdlib/value.js";
+import { Values } from "../values.js";
 import { applyCollectionCallback, isSupportedCallback } from "./runner.js";
 // A `resolve`/`reject` handed to an executor or thenable: calling it settles the capability.
-const capability = (runner, name, settle) => fn(runner.prototypes, name, 1, (_, args) => {
+const capability = (name, settle) => sync(name, (args) => {
     settle(args[0]);
     return undefined;
 });
 // Observation only controls rejection reporting; program completion interrupts all promise work.
 export class PromiseRuntime {
     scope;
-    proto;
     active = new Set();
     ids = new WeakMap();
     observed = new WeakSet();
     failures = new Map();
     nextID = 0;
-    constructor(scope, proto) {
+    constructor(scope) {
         this.scope = scope;
-        this.proto = proto;
     }
     // Resolution bodies need the promise's own identity to reject `resolve(promise)` self-resolution.
     createWithSelf(body) {
@@ -36,7 +36,7 @@ export class PromiseRuntime {
             // Allocate before forking so reruns get distinct IDs and diagnostics retain creation order.
             const id = this.nextID++;
             return Effect.map(Effect.forkIn(effect, this.scope, { startImmediately: true }), (fiber) => {
-                const promise = new ProgramPromise(this.proto, fiber);
+                const promise = new Values.Promise(fiber);
                 this.active.add(promise);
                 this.ids.set(promise, id);
                 fiber.addObserver((exit) => {
@@ -83,11 +83,11 @@ export class PromiseRuntime {
         });
     }
 }
-export const selfResolutionError = (node) => new InterpreterRuntimeError("Chaining cycle detected: a promise cannot resolve with itself.", node);
+export const selfResolutionError = (node) => new InterpreterRuntimeError("Chaining cycle detected: a promise cannot resolve with itself.", node).as("TypeError");
 export const resolvePromiseValue = (runner, value, node, own) => {
     if (own?.promise !== undefined && value === own.promise)
         return Effect.fail(selfResolutionError(node));
-    if (value instanceof ProgramPromise)
+    if (value instanceof Values.Promise)
         return runner.settlePromise(value);
     if (!(value instanceof ProgramObject))
         return Effect.succeed(value);
@@ -98,9 +98,9 @@ export const resolvePromiseValue = (runner, value, node, own) => {
         // Promise resolution invokes a thenable's method in a later job.
         yield* Effect.yieldNow;
         const deferred = Deferred.makeUnsafe();
-        const resolve = capability(runner, "resolve", (result) => Deferred.doneUnsafe(deferred, Exit.succeed(result)));
-        const reject = capability(runner, "reject", (reason) => Deferred.doneUnsafe(deferred, Exit.fail(new ProgramThrow(reason))));
-        const executed = yield* Effect.exit(runner.invokeCallable(then, value, [resolve, reject], node));
+        const resolve = capability("resolve", (result) => Deferred.doneUnsafe(deferred, Exit.succeed(result)));
+        const reject = capability("reject", (reason) => Deferred.doneUnsafe(deferred, Exit.fail(new ProgramThrow(reason))));
+        const executed = yield* Effect.exit(runner.invokeCallable(then, [resolve, reject], node));
         if (!Exit.isSuccess(executed)) {
             if (Cause.hasInterruptsOnly(executed.cause))
                 return yield* Effect.failCause(executed.cause);
@@ -110,7 +110,7 @@ export const resolvePromiseValue = (runner, value, node, own) => {
     });
 };
 export const resolvePromise = (runner, promises, value, node) => {
-    if (value instanceof ProgramPromise)
+    if (value instanceof Values.Promise)
         return Effect.succeed(value);
     return promises.createWithSelf((self) => resolvePromiseValue(runner, value, node, self));
 };
@@ -125,7 +125,7 @@ const invokePromiseMethod = (runner, promises, name, args, node) => {
     return promises.create(Effect.gen(function* () {
         const cursor = yield* runner.syncIterator(args[0], node);
         if (cursor === undefined) {
-            throw new InterpreterRuntimeError(`Promise.${name} expects an array or other synchronous iterable.`, node);
+            throw new InterpreterRuntimeError(`Promise.${name} expects an array or other synchronous iterable.`, node).as("TypeError");
         }
         const items = [];
         while (true) {
@@ -137,25 +137,22 @@ const invokePromiseMethod = (runner, promises, name, args, node) => {
             items.push(item);
         }
         if (name === "all") {
-            return new ProgramArray(runner.prototypes.Array, yield* settleAfterTurn(Effect.all(items.map((item) => Effect.flatten(promises.await(item))), { concurrency: "unbounded" })));
+            return new ProgramArray(yield* settleAfterTurn(Effect.all(items.map((item) => Effect.flatten(promises.await(item))), { concurrency: "unbounded" })));
         }
         if (name === "allSettled") {
             const outcomes = [];
             for (const item of items) {
                 const exit = yield* promises.await(item);
                 if (Exit.isSuccess(exit)) {
-                    outcomes.push(record(runner.prototypes.Object, { status: "fulfilled", value: exit.value }));
+                    outcomes.push(record({ status: "fulfilled", value: exit.value }));
                     continue;
                 }
                 if (Cause.hasInterruptsOnly(exit.cause))
                     return yield* Effect.failCause(exit.cause);
-                outcomes.push(record(runner.prototypes.Object, {
-                    status: "rejected",
-                    reason: caughtErrorValue(runner, Cause.squash(exit.cause)),
-                }));
+                outcomes.push(record({ status: "rejected", reason: caughtErrorValue(Cause.squash(exit.cause)) }));
             }
             yield* Effect.yieldNow;
-            return new ProgramArray(runner.prototypes.Array, outcomes);
+            return new ProgramArray(outcomes);
         }
         if (name === "race") {
             if (items.length === 0) {
@@ -168,32 +165,31 @@ const invokePromiseMethod = (runner, promises, name, args, node) => {
                 return Effect.fail(new PromiseAnyFulfilled(exit.value));
             if (Cause.hasInterruptsOnly(exit.cause))
                 return Effect.failCause(exit.cause);
-            return Effect.succeed(caughtErrorValue(runner, Cause.squash(exit.cause)));
+            return Effect.succeed(caughtErrorValue(Cause.squash(exit.cause)));
         }));
-        return yield* settleAfterTurn(Effect.all(flipped, { concurrency: "unbounded" }).pipe(Effect.flatMap((reasons) => Effect.fail(new ProgramThrow(createAggregateErrorValue(runner, reasons, "All promises were rejected")))), Effect.catch((error) => error instanceof PromiseAnyFulfilled ? Effect.succeed(error.value) : Effect.fail(error))));
+        return yield* settleAfterTurn(Effect.all(flipped, { concurrency: "unbounded" }).pipe(Effect.flatMap((reasons) => Effect.fail(new ProgramThrow(createAggregateErrorValue(reasons, "All promises were rejected")))), Effect.catch((error) => error instanceof PromiseAnyFulfilled ? Effect.succeed(error.value) : Effect.fail(error))));
     }));
 };
-const instanceMethod = (runner, promises, name, thisValue, args, node) => {
-    const method = `Promise.prototype.${name}`;
-    const promise = receiver(ProgramPromise, thisValue, method, node);
-    promises.markObserved(promise);
-    if (name === "finally") {
-        return chainFinally(runner, promises, promise, reactionHandler(args[0], method, node), method, node);
+export const invokePromiseInstanceMethod = (runner, promises, ref, args, node) => {
+    const method = `Promise.prototype.${ref.name}`;
+    promises.markObserved(ref.promise);
+    if (ref.name === "finally") {
+        return chainFinally(runner, promises, ref.promise, reactionHandler(args[0], method, node), method, node);
     }
-    const onFulfilled = name === "then" ? reactionHandler(args[0], method, node) : undefined;
-    const onRejected = reactionHandler(name === "then" ? args[1] : args[0], method, node);
-    return chainReaction(runner, promises, promise, onFulfilled, onRejected, method, node);
+    const onFulfilled = ref.name === "then" ? reactionHandler(args[0], method, node) : undefined;
+    const onRejected = reactionHandler(ref.name === "then" ? args[1] : args[0], method, node);
+    return chainReaction(runner, promises, ref.promise, onFulfilled, onRejected, method, node);
 };
 const constructPromise = (runner, promises, executor, node) => {
     if (!(executor instanceof ProgramFunction)) {
-        throw new InterpreterRuntimeError("new Promise(...) expects an executor function (e.g. new Promise((resolve, reject) => { ... })).", node);
+        throw new InterpreterRuntimeError("new Promise(...) expects an executor function (e.g. new Promise((resolve, reject) => { ... })).", node).as("TypeError");
     }
     return Effect.gen(function* () {
         const deferred = Deferred.makeUnsafe();
         const promise = yield* promises.createWithSelf((self) => Effect.flatMap(Deferred.await(deferred), (value) => resolvePromiseValue(runner, value, node, self)));
-        const resolve = capability(runner, "resolve", (value) => Deferred.doneUnsafe(deferred, Exit.succeed(value)));
-        const reject = capability(runner, "reject", (value) => Deferred.doneUnsafe(deferred, Exit.fail(new ProgramThrow(value))));
-        const executed = yield* Effect.exit(runner.invokeCallable(executor, undefined, [resolve, reject], node));
+        const resolve = capability("resolve", (value) => Deferred.doneUnsafe(deferred, Exit.succeed(value)));
+        const reject = capability("reject", (value) => Deferred.doneUnsafe(deferred, Exit.fail(new ProgramThrow(value))));
+        const executed = yield* Effect.exit(runner.invokeFunction(executor, [resolve, reject]));
         if (!Exit.isSuccess(executed)) {
             if (Cause.hasInterruptsOnly(executed.cause))
                 return yield* Effect.failCause(executed.cause);
@@ -232,7 +228,7 @@ const chainReaction = (runner, promises, source, onFulfilled, onRejected, method
         const handler = Exit.isSuccess(exit) ? onFulfilled : onRejected;
         if (handler === undefined)
             return yield* exit;
-        const input = Exit.isSuccess(exit) ? exit.value : caughtErrorValue(runner, Cause.squash(exit.cause));
+        const input = Exit.isSuccess(exit) ? exit.value : caughtErrorValue(Cause.squash(exit.cause));
         const result = yield* applyCollectionCallback(runner, handler, method, node)([input]);
         return yield* resolvePromiseValue(runner, result, node, self);
     }));
@@ -250,27 +246,26 @@ const chainFinally = (runner, promises, source, cleanup, method, node) => promis
     return yield* exit;
 }));
 export const promiseGlobal = (runner, promises) => {
-    const protos = runner.prototypes;
-    const proto = protos.Promise;
-    const promise = constructor(protos, proto, {
+    // Combinators are not callbacks: `[p].map(Promise.resolve)` must ask for an arrow function.
+    const statics = new Map(promiseStatics.map((name) => [
+        name,
+        new HostFunction({
+            name: `Promise.${name}`,
+            call: (args, node) => invokePromiseMethod(runner, promises, name, args, node),
+            callback: false,
+        }),
+    ]));
+    return new HostFunction({
         name: "Promise",
-        length: 1,
         call: requiresNew("Promise"),
-        construct: (args, _, node) => constructPromise(runner, promises, args[0], node),
+        construct: (args, node) => constructPromise(runner, promises, args[0], node),
+        instanceOf: (value) => value instanceof Values.Promise,
+        // Unknown statics fail loudly so a missing await cannot hide behind `undefined`.
+        members: (key, node) => {
+            const method = typeof key === "string" ? statics.get(key) : undefined;
+            if (method !== undefined)
+                return method;
+            throw new InterpreterRuntimeError(`Promise.${String(key)} is not available. Available: Promise.all, Promise.allSettled, Promise.race, Promise.any, Promise.resolve, and Promise.reject; consume promises with await.`, node);
+        },
     });
-    // Combinators are not callbacks: `[p].map(Promise.resolve)` must ask for an arrow function.
-    for (const name of promiseStatics) {
-        define(promise, name, native(protos, {
-            name,
-            length: 1,
-            call: (_, args, node) => invokePromiseMethod(runner, promises, name, args, node),
-            callback: false,
-        }), hidden);
-    }
-    methods(protos, proto, [
-        ["then", 2, (thisValue, args, node) => instanceMethod(runner, promises, "then", thisValue, args, node)],
-        ["catch", 1, (thisValue, args, node) => instanceMethod(runner, promises, "catch", thisValue, args, node)],
-        ["finally", 1, (thisValue, args, node) => instanceMethod(runner, promises, "finally", thisValue, args, node)],
-    ]);
-    return promise;
 };

package/dist/interpreter/references.d.ts

@@ -1,5 +1,4 @@
 import { type AstNode } from "./model.js";
-/** Values that cannot cross the data boundary. */
 export declare const isRuntimeReference: (value: unknown) => boolean;
 export declare const containsRuntimeReference: (value: unknown) => boolean;
 export declare const containsOpaqueReference: (value: unknown) => boolean;

package/dist/interpreter/references.js

@@ -1,12 +1,18 @@
 import { ToolReference } from "../tool-runtime.js";
-import { InterpreterRuntimeError } from "./model.js";
-import { Callable, getOwn, isWrapper, ownKeys, ProgramArray, ProgramDate, ProgramGenerator, ProgramMap, ProgramObject, ProgramPromise, ProgramRegExp, ProgramSet, ProgramURL, ProgramURLSearchParams, } from "./objects.js";
-/** Values that cannot cross the data boundary. */
-export const isRuntimeReference = (value) => value instanceof Callable ||
-    value instanceof ProgramGenerator ||
+import { Values } from "../values.js";
+import { HostFunction, HostNamespace } from "./host.js";
+import { CodeModeGenerator, GeneratorMethodReference, InterpreterRuntimeError, IntrinsicReference, PromiseInstanceMethodReference, } from "./model.js";
+import { getOwn, ownKeys, ProgramArray, ProgramFunction, ProgramObject } from "./objects.js";
+export const isRuntimeReference = (value) => value instanceof HostFunction ||
+    value instanceof HostNamespace ||
+    value instanceof ProgramFunction ||
+    value instanceof CodeModeGenerator ||
+    value instanceof GeneratorMethodReference ||
     value instanceof ToolReference ||
-    value instanceof ProgramPromise ||
-    isWrapper(value);
+    value instanceof IntrinsicReference ||
+    value instanceof PromiseInstanceMethodReference ||
+    value instanceof Values.Promise ||
+    Values.isValue(value);
 function* childValues(value) {
     if (!(value instanceof ProgramObject))
         return;
@@ -34,8 +40,8 @@ const find = (value, match, skip, seen) => {
 };
 const never = () => false;
 export const containsRuntimeReference = (value) => find(value, isRuntimeReference, never, new Set());
-// Wrapper values are data here, not opaque interpreter references.
-export const containsOpaqueReference = (value) => find(value, (current) => !isWrapper(current) && isRuntimeReference(current), isWrapper, new Set());
+// CodeMode values are data here, not opaque interpreter references.
+export const containsOpaqueReference = (value) => find(value, (current) => !Values.isValue(current) && isRuntimeReference(current), Values.isValue, new Set());
 // Reject cycles before mutation so later boundary walks remain safe.
 export const rejectCircularInsertion = (container, value, label, node, seen = new Set()) => {
     if (find(value, (current) => current === container, isRuntimeReference, seen)) {
@@ -43,27 +49,27 @@ export const rejectCircularInsertion = (container, value, label, node, seen = ne
     }
 };
 export const describeValue = (value) => {
-    if (value === null || value === undefined)
-        return String(value);
+    if (value === null)
+        return "null";
     if (value instanceof ProgramArray)
         return "an array";
-    if (value instanceof ProgramPromise)
+    if (value instanceof Values.Promise)
         return "an un-awaited Promise";
     if (value instanceof ToolReference)
         return "a tool reference";
-    if (value instanceof ProgramDate)
+    if (value instanceof Values.Date)
         return "a Date";
-    if (value instanceof ProgramRegExp)
+    if (value instanceof Values.RegExp)
         return "a RegExp";
-    if (value instanceof ProgramMap)
+    if (value instanceof Values.Map)
         return "a Map";
-    if (value instanceof ProgramSet)
+    if (value instanceof Values.Set)
         return "a Set";
-    if (value instanceof ProgramURL)
+    if (value instanceof Values.URL)
         return "a URL";
-    if (value instanceof ProgramURLSearchParams)
+    if (value instanceof Values.URLSearchParams)
         return "a URLSearchParams";
-    if (value instanceof ProgramGenerator)
+    if (value instanceof CodeModeGenerator)
         return "a generator";
     if (isRuntimeReference(value))
         return "a function";
@@ -72,8 +78,15 @@ export const describeValue = (value) => {
     return `a ${typeof value}`;
 };
 export const typeofValue = (value) => {
-    if (value instanceof Callable)
+    if (value instanceof HostFunction ||
+        value instanceof ProgramFunction ||
+        value instanceof GeneratorMethodReference ||
+        value instanceof IntrinsicReference ||
+        value instanceof PromiseInstanceMethodReference) {
         return "function";
+    }
+    if (value instanceof HostNamespace)
+        return "object";
     if (value instanceof ToolReference)
         return value.path.length > 0 ? "function" : "object";
     return typeof value;

package/dist/interpreter/runner.d.ts

@@ -1,7 +1,8 @@
 import { Effect } from "effect";
-import type { Prototypes } from "./intrinsics.js";
-import { type AstNode } from "./model.js";
-import { Callable, ProgramPromise } from "./objects.js";
+import { Values } from "../values.js";
+import { HostFunction } from "./host.js";
+import { type AstNode, IntrinsicReference } from "./model.js";
+import { ProgramFunction } from "./objects.js";
 export type IteratorCursor<R> = {
     readonly next: Effect.Effect<{
         readonly done: boolean;
@@ -9,20 +10,15 @@ export type IteratorCursor<R> = {
     }, unknown, R>;
     readonly close: Effect.Effect<void, unknown, R>;
 };
-/** Everything a native function needs from the realm: calling back into the program and its intrinsic objects. */
+/** Everything a host function needs to call back into the program. */
 export type Runner<R> = {
-    readonly invokeCallable: (callable: unknown, thisValue: unknown, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
-    readonly settlePromise: (promise: ProgramPromise) => Effect.Effect<unknown, unknown, never>;
+    readonly invokeFunction: (fn: ProgramFunction, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>;
+    readonly invokeCallable: (callable: unknown, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
+    readonly settlePromise: (promise: Values.Promise) => Effect.Effect<unknown, unknown, never>;
     readonly syncIterator: (value: unknown, node: AstNode) => Effect.Effect<IteratorCursor<R> | undefined, unknown, R>;
-    readonly prototypes: Prototypes;
 };
 export declare const preserveConsumerError: <A, R>(cursor: IteratorCursor<R>, 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>(runner: Runner<R>, value: unknown, hint: "number" | "string" | "default", node: AstNode) => Effect.Effect<unknown, unknown, R>;
-export declare const toPrimitiveString: <R>(runner: Runner<R>, value: unknown, node: AstNode) => Effect.Effect<string, unknown, R>;
-export declare const toPrimitiveNumber: <R>(runner: Runner<R>, value: unknown, node: AstNode) => Effect.Effect<number, unknown, R>;
-export declare const isSupportedCallback: (value: unknown) => value is Callable;
+export declare const toPrimitive: <R>(runner: Runner<R>, value: unknown, hint: "number" | "string", node: AstNode) => Effect.Effect<unknown, unknown, R>;
+export type SupportedCallback = ProgramFunction | HostFunction<unknown> | IntrinsicReference;
+export declare const isSupportedCallback: (value: unknown) => value is SupportedCallback;
 export declare const applyCollectionCallback: <R>(runner: Runner<R>, callback: unknown, name: string, node: AstNode) => ((args: Array<unknown>) => Effect.Effect<unknown, unknown, R>);

package/dist/interpreter/runner.js

@@ -1,45 +1,45 @@
 import { Effect, Exit } from "effect";
-import { coerceToNumber, coerceToString } from "../stdlib/value.js";
-import { InterpreterRuntimeError } from "./model.js";
-import { Callable, get, NativeFunction, ProgramDate, ProgramObject, ProgramPromise } from "./objects.js";
+import { Values } from "../values.js";
+import { coerceToString } from "../stdlib/value.js";
+import { HostFunction } from "./host.js";
+import { InterpreterRuntimeError, IntrinsicReference } from "./model.js";
+import { get, has, ProgramFunction, ProgramObject } 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)));
-/**
- * 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 const toPrimitive = (runner, value, hint, node) => {
+    if (value === null || typeof value !== "object")
+        return Effect.succeed(value);
+    if (Values.isValue(value)) {
+        return Effect.succeed(value instanceof Values.Date && hint === "number" ? value.time : coerceToString(value));
+    }
     if (!(value instanceof ProgramObject))
         return Effect.succeed(value);
-    const asString = hint === "string" || (hint === "default" && value instanceof ProgramDate);
-    const order = asString ? ["toString", "valueOf"] : ["valueOf", "toString"];
+    const order = hint === "number" ? ["valueOf", "toString"] : ["toString", "valueOf"];
     return Effect.gen(function* () {
         for (const method of order) {
+            if (method === "toString" && !has(value, "toString"))
+                return coerceToString(value);
             const callable = get(value, method);
-            if (!(callable instanceof Callable))
+            if (typeofValue(callable) !== "function")
                 continue;
-            const result = yield* runner.invokeCallable(callable, value, [], node);
+            const result = yield* runner.invokeCallable(callable, [], node);
             if (result === null || (typeof result !== "object" && typeof result !== "function"))
                 return result;
         }
-        throw new InterpreterRuntimeError("Cannot convert object to primitive value.", node);
+        throw new InterpreterRuntimeError("Cannot convert object to primitive value.", node).as("TypeError");
     });
 };
-export const toPrimitiveString = (runner, value, node) => Effect.map(toPrimitive(runner, value, "string", node), coerceToString);
-export const toPrimitiveNumber = (runner, value, node) => Effect.map(toPrimitive(runner, value, "number", node), coerceToNumber);
-// 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
-// constructors pass the gate and throw a TypeError on call, like JS.
-export const isSupportedCallback = (value) => value instanceof Callable && !(value instanceof NativeFunction && !value.callback);
+export const isSupportedCallback = (value) => value instanceof ProgramFunction ||
+    (value instanceof HostFunction && value.callback) ||
+    value instanceof IntrinsicReference;
 export const applyCollectionCallback = (runner, callback, name, node) => {
     if (!isSupportedCallback(callback)) {
         if (typeofValue(callback) === "function") {
             throw new InterpreterRuntimeError(`${name} cannot use this callable as a callback; wrap it in an arrow function, e.g. (value) => tools.ns.tool(value).`, node);
         }
-        throw new InterpreterRuntimeError(`${name} expects a function callback.`, node);
+        throw new InterpreterRuntimeError(`${name} expects a function callback.`, node).as("TypeError");
     }
-    return (callbackArgs) => runner.invokeCallable(callback, undefined, callbackArgs, node);
+    return (callbackArgs) => runner.invokeCallable(callback, callbackArgs, node);
 };

package/dist/interpreter/runtime.d.ts

@@ -1,6 +1,5 @@
 import type { Program } from "acorn";
 import { Effect } from "effect";
-import type { Prototypes } from "./intrinsics.js";
 import { type Host } from "./globals.js";
 import { type Runner } from "./runner.js";
 import { PromiseRuntime } from "./promises.js";
@@ -10,10 +9,11 @@ export declare class Runtime<R> {
     readonly search: (args: Array<unknown>) => Effect.Effect<unknown, unknown, R>;
     readonly toolKeys: (path: ReadonlyArray<string>) => ReadonlyArray<string>;
     readonly promises: PromiseRuntime<R>;
-    readonly prototypes: Prototypes;
     readonly logs: Array<string>;
     readonly runner: Runner<R>;
+    /** Built-in globals by name, unaffected by program shadowing. */
+    readonly builtins: ReadonlyMap<string, unknown>;
     private readonly root;
-    constructor(executeTool: (path: ReadonlyArray<string>, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>, search: (args: Array<unknown>) => Effect.Effect<unknown, unknown, R>, toolKeys: (path: ReadonlyArray<string>) => ReadonlyArray<string>, promises: PromiseRuntime<R>, prototypes: Prototypes, logs?: Array<string>, extraGlobals?: (host: Host<R>) => ReadonlyArray<readonly [string, unknown]>);
+    constructor(executeTool: (path: ReadonlyArray<string>, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>, search: (args: Array<unknown>) => Effect.Effect<unknown, unknown, R>, toolKeys: (path: ReadonlyArray<string>) => ReadonlyArray<string>, promises: PromiseRuntime<R>, logs?: Array<string>, extraGlobals?: (host: Host<R>) => ReadonlyArray<readonly [string, unknown]>);
     run(program: Program): Effect.Effect<unknown, unknown, R>;
 }