@opencode/codemode 2.0.1 → 2.0.2

package/dist/interpreter/references.js

@@ -1,18 +1,12 @@
 import { ToolReference } from "../tool-runtime.js";
-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 ||
+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 ||
     value instanceof ToolReference ||
-    value instanceof IntrinsicReference ||
-    value instanceof PromiseInstanceMethodReference ||
-    value instanceof Values.Promise ||
-    Values.isValue(value);
+    value instanceof ProgramPromise ||
+    isWrapper(value);
 function* childValues(value) {
     if (!(value instanceof ProgramObject))
         return;
@@ -40,8 +34,8 @@ const find = (value, match, skip, seen) => {
 };
 const never = () => false;
 export const containsRuntimeReference = (value) => find(value, isRuntimeReference, never, 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());
+// Wrapper values are data here, not opaque interpreter references.
+export const containsOpaqueReference = (value) => find(value, (current) => !isWrapper(current) && isRuntimeReference(current), isWrapper, 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)) {
@@ -49,27 +43,27 @@ export const rejectCircularInsertion = (container, value, label, node, seen = ne
     }
 };
 export const describeValue = (value) => {
-    if (value === null)
-        return "null";
+    if (value === null || value === undefined)
+        return String(value);
     if (value instanceof ProgramArray)
         return "an array";
-    if (value instanceof Values.Promise)
+    if (value instanceof ProgramPromise)
         return "an un-awaited Promise";
     if (value instanceof ToolReference)
         return "a tool reference";
-    if (value instanceof Values.Date)
+    if (value instanceof ProgramDate)
         return "a Date";
-    if (value instanceof Values.RegExp)
+    if (value instanceof ProgramRegExp)
         return "a RegExp";
-    if (value instanceof Values.Map)
+    if (value instanceof ProgramMap)
         return "a Map";
-    if (value instanceof Values.Set)
+    if (value instanceof ProgramSet)
         return "a Set";
-    if (value instanceof Values.URL)
+    if (value instanceof ProgramURL)
         return "a URL";
-    if (value instanceof Values.URLSearchParams)
+    if (value instanceof ProgramURLSearchParams)
         return "a URLSearchParams";
-    if (value instanceof CodeModeGenerator)
+    if (value instanceof ProgramGenerator)
         return "a generator";
     if (isRuntimeReference(value))
         return "a function";
@@ -78,15 +72,8 @@ export const describeValue = (value) => {
     return `a ${typeof value}`;
 };
 export const typeofValue = (value) => {
-    if (value instanceof HostFunction ||
-        value instanceof ProgramFunction ||
-        value instanceof GeneratorMethodReference ||
-        value instanceof IntrinsicReference ||
-        value instanceof PromiseInstanceMethodReference) {
+    if (value instanceof Callable)
         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,9 +1,7 @@
 import { Effect } from "effect";
-import { Values } from "../values.js";
-import { HostFunction } from "./host.js";
-import { type AstNode, IntrinsicReference } from "./model.js";
-import type { Intrinsics } from "./intrinsics.js";
-import { ProgramFunction } from "./objects.js";
+import type { Prototypes } from "./intrinsics.js";
+import { type AstNode } from "./model.js";
+import { Callable, ProgramPromise } from "./objects.js";
 export type IteratorCursor<R> = {
     readonly next: Effect.Effect<{
         readonly done: boolean;
@@ -11,16 +9,20 @@ export type IteratorCursor<R> = {
     }, unknown, R>;
     readonly close: Effect.Effect<void, unknown, R>;
 };
-/** Everything a host function needs from the realm: calling back into the program and its intrinsic objects. */
+/** Everything a native function needs from the realm: calling back into the program and its intrinsic objects. */
 export type Runner<R> = {
-    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 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 syncIterator: (value: unknown, node: AstNode) => Effect.Effect<IteratorCursor<R> | undefined, unknown, R>;
-    readonly intrinsics: Intrinsics;
+    readonly prototypes: Prototypes;
 };
 export declare const preserveConsumerError: <A, R>(cursor: IteratorCursor<R>, effect: Effect.Effect<A, unknown, R>) => Effect.Effect<A, unknown, R>;
-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;
+/**
+ * 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 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,39 +1,39 @@
 import { Effect, Exit } from "effect";
-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 { coerceToNumber, coerceToString } from "../stdlib/value.js";
+import { InterpreterRuntimeError } from "./model.js";
+import { Callable, get, NativeFunction, ProgramDate, ProgramObject, ProgramPromise } 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 order = hint === "number" ? ["valueOf", "toString"] : ["toString", "valueOf"];
+    const asString = hint === "string" || (hint === "default" && value instanceof ProgramDate);
+    const order = asString ? ["toString", "valueOf"] : ["valueOf", "toString"];
     return Effect.gen(function* () {
         for (const method of order) {
-            if (method === "toString" && !has(value, "toString"))
-                return coerceToString(value);
             const callable = get(value, method);
-            if (typeofValue(callable) !== "function")
+            if (!(callable instanceof Callable))
                 continue;
-            const result = yield* runner.invokeCallable(callable, [], node);
+            const result = yield* runner.invokeCallable(callable, value, [], node);
             if (result === null || (typeof result !== "object" && typeof result !== "function"))
                 return result;
         }
         throw new InterpreterRuntimeError("Cannot convert object to primitive value.", node);
     });
 };
-export const isSupportedCallback = (value) => value instanceof ProgramFunction ||
-    (value instanceof HostFunction && value.callback) ||
-    value instanceof IntrinsicReference;
+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 applyCollectionCallback = (runner, callback, name, node) => {
     if (!isSupportedCallback(callback)) {
         if (typeofValue(callback) === "function") {
@@ -41,5 +41,5 @@ export const applyCollectionCallback = (runner, callback, name, node) => {
         }
         throw new InterpreterRuntimeError(`${name} expects a function callback.`, node);
     }
-    return (callbackArgs) => runner.invokeCallable(callback, callbackArgs, node);
+    return (callbackArgs) => runner.invokeCallable(callback, undefined, callbackArgs, node);
 };

package/dist/interpreter/runtime.d.ts

@@ -1,5 +1,6 @@
 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";
@@ -9,11 +10,10 @@ 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>, 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>, prototypes: Prototypes, logs?: Array<string>, extraGlobals?: (host: Host<R>) => ReadonlyArray<readonly [string, unknown]>);
     run(program: Program): Effect.Effect<unknown, unknown, R>;
 }