@opencode/codemode 0.0.0-dev-19643 → 0.0.0-dev-19644

package/dist/codemode.d.ts

@@ -30,7 +30,7 @@ export type ResolvedExecutionLimits = {
 export type Options<Provided extends Record<string, unknown> = {}> = ToolRuntime.ToolCallHooks<Services<Provided>> & {
     /** Explicit tools exposed to the program as `tools`. */
     tools?: Provided & Tools<Services<Provided>>;
-    /** Host classes and functions exposed as globals; see `Extension.make`. */
+    /** Host functions exposed as globals; see `Extension.make`. */
     extensions?: ReadonlyArray<Extension>;
     /** Resource limits enforced on each execution. */
     limits?: ExecutionLimits;

package/dist/extension.d.ts

@@ -1,12 +1,11 @@
 export * as Extension from "./extension.js";
 /**
- * Host classes and functions a program uses directly, like JavaScript. Values crossing in either direction are
- * converted, never shared: plain data is copied, instances of the classes stay on the host behind program-side
- * handles. Extension calls are not tool calls.
+ * Host functions a program calls directly as globals. Values crossing in either direction are converted, never
+ * shared: arguments come in as copies, results go out as copies, and a function inside a result is callable the
+ * same way. Extension calls are not tool calls.
  */
 export type Extension = {
     readonly name: string;
-    /** Each value is a class or a function; everything on a class is exposed, including statics and accessors. */
     readonly globals: Readonly<Record<string, Function>>;
 };
 export declare const make: (options: Extension) => Extension;

package/dist/extension.js

@@ -2,7 +2,7 @@ export * as Extension from "./extension.js";
 export const make = (options) => {
     for (const [name, value] of Object.entries(options.globals)) {
         if (typeof value !== "function") {
-            throw new TypeError(`Extension "${options.name}" global "${name}" must be a class or a function.`);
+            throw new TypeError(`Extension "${options.name}" global "${name}" must be a function.`);
         }
     }
     return { name: options.name, globals: { ...options.globals } };

package/dist/interpreter/extensions.d.ts

@@ -1,8 +1,8 @@
 import type { Extension } from "../extension.js";
 import type { Interpreter } from "./interpreter.js";
 /**
- * The global bindings of one run's extensions. Everything crossing the boundary is converted: plain data is
- * copied, built-in wrappers are copied, instances of exposed classes travel as handles, and a host Promise becomes
- * a program promise. Prototypes, constructors, and handle identity are all per run.
+ * The global bindings of one run's extensions. Everything crossing the boundary is converted: plain data and
+ * built-in wrappers are copied, a host function becomes a program function whose calls cross the same way, and a
+ * host Promise becomes a program promise.
  */
 export declare const extensionGlobals: <R>(ctx: Interpreter<R>, extensions: ReadonlyArray<Extension>) => ReadonlyArray<readonly [string, unknown]>;

package/dist/interpreter/extensions.js

@@ -3,26 +3,16 @@ import { coerceToString } from "../stdlib/value.js";
 import { createErrorValue, isErrorType } from "./intrinsics.js";
 import { MAX_VALUE_DEPTH } from "./limits.js";
 import { Throw, typeError } from "./model.js";
-import { constructor, fn } from "./native.js";
-import { Callable, define, defineAccessor, entries, get, hidden, Arr, Bytes, DateObj, ErrorObj, GeneratorObj, Handle, MapObj, Obj, PromiseObj, RegExpObj, SetObj, URLObj, URLSearchParamsObj, } from "./objects.js";
+import { fn } from "./native.js";
+import { Callable, define, entries, get, Arr, Bytes, DateObj, ErrorObj, GeneratorObj, MapObj, Obj, PromiseObj, RegExpObj, SetObj, URLObj, URLSearchParamsObj, } from "./objects.js";
 import { describeValue } from "./references.js";
-const isClass = (value) => typeof value === "function" && typeof value.prototype === "object" && value.prototype !== null;
-// Own keys the native function already carries.
-const ownFunctionKeys = new Set(["length", "name", "prototype"]);
-const ownPrototypeKeys = new Set(["constructor"]);
 /**
- * The global bindings of one run's extensions. Everything crossing the boundary is converted: plain data is
- * copied, built-in wrappers are copied, instances of exposed classes travel as handles, and a host Promise becomes
- * a program promise. Prototypes, constructors, and handle identity are all per run.
+ * The global bindings of one run's extensions. Everything crossing the boundary is converted: plain data and
+ * built-in wrappers are copied, a host function becomes a program function whose calls cross the same way, and a
+ * host Promise becomes a program promise.
  */
 export const extensionGlobals = (ctx, extensions) => {
     const builtins = ctx.builtins;
-    const classes = new Set(extensions.flatMap((extension) => Object.values(extension.globals)).filter(isClass));
-    // Host prototype object → this run's program prototype, so an instance wraps as its most-derived exposed class.
-    const protoOf = new Map();
-    const exposed = new Map();
-    const classOf = new Map();
-    const handles = new WeakMap();
     const toHost = (value, label, depth = 0, seen = new Set()) => {
         if (depth > MAX_VALUE_DEPTH)
             throw typeError(`${label} exceeds the maximum value depth of ${MAX_VALUE_DEPTH}.`);
@@ -31,8 +21,6 @@ export const extensionGlobals = (ctx, extensions) => {
                 return value;
             throw typeError(`${label} contains ${describeValue(value)}, which cannot be passed to an extension.`);
         }
-        if (value instanceof Handle)
-            return value.instance;
         if (value instanceof Bytes)
             return new Uint8Array(value.bytes);
         if (value instanceof DateObj)
@@ -58,7 +46,7 @@ export const extensionGlobals = (ctx, extensions) => {
             const name = coerceToString(get(value, "name"));
             const message = get(value, "message");
             const text = message === undefined ? "" : coerceToString(message);
-            return name === "AggregateError" ? new AggregateError([], text) : new (hostErrors[name] ?? Error)(text);
+            return name === "AggregateError" ? new AggregateError([], text) : new (hostErrors.get(name) ?? Error)(text);
         }
         if (seen.has(value))
             throw typeError(`${label} contains a circular value.`);
@@ -76,16 +64,9 @@ export const extensionGlobals = (ctx, extensions) => {
             throw typeError(`${label} exceeds the maximum value depth of ${MAX_VALUE_DEPTH}.`);
         if (isPrimitive(value))
             return value;
+        if (typeof value === "function")
+            return wrap(value, label);
         if (value !== null && typeof value === "object") {
-            const existing = handles.get(value);
-            if (existing !== undefined)
-                return existing;
-            const proto = handlePrototype(value);
-            if (proto !== undefined) {
-                const handle = new Handle(proto, value);
-                handles.set(value, handle);
-                return handle;
-            }
             if (value instanceof Date)
                 return new DateObj(builtins.Date, value.getTime());
             if (value instanceof RegExp)
@@ -102,24 +83,24 @@ export const extensionGlobals = (ctx, extensions) => {
             if (value instanceof URLSearchParams) {
                 return new URLSearchParamsObj(builtins.URLSearchParams, new URLSearchParams(value));
             }
-            const next = (item) => fromHost(item, label, depth + 1, seen);
+            const next = (item, path) => fromHost(item, path, depth + 1, seen);
             if (value instanceof Map) {
                 const wrapped = new MapObj(builtins.Map);
                 for (const [key, item] of value)
-                    wrapped.map.set(next(key), next(item));
+                    wrapped.map.set(next(key, label), next(item, label));
                 return wrapped;
             }
             if (value instanceof Set) {
                 const wrapped = new SetObj(builtins.Set);
                 for (const item of value)
-                    wrapped.set.add(next(item));
+                    wrapped.set.add(next(item, label));
                 return wrapped;
             }
             if (seen.has(value))
                 throw typeError(`${label} produced a circular value.`);
             seen.add(value);
             if (Array.isArray(value)) {
-                const copied = new Arr(builtins.Array, value.map(next));
+                const copied = new Arr(builtins.Array, value.map((item, index) => next(item, `${label}[${index}]`)));
                 seen.delete(value);
                 return copied;
             }
@@ -127,139 +108,39 @@ export const extensionGlobals = (ctx, extensions) => {
             if (prototype === Object.prototype || prototype === null) {
                 const copied = new Obj(builtins.Object);
                 for (const [key, item] of Object.entries(value))
-                    define(copied, key, next(item));
+                    define(copied, key, next(item, `${label}.${key}`));
                 seen.delete(value);
                 return copied;
             }
         }
         throw typeError(`${label} produced ${describeHost(value)}, which the program cannot hold.`);
     };
-    const handlePrototype = (instance) => {
-        for (let level = Object.getPrototypeOf(instance); level !== null; level = Object.getPrototypeOf(level)) {
-            const proto = protoOf.get(level);
-            if (proto !== undefined)
-                return proto;
-        }
-        return undefined;
-    };
-    // Runs host code with already-converted inputs. Whatever it returns, resolves, throws, or rejects with crosses
-    // the same way, so the program catches what the author threw.
-    const invoke = (run, label) => {
+    // A host function as a program function: arguments cross in, and whatever it returns, resolves, throws, or
+    // rejects with crosses out, so the program catches what the author threw.
+    const wrap = (value, label) => fn(builtins, value.name, value.length, (_, values) => {
+        const converted = values.map((item, index) => toHost(item, `Argument ${index + 1} to ${label}`));
         const thrown = (reason) => new Throw(fromHost(reason, label));
         let result;
         try {
-            result = run();
+            result = value.apply(undefined, converted);
         }
         catch (reason) {
             return Effect.fail(thrown(reason));
         }
         if (!(result instanceof Promise))
-            return Effect.succeed(fromHost(result, label));
+            return fromHost(result, label);
         return ctx.pending.create(Effect.map(Effect.tryPromise({ try: () => result, catch: thrown }), (settled) => fromHost(settled, label)));
-    };
-    const args = (values, label) => values.map((value, index) => toHost(value, `Argument ${index + 1} to ${label}`));
-    // Own members of each level from `from` up to (excluding) `root`, child first, as JS resolves them.
-    const members = (target, from, root, skip, label, receiver) => {
-        for (let level = from; level !== null && level !== root; level = Object.getPrototypeOf(level)) {
-            for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(level))) {
-                if (skip.has(key) || target.props.has(key))
-                    continue;
-                const name = `${label}.${key}`;
-                if (typeof descriptor.value === "function") {
-                    const method = descriptor.value;
-                    const impl = (thisValue, values) => {
-                        const self = receiver(thisValue, name);
-                        const converted = args(values, name);
-                        return invoke(() => method.apply(self, converted), name);
-                    };
-                    define(target, key, fn(builtins, key, method.length, impl), hidden);
-                    continue;
-                }
-                // Data properties stay host-side: a program write to one would change the host class itself.
-                if ("value" in descriptor)
-                    continue;
-                const get = descriptor.get;
-                const set = descriptor.set;
-                defineAccessor(target, key, get === undefined
-                    ? undefined
-                    : (thisValue) => {
-                        const value = get.call(receiver(thisValue, name));
-                        if (value instanceof Promise)
-                            throw typeError(`${name} returned a Promise; a getter must be synchronous.`);
-                        return fromHost(value, name);
-                    }, set === undefined
-                    ? undefined
-                    : (thisValue, value) => {
-                        set.call(receiver(thisValue, name), toHost(value, `${name} value`));
-                    });
-            }
-        }
-    };
-    const expose = (cls) => {
-        const existing = exposed.get(cls);
-        if (existing !== undefined)
-            return existing;
-        const ancestor = exposedAncestor(cls);
-        const base = ancestor === undefined ? undefined : expose(ancestor);
-        const proto = new Obj(base === undefined ? builtins.Object : base.proto);
-        protoOf.set(cls.prototype, proto);
-        const name = cls.name;
-        const ctor = constructor(builtins, proto, {
-            name,
-            length: cls.length,
-            call: (_, values) => {
-                const converted = args(values, name);
-                return invoke(() => cls.apply(undefined, converted), name);
-            },
-            construct: (values) => {
-                const label = `new ${name}`;
-                const construct = cls;
-                const converted = args(values, label);
-                return invoke(() => new construct(...converted), label);
-            },
-        });
-        if (base !== undefined)
-            ctor.proto = base.ctor;
-        const entry = { ctor, proto };
-        exposed.set(cls, entry);
-        classOf.set(ctor, cls);
-        // A static called through an exposed subclass sees that subclass as `this`, like JS.
-        members(ctor, cls, ancestor ?? Function.prototype, ownFunctionKeys, name, (thisValue) => {
-            const called = classOf.get(thisValue);
-            return called !== undefined && (called === cls || called.prototype instanceof cls) ? called : cls;
-        });
-        members(proto, cls.prototype, ancestor?.prototype ?? Object.prototype, ownPrototypeKeys, `${name}.prototype`, (thisValue, member) => {
-            if (thisValue instanceof Handle && thisValue.instance instanceof cls)
-                return thisValue.instance;
-            throw typeError(`Illegal invocation: ${member} called on ${describeValue(thisValue)}.`);
-        });
-        return entry;
-    };
-    const exposedAncestor = (cls) => {
-        for (let level = Object.getPrototypeOf(cls); isClass(level); level = Object.getPrototypeOf(level)) {
-            if (classes.has(level))
-                return level;
-        }
-        return undefined;
-    };
-    return extensions.flatMap((extension) => Object.entries(extension.globals).map(([name, value]) => {
-        if (isClass(value))
-            return [name, expose(value).ctor];
-        const impl = (_, values) => {
-            const converted = args(values, name);
-            return invoke(() => value.apply(undefined, converted), name);
-        };
-        return [name, fn(builtins, name, value.length, impl)];
-    }));
-};
-const hostErrors = {
-    TypeError,
-    RangeError,
-    SyntaxError,
-    ReferenceError,
-    EvalError,
-    URIError,
+    });
+    return extensions.flatMap((extension) => Object.entries(extension.globals).map(([name, value]) => [name, wrap(value, name)]));
 };
+const hostErrors = new Map([
+    ["TypeError", TypeError],
+    ["RangeError", RangeError],
+    ["SyntaxError", SyntaxError],
+    ["ReferenceError", ReferenceError],
+    ["EvalError", EvalError],
+    ["URIError", URIError],
+]);
 // The primitives the interpreter operates on; symbols and BigInts are not among them.
 const isPrimitive = (value) => value === null ||
     value === undefined ||
@@ -267,8 +148,6 @@ const isPrimitive = (value) => value === null ||
     typeof value === "number" ||
     typeof value === "boolean";
 const describeHost = (value) => {
-    if (typeof value === "function")
-        return "a function";
     if (typeof value !== "object" || value === null)
         return `a ${typeof value}`;
     const name = value.constructor?.name;

package/dist/interpreter/objects.d.ts

@@ -109,11 +109,6 @@ export declare class Bytes extends Obj {
     readonly bytes: Uint8Array;
     constructor(proto: Obj, bytes: Uint8Array);
 }
-/** An instance of an extension class: the host object lives in a field no property path reaches. */
-export declare class Handle extends Obj {
-    readonly instance: object;
-    constructor(proto: Obj, instance: object);
-}
 /** 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 | Bytes;
 export declare const parseArrayIndex: (key: string | number) => number | undefined;

package/dist/interpreter/objects.js

@@ -123,14 +123,6 @@ export class Bytes extends Obj {
         this.bytes = bytes;
     }
 }
-/** An instance of an extension class: the host object lives in a field no property path reaches. */
-export class Handle extends Obj {
-    instance;
-    constructor(proto, instance) {
-        super(proto);
-        this.instance = instance;
-    }
-}
 /** Built-in objects that wrap a host value; data-like, but never plain data. */
 export const isWrapper = (value) => value instanceof DateObj ||
     value instanceof RegExpObj ||

package/dist/interpreter/references.js

@@ -1,10 +1,9 @@
 import { ToolReference } from "../tool-runtime.js";
 import { invalidData } from "./model.js";
-import { Callable, getOwn, isWrapper, ownKeys, Arr, Bytes, DateObj, GeneratorObj, Handle, MapObj, Obj, PromiseObj, RegExpObj, SetObj, URLObj, URLSearchParamsObj, } from "./objects.js";
+import { Callable, getOwn, isWrapper, ownKeys, Arr, Bytes, DateObj, GeneratorObj, MapObj, Obj, PromiseObj, RegExpObj, SetObj, URLObj, URLSearchParamsObj, } from "./objects.js";
 /** Values that cannot cross the data boundary. */
 export const isRuntimeReference = (value) => value instanceof Callable ||
     value instanceof GeneratorObj ||
-    value instanceof Handle ||
     value instanceof ToolReference ||
     value instanceof PromiseObj ||
     isWrapper(value);
@@ -68,8 +67,6 @@ export const describeValue = (value) => {
         return "a Uint8Array";
     if (value instanceof GeneratorObj)
         return "a generator";
-    if (value instanceof Handle)
-        return `a ${value.instance.constructor.name}`;
     if (isRuntimeReference(value))
         return "a function";
     if (typeof value === "object")

package/package.json

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