@opencode/codemode 2.0.0 → 2.0.2

package/dist/stdlib/value.d.ts

@@ -1,13 +1,9 @@
-import { type HostFunction, type SyncOptions } from "../interpreter/host.js";
-import { ProgramError } from "../interpreter/objects.js";
-export declare const errorConstructors: Set<string>;
+import { type NativeFunction } from "../interpreter/objects.js";
+import type { Runner } from "../interpreter/runner.js";
 export declare const compoundOperators: Set<string>;
-export declare const createErrorValue: (name: string, message: string) => ProgramError;
-export declare const createAggregateErrorValue: (errors: Array<unknown>, message: string) => ProgramError;
-export declare const errorBrandName: (value: unknown) => string | undefined;
+/** The built-in string form of a value, without consulting program-defined `toString` methods. */
 export declare const coerceToString: (value: unknown) => string;
 export declare const coerceToNumber: (value: unknown) => number;
-type Coercion = "Number" | "String" | "Boolean" | "parseInt" | "parseFloat" | "isFinite" | "isNaN";
+export type Coercion = "Number" | "String" | "Boolean" | "parseInt" | "parseFloat" | "isFinite" | "isNaN";
 /** A global coercion function such as `Number` or `parseInt`. */
-export declare const coercion: (name: Coercion, options?: SyncOptions) => HostFunction;
-export {};
+export declare const coercion: <R>(runner: Runner<R>, name: Coercion, length?: number) => NativeFunction<R>;

package/dist/stdlib/value.js

@@ -1,47 +1,25 @@
-import { sync } from "../interpreter/host.js";
-import { InterpreterRuntimeError } from "../interpreter/model.js";
 import { toProgram } from "../data.js";
-import { get, ProgramArray, ProgramError, set } from "../interpreter/objects.js";
-import { Values } from "../values.js";
-export const errorConstructors = new Set([
-    "Error",
-    "TypeError",
-    "RangeError",
-    "SyntaxError",
-    "ReferenceError",
-    "EvalError",
-    "URIError",
-    "AggregateError",
-]);
+import { fn } from "../interpreter/native.js";
+import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { get, isWrapper, ProgramArray, ProgramDate, ProgramError, ProgramMap, ProgramRegExp, ProgramSet, ProgramURL, ProgramURLSearchParams, } from "../interpreter/objects.js";
 export const compoundOperators = new Set(["+=", "-=", "*=", "/=", "%=", "**=", "&=", "|=", "^=", "<<=", ">>=", ">>>="]);
-export const createErrorValue = (name, message) => {
-    const value = new ProgramError(name);
-    set(value, "name", name);
-    set(value, "message", message);
-    return value;
-};
-export const createAggregateErrorValue = (errors, message) => {
-    const value = createErrorValue("AggregateError", message);
-    set(value, "errors", new ProgramArray(errors));
-    return value;
-};
-export const errorBrandName = (value) => value instanceof ProgramError ? value.errorName : undefined;
+/** The built-in string form of a value, without consulting program-defined `toString` methods. */
 export const coerceToString = (value) => {
     if (value === null)
         return "null";
     if (value === undefined)
         return "undefined";
-    if (value instanceof Values.Date)
+    if (value instanceof ProgramDate)
         return Number.isFinite(value.time) ? new Date(value.time).toISOString() : "Invalid Date";
-    if (value instanceof Values.RegExp)
+    if (value instanceof ProgramRegExp)
         return `/${value.regex.source}/${value.regex.flags}`;
-    if (value instanceof Values.Map)
+    if (value instanceof ProgramMap)
         return "[object Map]";
-    if (value instanceof Values.Set)
+    if (value instanceof ProgramSet)
         return "[object Set]";
-    if (value instanceof Values.URL)
+    if (value instanceof ProgramURL)
         return value.url.href;
-    if (value instanceof Values.URLSearchParams)
+    if (value instanceof ProgramURLSearchParams)
         return value.params.toString();
     if (value instanceof ProgramError) {
         // Match Error.prototype.toString: "name: message", or just one when the other is empty.
@@ -63,15 +41,15 @@ export const coerceToString = (value) => {
     return String(value);
 };
 export const coerceToNumber = (value) => {
-    if (value instanceof Values.Date)
+    if (value instanceof ProgramDate)
         return value.time;
-    if (Values.isValue(value))
+    if (isWrapper(value))
         return Number.NaN;
     if (value instanceof ProgramArray)
         return Number(coerceToString(value));
     return value !== null && typeof value === "object" ? Number.NaN : Number(value);
 };
-const coerce = (name, args, node) => {
+const coerce = (runner, name, args, node) => {
     // Native: Number() is 0 and String() is "", unlike their undefined-argument forms; the
     // other coercers match native through the undefined-argument path below.
     if (args.length === 0) {
@@ -81,7 +59,7 @@ const coerce = (name, args, node) => {
             return "";
     }
     const raw = args[0];
-    if (Values.isValue(raw)) {
+    if (isWrapper(raw)) {
         if (name === "Boolean")
             return true;
         if (name === "Number")
@@ -96,7 +74,7 @@ const coerce = (name, args, node) => {
             return parseInt(coerceToString(raw));
         return parseFloat(coerceToString(raw));
     }
-    const value = toProgram(raw, `${name} input`);
+    const value = toProgram(runner.prototypes, raw, `${name} input`);
     if (name === "Number")
         return coerceToNumber(value);
     if (name === "Boolean")
@@ -117,4 +95,4 @@ const coerce = (name, args, node) => {
     return coerceToString(value);
 };
 /** A global coercion function such as `Number` or `parseInt`. */
-export const coercion = (name, options = {}) => sync(name, (args, node) => toProgram(coerce(name, args, node), `${name} result`), options);
+export const coercion = (runner, name, length = 1) => fn(runner.prototypes, name, length, (_, args, node) => toProgram(runner.prototypes, coerce(runner, name, args, node), `${name} result`));

package/dist/stdlib/web.d.ts

@@ -1,4 +1,4 @@
-import { HostNamespace } from "../interpreter/host.js";
-export declare const atobGlobal: import("../interpreter/host.js").HostFunction<never>;
-export declare const btoaGlobal: import("../interpreter/host.js").HostFunction<never>;
-export declare const cryptoGlobal: HostNamespace;
+import { ProgramObject } from "../interpreter/objects.js";
+import type { Runner } from "../interpreter/runner.js";
+export declare const base64Global: <R>(runner: Runner<R>, name: "atob" | "btoa") => import("../interpreter/objects.js").NativeFunction<R>;
+export declare const cryptoGlobal: <R>(runner: Runner<R>) => ProgramObject;

package/dist/stdlib/web.js

@@ -1,20 +1,22 @@
-import { HostNamespace, sync } from "../interpreter/host.js";
+import { fn, methods } from "../interpreter/native.js";
 import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { ProgramObject } from "../interpreter/objects.js";
 import { coerceToString } from "./value.js";
-// WebIDL DOMString conversion: a missing argument is a TypeError, anything else stringifies.
-const base64 = (name) => sync(name, (args, node) => {
+// WebIDL DOMString conversion: a missing argument is a TypeError, anything else stringifies. Invalid input is a
+// TypeError as well; browsers throw a DOMException named InvalidCharacterError, which CodeMode does not have.
+export const base64Global = (runner, name) => fn(runner.prototypes, name, 1, (_, args, node) => {
     if (args.length === 0)
-        throw new InterpreterRuntimeError(`${name} requires 1 argument (a string)`, node).as("TypeError");
+        throw new InterpreterRuntimeError(`${name} requires 1 argument (a string)`, node);
     const input = coerceToString(args[0]);
     try {
         return name === "atob" ? atob(input) : btoa(input);
     }
     catch {
-        throw new InterpreterRuntimeError("The string contains invalid characters.", node).as("InvalidCharacterError");
+        throw new InterpreterRuntimeError("The string contains invalid characters.", node);
     }
 });
-export const atobGlobal = base64("atob");
-export const btoaGlobal = base64("btoa");
-export const cryptoGlobal = new HostNamespace("crypto", {
-    randomUUID: sync("crypto.randomUUID", () => crypto.randomUUID()),
-});
+export const cryptoGlobal = (runner) => {
+    const object = new ProgramObject(runner.prototypes.Object);
+    methods(runner.prototypes, object, [["randomUUID", 0, () => crypto.randomUUID()]]);
+    return object;
+};

package/dist/tool-runtime.d.ts

@@ -1,4 +1,5 @@
 import { Effect } from "effect";
+import type { Prototypes } from "./interpreter/intrinsics.js";
 import { type Namespace } from "./namespace.js";
 import { type Tool } from "./tool.js";
 import type { Tools } from "./tools.js";
@@ -65,5 +66,5 @@ export type ToolRuntime<R = never> = {
     readonly keys: (path: ReadonlyArray<string>) => ReadonlyArray<string>;
 };
 /** Per-execution call state over tools prepared once for the runtime. */
-export declare const make: <R>(prepared: Prepared<R>, maxToolCalls: number | undefined, hooks?: ToolCallHooks<R>) => ToolRuntime<R>;
+export declare const make: <R>(prepared: Prepared<R>, prototypes: Prototypes, maxToolCalls: number | undefined, hooks?: ToolCallHooks<R>) => ToolRuntime<R>;
 export * as ToolRuntime from "./tool-runtime.js";

package/dist/tool-runtime.js

@@ -184,7 +184,7 @@ const resolve = (root, path) => {
     return node.tool;
 };
 /** Per-execution call state over tools prepared once for the runtime. */
-export const make = (prepared, maxToolCalls, hooks) => {
+export const make = (prepared, prototypes, maxToolCalls, hooks) => {
     const calls = [];
     const root = prepared.root;
     const searchTool = makeSearchTool(prepared.searchIndex);
@@ -234,7 +234,7 @@ export const make = (prepared, maxToolCalls, hooks) => {
                     .join("\n")));
             }));
             return yield* Effect.try({
-                try: () => fromData(decodeToolOutput(tool, raw), `Result from tool '${name}'`),
+                try: () => fromData(prototypes, decodeToolOutput(tool, raw), `Result from tool '${name}'`),
                 catch: (cause) => new ToolRuntimeError("InvalidToolOutput", `Invalid output from tool '${name}': ${cause}`),
             });
         }), call);

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/codemode",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "Effect-native confined code execution over schema-described tools",
   "type": "module",
   "license": "MIT",

package/dist/interpreter/host.d.ts

@@ -1,41 +0,0 @@
-import { Effect } from "effect";
-import { type AstNode } from "./model.js";
-export type HostCall<R> = (args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
-type HostMember = (key: PropertyKey, node: AstNode) => unknown;
-type HostFunctionOptions<R> = {
-    readonly name: string;
-    readonly call: HostCall<R>;
-    /** `new name(...)`; without it `new` is unsupported syntax. */
-    readonly construct?: HostCall<R>;
-    /** Static members read through `name.key`; unknown keys read as `undefined` unless the function decides otherwise. */
-    readonly members?: Record<string, unknown> | HostMember;
-    /** `value instanceof name`; without it the operator rejects this right-hand side. */
-    readonly instanceOf?: (value: unknown) => boolean;
-    /** Whether callback sites (array methods, replacers, promise reactions) admit this function. Defaults to true. */
-    readonly callback?: boolean;
-};
-/** A host-implemented function value. `typeof` is "function". */
-export declare class HostFunction<R = never> {
-    readonly name: string;
-    readonly call: HostCall<R>;
-    readonly construct: HostCall<R> | undefined;
-    readonly member: HostMember;
-    readonly instanceOf: ((value: unknown) => boolean) | undefined;
-    readonly callback: boolean;
-    constructor(options: HostFunctionOptions<R>);
-}
-/** A host-implemented object of static members. `typeof` is "object" and it is not callable. */
-export declare class HostNamespace {
-    readonly name: string;
-    readonly member: HostMember;
-    constructor(name: string, members: Record<string, unknown> | HostMember);
-}
-export type SyncOptions = Omit<HostFunctionOptions<never>, "name" | "call">;
-type SyncImpl = (args: Array<unknown>, node: AstNode) => unknown;
-/** Lifts a synchronous implementation, which may throw `InterpreterRuntimeError`, into a host call. */
-export declare const syncCall: (impl: SyncImpl) => HostCall<never>;
-/** A synchronous host function. */
-export declare const sync: (name: string, impl: SyncImpl, options?: SyncOptions) => HostFunction<never>;
-/** The `call` of a constructor that JS requires to be invoked with `new`. */
-export declare const requiresNew: (name: string) => HostCall<never>;
-export {};

package/dist/interpreter/host.js

@@ -1,44 +0,0 @@
-import { Effect } from "effect";
-import { InterpreterRuntimeError } from "./model.js";
-/** A host-implemented function value. `typeof` is "function". */
-export class HostFunction {
-    name;
-    call;
-    construct;
-    member;
-    instanceOf;
-    callback;
-    constructor(options) {
-        this.name = options.name;
-        this.call = options.call;
-        this.construct = options.construct;
-        this.member = memberLookup(options.members);
-        this.instanceOf = options.instanceOf;
-        this.callback = options.callback ?? true;
-    }
-}
-/** A host-implemented object of static members. `typeof` is "object" and it is not callable. */
-export class HostNamespace {
-    name;
-    member;
-    constructor(name, members) {
-        this.name = name;
-        this.member = memberLookup(members);
-    }
-}
-const memberLookup = (members) => {
-    if (members === undefined)
-        return () => undefined;
-    if (typeof members === "function")
-        return members;
-    const table = new Map(Object.entries(members));
-    return (key) => (typeof key === "string" ? table.get(key) : undefined);
-};
-/** Lifts a synchronous implementation, which may throw `InterpreterRuntimeError`, into a host call. */
-export const syncCall = (impl) => (args, node) => Effect.sync(() => impl(args, node));
-/** A synchronous host function. */
-export const sync = (name, impl, options = {}) => new HostFunction({ name, call: syncCall(impl), ...options });
-/** The `call` of a constructor that JS requires to be invoked with `new`. */
-export const requiresNew = (name) => (_, node) => Effect.sync(() => {
-    throw new InterpreterRuntimeError(`Constructor ${name} requires 'new'.`, node).as("TypeError");
-});

package/dist/interpreter/methods.d.ts

@@ -1,4 +0,0 @@
-import { Effect } from "effect";
-import { type AstNode, IntrinsicReference } from "./model.js";
-import { type Runner } from "./runner.js";
-export declare const invokeIntrinsic: <R>(runner: Runner<R>, ref: IntrinsicReference, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;