@opencode/codemode 0.0.0-dev-19530 → 2.0.0

package/dist/stdlib/value.d.ts

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

package/dist/stdlib/value.js

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

package/dist/stdlib/web.d.ts

@@ -1,4 +1,4 @@
-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;
+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;

package/dist/stdlib/web.js

@@ -1,22 +1,20 @@
-import { fn, methods } from "../interpreter/native.js";
+import { HostNamespace, sync } from "../interpreter/host.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. 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) => {
+// WebIDL DOMString conversion: a missing argument is a TypeError, anything else stringifies.
+const base64 = (name) => sync(name, (args, node) => {
     if (args.length === 0)
-        throw new InterpreterRuntimeError(`${name} requires 1 argument (a string)`, node);
+        throw new InterpreterRuntimeError(`${name} requires 1 argument (a string)`, node).as("TypeError");
     const input = coerceToString(args[0]);
     try {
         return name === "atob" ? atob(input) : btoa(input);
     }
     catch {
-        throw new InterpreterRuntimeError("The string contains invalid characters.", node);
+        throw new InterpreterRuntimeError("The string contains invalid characters.", node).as("InvalidCharacterError");
     }
 });
-export const cryptoGlobal = (runner) => {
-    const object = new ProgramObject(runner.prototypes.Object);
-    methods(runner.prototypes, object, [["randomUUID", 0, () => crypto.randomUUID()]]);
-    return object;
-};
+export const atobGlobal = base64("atob");
+export const btoaGlobal = base64("btoa");
+export const cryptoGlobal = new HostNamespace("crypto", {
+    randomUUID: sync("crypto.randomUUID", () => crypto.randomUUID()),
+});

package/dist/tool-runtime.d.ts

@@ -1,5 +1,4 @@
 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";
@@ -66,5 +65,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>, prototypes: Prototypes, maxToolCalls: number | undefined, hooks?: ToolCallHooks<R>) => ToolRuntime<R>;
+export declare const make: <R>(prepared: Prepared<R>, 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, prototypes, maxToolCalls, hooks) => {
+export const make = (prepared, maxToolCalls, hooks) => {
     const calls = [];
     const root = prepared.root;
     const searchTool = makeSearchTool(prepared.searchIndex);
@@ -234,7 +234,7 @@ export const make = (prepared, prototypes, maxToolCalls, hooks) => {
                     .join("\n")));
             }));
             return yield* Effect.try({
-                try: () => fromData(prototypes, decodeToolOutput(tool, raw), `Result from tool '${name}'`),
+                try: () => fromData(decodeToolOutput(tool, raw), `Result from tool '${name}'`),
                 catch: (cause) => new ToolRuntimeError("InvalidToolOutput", `Invalid output from tool '${name}': ${cause}`),
             });
         }), call);

package/dist/values.d.ts

@@ -0,0 +1,37 @@
+export * as Values from "./values.js";
+import type { Fiber } from "effect";
+/**
+ * Runtime values the interpreter recognizes by class. Each wraps the host value it stands for,
+ * so hosts construct these to hand a value to a program and receive them back unchanged.
+ */
+export declare class Promise {
+    readonly fiber: Fiber.Fiber<unknown, unknown>;
+    constructor(fiber: Fiber.Fiber<unknown, unknown>);
+}
+export declare class Date {
+    time: number;
+    constructor(time: number);
+}
+export declare class RegExp {
+    readonly regex: globalThis.RegExp;
+    constructor(pattern: string, flags: string);
+    get lastIndex(): unknown;
+    set lastIndex(value: unknown);
+}
+export declare class Map {
+    readonly map: globalThis.Map<unknown, unknown>;
+}
+export declare class Set {
+    readonly set: globalThis.Set<unknown>;
+}
+export declare class URLSearchParams {
+    readonly params: globalThis.URLSearchParams;
+    constructor(params: globalThis.URLSearchParams);
+}
+export declare class URL {
+    readonly url: globalThis.URL;
+    readonly searchParams: URLSearchParams;
+    constructor(url: globalThis.URL);
+}
+/** Data-like runtime values; excludes Promise, which never crosses a boundary. */
+export declare const isValue: (value: unknown) => value is Date | RegExp | Map | Set | URL | URLSearchParams;

package/dist/values.js

@@ -0,0 +1,56 @@
+export * as Values from "./values.js";
+/**
+ * Runtime values the interpreter recognizes by class. Each wraps the host value it stands for,
+ * so hosts construct these to hand a value to a program and receive them back unchanged.
+ */
+export class Promise {
+    fiber;
+    constructor(fiber) {
+        this.fiber = fiber;
+    }
+}
+export class Date {
+    time;
+    constructor(time) {
+        this.time = time;
+    }
+}
+export class RegExp {
+    regex;
+    constructor(pattern, flags) {
+        this.regex = new globalThis.RegExp(pattern, flags);
+    }
+    get lastIndex() {
+        return Reflect.get(this.regex, "lastIndex");
+    }
+    set lastIndex(value) {
+        Reflect.set(this.regex, "lastIndex", value);
+    }
+}
+export class Map {
+    map = new globalThis.Map();
+}
+export class Set {
+    set = new globalThis.Set();
+}
+export class URLSearchParams {
+    params;
+    constructor(params) {
+        this.params = params;
+    }
+}
+export class URL {
+    url;
+    searchParams;
+    constructor(url) {
+        this.url = url;
+        this.searchParams = new URLSearchParams(url.searchParams);
+    }
+}
+/** Data-like runtime values; excludes Promise, which never crosses a boundary. */
+export const isValue = (value) => value instanceof Date ||
+    value instanceof RegExp ||
+    value instanceof Map ||
+    value instanceof Set ||
+    value instanceof URL ||
+    value instanceof URLSearchParams;

package/package.json

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

package/dist/interpreter/generators.d.ts

@@ -1,4 +0,0 @@
-import type { PromiseRuntime } from "./promises.js";
-import type { Runner } from "./runner.js";
-/** `next`/`return`/`throw` on the generator prototypes; async generators answer with promises. */
-export declare const generatorGlobals: <R>(runner: Runner<R>, promises: PromiseRuntime<R>) => void;

package/dist/interpreter/generators.js

@@ -1,25 +0,0 @@
-import { Effect } from "effect";
-import { fn, methods, receiver } from "./native.js";
-import { AsyncIteratorSymbol, IteratorSymbol } from "./model.js";
-import { define, hidden, ProgramGenerator } from "./objects.js";
-/** `next`/`return`/`throw` on the generator prototypes; async generators answer with promises. */
-export const generatorGlobals = (runner, promises) => {
-    const protos = runner.prototypes;
-    const install = (asynchronous) => {
-        const proto = asynchronous ? protos.AsyncGenerator : protos.Generator;
-        const label = asynchronous ? "AsyncGenerator" : "Generator";
-        const request = (kind) => [
-            kind,
-            1,
-            (thisValue, args, node) => {
-                const generator = receiver(ProgramGenerator, thisValue, `${label}.prototype.${kind}`, node);
-                const requested = generator.request(kind, args[0], node);
-                return generator.asynchronous ? promises.create(requested) : requested;
-            },
-        ];
-        methods(protos, proto, [request("next"), request("return"), request("throw")]);
-        define(asynchronous ? protos.AsyncIterator : protos.Iterator, asynchronous ? AsyncIteratorSymbol : IteratorSymbol, fn(protos, asynchronous ? "[Symbol.asyncIterator]" : "[Symbol.iterator]", 0, (thisValue) => thisValue), hidden);
-    };
-    install(false);
-    install(true);
-};

package/dist/interpreter/intrinsics.d.ts

@@ -1,13 +0,0 @@
-import { ProgramError, ProgramObject } from "./objects.js";
-export declare const errorTypes: readonly ["Error", "TypeError", "RangeError", "SyntaxError", "ReferenceError", "EvalError", "URIError", "AggregateError"];
-export type ErrorType = (typeof errorTypes)[number];
-export declare const isErrorType: (name: string) => name is ErrorType;
-declare const builtins: readonly ["Object", "Function", "Array", "String", "Number", "Boolean", "Date", "RegExp", "Map", "Set", "URL", "URLSearchParams", "Promise", "Iterator", "AsyncIterator", "Generator", "AsyncGenerator"];
-/**
- * The built-in prototype objects of one runtime, allocated empty in dependency order. The globals populate them
- * and attach their constructors when the runtime is built.
- */
-export type Prototypes = Readonly<Record<(typeof builtins)[number] | ErrorType, ProgramObject>>;
-export declare const createErrorValue: (prototype: ProgramObject, message: string | undefined) => ProgramError;
-export declare const createPrototypes: () => Prototypes;
-export {};

package/dist/interpreter/intrinsics.js

@@ -1,82 +0,0 @@
-import { Effect } from "effect";
-import { define, hidden, NativeFunction, ProgramArray, ProgramError, ProgramObject } from "./objects.js";
-export const errorTypes = [
-    "Error",
-    "TypeError",
-    "RangeError",
-    "SyntaxError",
-    "ReferenceError",
-    "EvalError",
-    "URIError",
-    "AggregateError",
-];
-export const isErrorType = (name) => errorTypes.includes(name);
-const builtins = [
-    "Object",
-    "Function",
-    "Array",
-    "String",
-    "Number",
-    "Boolean",
-    "Date",
-    "RegExp",
-    "Map",
-    "Set",
-    "URL",
-    "URLSearchParams",
-    "Promise",
-    "Iterator",
-    "AsyncIterator",
-    "Generator",
-    "AsyncGenerator",
-];
-export const createErrorValue = (prototype, message) => {
-    const value = new ProgramError(prototype);
-    if (message !== undefined)
-        define(value, "message", message, hidden);
-    return value;
-};
-export const createPrototypes = () => {
-    const object = new ProgramObject(null);
-    // Function.prototype is itself callable and returns undefined.
-    const fn = new NativeFunction(object, { name: "", call: () => Effect.undefined });
-    const plain = () => new ProgramObject(object);
-    const error = plain();
-    define(error, "name", "Error", hidden);
-    define(error, "message", "", hidden);
-    const derived = (type) => {
-        const proto = new ProgramObject(error);
-        define(proto, "name", type, hidden);
-        define(proto, "message", "", hidden);
-        return proto;
-    };
-    const iterator = plain();
-    const asyncIterator = plain();
-    return {
-        Object: object,
-        Function: fn,
-        Array: new ProgramArray(object),
-        String: plain(),
-        Number: plain(),
-        Boolean: plain(),
-        Date: plain(),
-        RegExp: plain(),
-        Map: plain(),
-        Set: plain(),
-        URL: plain(),
-        URLSearchParams: plain(),
-        Promise: plain(),
-        Iterator: iterator,
-        AsyncIterator: asyncIterator,
-        Generator: new ProgramObject(iterator),
-        AsyncGenerator: new ProgramObject(asyncIterator),
-        Error: error,
-        TypeError: derived("TypeError"),
-        RangeError: derived("RangeError"),
-        SyntaxError: derived("SyntaxError"),
-        ReferenceError: derived("ReferenceError"),
-        EvalError: derived("EvalError"),
-        URIError: derived("URIError"),
-        AggregateError: derived("AggregateError"),
-    };
-};

package/dist/interpreter/native.d.ts

@@ -1,19 +0,0 @@
-import { Effect } from "effect";
-import type { Prototypes } from "./intrinsics.js";
-import { type AstNode } from "./model.js";
-import { type Callable, NativeFunction, type NativeOptions, ProgramObject } from "./objects.js";
-/** A native function body: a plain value, a thrown `InterpreterRuntimeError`, or an Effect. */
-export type Impl = (thisValue: unknown, args: Array<unknown>, node: AstNode) => unknown;
-export declare const native: <R>(protos: Prototypes, options: NativeOptions<R>) => NativeFunction<R>;
-export declare const fn: <R>(protos: Prototypes, name: string, length: number, impl: Impl) => NativeFunction<R>;
-export type Method = readonly [name: string, length: number, impl: Impl];
-export declare const methods: (protos: Prototypes, target: ProgramObject, table: ReadonlyArray<Method>) => void;
-export declare const constants: (target: ProgramObject, table: Record<string, unknown>) => void;
-/** A constructor wired to its prototype: `C.prototype === proto` and `proto.constructor === C`. */
-export declare const constructor: <R>(protos: Prototypes, proto: ProgramObject, options: NativeOptions<R>) => NativeFunction<R>;
-/** The `call` of a constructor that JS requires to be invoked with `new`. */
-export declare const requiresNew: (name: string) => (_: unknown, __: Array<unknown>, node: AstNode) => Effect.Effect<never, unknown, never>;
-/** The instance prototype for `new` via `newTarget.prototype`, falling back to the built-in's own. */
-export declare const prototypeFrom: (newTarget: Callable, fallback: ProgramObject) => ProgramObject;
-/** Narrows a method receiver to the built-in it belongs to, or throws the TypeError JS would. */
-export declare const receiver: <T extends ProgramObject>(cls: abstract new (...args: never) => T, thisValue: unknown, method: string, node?: AstNode) => T;

package/dist/interpreter/native.js

@@ -1,40 +0,0 @@
-import { Effect } from "effect";
-import { InterpreterRuntimeError } from "./model.js";
-import { define, frozen, hidden, NativeFunction, ProgramObject } from "./objects.js";
-import { describeValue } from "./references.js";
-const lift = (impl) => (thisValue, args, node) => Effect.suspend(() => {
-    const result = impl(thisValue, args, node);
-    return Effect.isEffect(result) ? result : Effect.succeed(result);
-});
-export const native = (protos, options) => new NativeFunction(protos.Function, options);
-export const fn = (protos, name, length, impl) => native(protos, { name, length, call: lift(impl) });
-export const methods = (protos, target, table) => {
-    for (const [name, length, impl] of table)
-        define(target, name, fn(protos, name, length, impl), hidden);
-};
-export const constants = (target, table) => {
-    for (const [name, value] of Object.entries(table))
-        define(target, name, value, frozen);
-};
-/** A constructor wired to its prototype: `C.prototype === proto` and `proto.constructor === C`. */
-export const constructor = (protos, proto, options) => {
-    const ctor = native(protos, options);
-    define(ctor, "prototype", proto, frozen);
-    define(proto, "constructor", ctor, hidden);
-    return ctor;
-};
-/** 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);
-});
-/** The instance prototype for `new` via `newTarget.prototype`, falling back to the built-in's own. */
-export const prototypeFrom = (newTarget, fallback) => {
-    const proto = newTarget.props.get("prototype");
-    return proto !== undefined && "value" in proto && proto.value instanceof ProgramObject ? proto.value : fallback;
-};
-/** Narrows a method receiver to the built-in it belongs to, or throws the TypeError JS would. */
-export const receiver = (cls, thisValue, method, node) => {
-    if (thisValue instanceof cls)
-        return thisValue;
-    throw new InterpreterRuntimeError(`${method} called on incompatible receiver ${describeValue(thisValue)}.`, node);
-};