@opencode/codemode 0.0.0-dev-19602 → 0.0.0-dev-19607

package/dist/codemode.d.ts

@@ -1,4 +1,5 @@
 import { Effect, Schema } from "effect";
+import type { Extension } from "./extension.js";
 import { type Services, type ToolDescription, ToolRuntime } from "./tool-runtime.js";
 import type { Tools } from "./tools.js";
 /** A tool call admitted during an execution. */
@@ -29,6 +30,8 @@ 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`. */
+    extensions?: ReadonlyArray<Extension>;
     /** Resource limits enforced on each execution. */
     limits?: ExecutionLimits;
 };

package/dist/codemode.js

@@ -1,5 +1,7 @@
 import { Effect, Schema } from "effect";
 import { executeProgram } from "./interpreter/execute.js";
+import { extensionGlobals } from "./interpreter/extensions.js";
+import { globalNames } from "./interpreter/globals.js";
 import { ToolRuntime } from "./tool-runtime.js";
 /** Signature-construction helpers for host-owned catalog instructions. */
 export { searchSignature, toolExpression } from "./tool-runtime.js";
@@ -59,8 +61,17 @@ export const execute = (options) => make(options).execute(options.code);
 export const make = (options = {}) => {
     const prepared = ToolRuntime.prepare((options.tools ?? {}));
     const limits = resolveExecutionLimits(options.limits);
+    const extensions = options.extensions ?? [];
+    const bound = new Set(globalNames);
+    for (const extension of extensions) {
+        for (const name of Object.keys(extension.globals)) {
+            if (bound.has(name))
+                throw new TypeError(`Extension "${extension.name}" global "${name}" is already defined.`);
+            bound.add(name);
+        }
+    }
     return {
         catalog: prepared.catalog,
-        execute: (code) => executeProgram(code, prepared, limits, options),
+        execute: (code) => executeProgram(code, prepared, limits, options, (host) => extensionGlobals(host, extensions)),
     };
 };

package/dist/data.d.ts

@@ -1,6 +1,7 @@
 export * as Data from "./data.js";
 import type { DiagnosticKind } from "./codemode.js";
 import type { Prototypes } from "./interpreter/intrinsics.js";
+export declare const MAX_VALUE_DEPTH = 32;
 export declare class ToolRuntimeError extends Error {
     readonly kind: Extract<DiagnosticKind, "UnknownTool" | "InvalidToolInput" | "InvalidToolOutput" | "InvalidDataValue" | "ToolCallLimitExceeded">;
     readonly suggestions: ReadonlyArray<string>;

package/dist/data.js

@@ -1,6 +1,6 @@
 export * as Data from "./data.js";
-import { Callable, define, entries, get, isWrapper, parseArrayIndex, ProgramArray, ProgramDate, ProgramError, ProgramGenerator, ProgramMap, ProgramObject, ProgramPromise, ProgramRegExp, ProgramSet, ProgramURL, ProgramURLSearchParams, } from "./interpreter/objects.js";
-const MAX_VALUE_DEPTH = 32;
+import { Callable, define, entries, get, isWrapper, parseArrayIndex, ProgramArray, ProgramDate, ProgramError, ProgramGenerator, ProgramHandle, ProgramMap, ProgramObject, ProgramPromise, ProgramRegExp, ProgramSet, ProgramURL, ProgramURLSearchParams, } from "./interpreter/objects.js";
+export const MAX_VALUE_DEPTH = 32;
 export class ToolRuntimeError extends Error {
     kind;
     suggestions;
@@ -49,6 +49,13 @@ const copy = (value, label, mode, depth, seen, protos, stripProto = true) => {
     if ((value instanceof Callable || value instanceof ProgramGenerator) && mode !== "program") {
         throw new ToolRuntimeError("InvalidDataValue", `${label} must contain data only.`);
     }
+    if (value instanceof ProgramHandle && mode !== "program") {
+        throw new ToolRuntimeError("InvalidDataValue", `${label} contains a ${value.instance.constructor.name}, which only extension functions accept.`);
+    }
+    // Host-produced input never holds program objects; one arriving here would come back as a host object.
+    if (value instanceof ProgramObject && mode === "data") {
+        throw new ToolRuntimeError("InvalidDataValue", `${label} must be host data, not a program value.`);
+    }
     if (protos !== undefined && mode === "program") {
         if (value instanceof ProgramObject)
             return value;

package/dist/extension.d.ts

@@ -0,0 +1,12 @@
+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.
+ */
+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

@@ -0,0 +1,9 @@
+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.`);
+        }
+    }
+    return { name: options.name, globals: { ...options.globals } };
+};

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * as CodeMode from "./codemode.js";
+export * as Extension from "./extension.js";
 export * as Namespace from "./namespace.js";
 export * as Tool from "./tool.js";
 export * as OpenAPI from "./openapi/index.js";

package/dist/index.js

@@ -1,4 +1,5 @@
 export * as CodeMode from "./codemode.js";
+export * as Extension from "./extension.js";
 export * as Namespace from "./namespace.js";
 export * as Tool from "./tool.js";
 export * as OpenAPI from "./openapi/index.js";

package/dist/interpreter/extensions.d.ts

@@ -0,0 +1,8 @@
+import type { Extension } from "../extension.js";
+import type { Host } from "./globals.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.
+ */
+export declare const extensionGlobals: <R>(host: Host<R>, extensions: ReadonlyArray<Extension>) => ReadonlyArray<readonly [string, unknown]>;

package/dist/interpreter/extensions.js

@@ -0,0 +1,270 @@
+import { Effect } from "effect";
+import { MAX_VALUE_DEPTH } from "../data.js";
+import { coerceToString } from "../stdlib/value.js";
+import { createErrorValue, isErrorType } from "./intrinsics.js";
+import { ProgramThrow, typeError } from "./model.js";
+import { constructor, fn } from "./native.js";
+import { Callable, define, defineAccessor, entries, get, hidden, ProgramArray, ProgramDate, ProgramError, ProgramGenerator, ProgramHandle, ProgramMap, ProgramObject, ProgramPromise, ProgramRegExp, ProgramSet, ProgramURL, ProgramURLSearchParams, } 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.
+ */
+export const extensionGlobals = (host, extensions) => {
+    const protos = host.runner.prototypes;
+    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 prototypes = 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}.`);
+        if (value === null || typeof value !== "object") {
+            if (isPrimitive(value))
+                return value;
+            throw typeError(`${label} contains ${describeValue(value)}, which cannot be passed to an extension.`);
+        }
+        if (value instanceof ProgramHandle)
+            return value.instance;
+        if (value instanceof ProgramDate)
+            return new Date(value.time);
+        if (value instanceof ProgramRegExp)
+            return new RegExp(value.regex.source, value.regex.flags);
+        if (value instanceof ProgramURL)
+            return new URL(value.url.href);
+        if (value instanceof ProgramURLSearchParams)
+            return new URLSearchParams(value.params);
+        const next = (item) => toHost(item, label, depth + 1, seen);
+        if (value instanceof ProgramMap)
+            return new Map([...value.map].map(([key, item]) => [next(key), next(item)]));
+        if (value instanceof ProgramSet)
+            return new Set([...value.set].map(next));
+        if (!(value instanceof ProgramObject) ||
+            value instanceof Callable ||
+            value instanceof ProgramGenerator ||
+            value instanceof ProgramPromise) {
+            throw typeError(`${label} contains ${describeValue(value)}, which cannot be passed to an extension.`);
+        }
+        if (value instanceof ProgramError) {
+            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);
+        }
+        if (seen.has(value))
+            throw typeError(`${label} contains a circular value.`);
+        seen.add(value);
+        const copied = value instanceof ProgramArray
+            ? value.items.map(next)
+            : Object.fromEntries(entries(value)
+                .filter(([key]) => key !== "__proto__")
+                .map(([key, item]) => [key, next(item)]));
+        seen.delete(value);
+        return copied;
+    };
+    const fromHost = (value, label, depth = 0, seen = new Set()) => {
+        if (depth > MAX_VALUE_DEPTH)
+            throw typeError(`${label} exceeds the maximum value depth of ${MAX_VALUE_DEPTH}.`);
+        if (isPrimitive(value))
+            return value;
+        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 ProgramHandle(proto, value);
+                handles.set(value, handle);
+                return handle;
+            }
+            if (value instanceof Date)
+                return new ProgramDate(protos.Date, value.getTime());
+            if (value instanceof RegExp)
+                return new ProgramRegExp(protos.RegExp, value.source, value.flags);
+            if (value instanceof Error) {
+                return createErrorValue(protos[isErrorType(value.name) ? value.name : "Error"], value.message);
+            }
+            if (value instanceof URL)
+                return new ProgramURL(protos.URL, protos.URLSearchParams, new URL(value.href));
+            if (value instanceof URLSearchParams) {
+                return new ProgramURLSearchParams(protos.URLSearchParams, new URLSearchParams(value));
+            }
+            const next = (item) => fromHost(item, label, depth + 1, seen);
+            if (value instanceof Map) {
+                const wrapped = new ProgramMap(protos.Map);
+                for (const [key, item] of value)
+                    wrapped.map.set(next(key), next(item));
+                return wrapped;
+            }
+            if (value instanceof Set) {
+                const wrapped = new ProgramSet(protos.Set);
+                for (const item of value)
+                    wrapped.set.add(next(item));
+                return wrapped;
+            }
+            if (seen.has(value))
+                throw typeError(`${label} produced a circular value.`);
+            seen.add(value);
+            if (Array.isArray(value)) {
+                const copied = new ProgramArray(protos.Array, value.map(next));
+                seen.delete(value);
+                return copied;
+            }
+            const prototype = Object.getPrototypeOf(value);
+            if (prototype === Object.prototype || prototype === null) {
+                const copied = new ProgramObject(protos.Object);
+                for (const [key, item] of Object.entries(value))
+                    define(copied, key, next(item));
+                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 = prototypes.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) => {
+        const thrown = (reason) => new ProgramThrow(fromHost(reason, label));
+        let result;
+        try {
+            result = run();
+        }
+        catch (reason) {
+            return Effect.fail(thrown(reason));
+        }
+        if (!(result instanceof Promise))
+            return Effect.succeed(fromHost(result, label));
+        return host.promises.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(protos, 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 ProgramObject(base === undefined ? protos.Object : base.proto);
+        prototypes.set(cls.prototype, proto);
+        const name = cls.name;
+        const ctor = constructor(protos, 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 ProgramHandle && 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(protos, name, value.length, impl)];
+    }));
+};
+const hostErrors = {
+    TypeError,
+    RangeError,
+    SyntaxError,
+    ReferenceError,
+    EvalError,
+    URIError,
+};
+// The primitives the interpreter operates on; symbols and BigInts are not among them.
+const isPrimitive = (value) => value === null ||
+    value === undefined ||
+    typeof value === "string" ||
+    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;
+    return name === undefined || name === "" ? "an object" : `a ${name}`;
+};

package/dist/interpreter/globals.d.ts

@@ -9,5 +9,7 @@ export type Host<R> = {
     readonly toolKeys: (path: ReadonlyArray<string>) => ReadonlyArray<string>;
     readonly logs: Array<string>;
 };
+/** Names bound in every program before extensions apply. */
+export declare const globalNames: ReadonlySet<string>;
 /** The immutable global bindings of every program, in declaration order. */
 export declare const globals: <R>(host: Host<R>) => ReadonlyArray<readonly [string, unknown]>;

package/dist/interpreter/globals.js

@@ -42,44 +42,47 @@ const symbolGlobal = (runner) => {
     constants(symbol, { asyncIterator: AsyncIteratorSymbol, iterator: IteratorSymbol });
     return symbol;
 };
+// A table rather than a list so the names are known before any runtime exists.
+const table = {
+    tools: () => new ToolReference([]),
+    search: (host) => native(host.runner.prototypes, { name: "search", call: (_, args) => host.search(args), callback: false }),
+    undefined: () => undefined,
+    NaN: () => NaN,
+    Infinity: () => Infinity,
+    Object: (host) => objectGlobal(host.runner, host.toolKeys),
+    Function: (host) => functionGlobal(host.runner),
+    Array: (host) => arrayGlobal(host.runner),
+    Math: (host) => mathGlobal(host.runner),
+    JSON: (host) => jsonGlobal(host.runner),
+    console: (host) => consoleGlobal(host.runner, host.logs),
+    Promise: (host) => promiseGlobal(host.runner, host.promises),
+    Symbol: (host) => symbolGlobal(host.runner),
+    Number: (host) => numberGlobal(host.runner),
+    String: (host) => stringGlobal(host.runner),
+    Boolean: (host) => booleanGlobal(host.runner),
+    parseInt: (host) => coercion(host.runner, "parseInt", 2),
+    parseFloat: (host) => coercion(host.runner, "parseFloat"),
+    isFinite: (host) => coercion(host.runner, "isFinite"),
+    isNaN: (host) => coercion(host.runner, "isNaN"),
+    Date: (host) => dateGlobal(host.runner),
+    RegExp: (host) => regexpGlobal(host.runner),
+    Map: (host) => mapGlobal(host.runner),
+    Set: (host) => setGlobal(host.runner),
+    URL: (host) => urlGlobal(host.runner),
+    URLSearchParams: (host) => urlSearchParamsGlobal(host.runner),
+    encodeURI: (host) => uriGlobal(host.runner, "encodeURI"),
+    encodeURIComponent: (host) => uriGlobal(host.runner, "encodeURIComponent"),
+    decodeURI: (host) => uriGlobal(host.runner, "decodeURI"),
+    decodeURIComponent: (host) => uriGlobal(host.runner, "decodeURIComponent"),
+    atob: (host) => base64Global(host.runner, "atob"),
+    btoa: (host) => base64Global(host.runner, "btoa"),
+    crypto: (host) => cryptoGlobal(host.runner),
+    ...Object.fromEntries(errorTypes.map((type) => [type, (host) => errorGlobal(type, host.runner)])),
+};
+/** Names bound in every program before extensions apply. */
+export const globalNames = new Set(Object.keys(table));
 /** The immutable global bindings of every program, in declaration order. */
 export const globals = (host) => {
-    const runner = host.runner;
-    generatorGlobals(runner, host.promises);
-    return [
-        ["tools", new ToolReference([])],
-        ["search", native(runner.prototypes, { name: "search", call: (_, args) => host.search(args), callback: false })],
-        ["undefined", undefined],
-        ["NaN", NaN],
-        ["Infinity", Infinity],
-        ["Object", objectGlobal(runner, host.toolKeys)],
-        ["Function", functionGlobal(runner)],
-        ["Array", arrayGlobal(runner)],
-        ["Math", mathGlobal(runner)],
-        ["JSON", jsonGlobal(runner)],
-        ["console", consoleGlobal(runner, host.logs)],
-        ["Promise", promiseGlobal(runner, host.promises)],
-        ["Symbol", symbolGlobal(runner)],
-        ["Number", numberGlobal(runner)],
-        ["String", stringGlobal(runner)],
-        ["Boolean", booleanGlobal(runner)],
-        ["parseInt", coercion(runner, "parseInt", 2)],
-        ["parseFloat", coercion(runner, "parseFloat")],
-        ["isFinite", coercion(runner, "isFinite")],
-        ["isNaN", coercion(runner, "isNaN")],
-        ["Date", dateGlobal(runner)],
-        ["RegExp", regexpGlobal(runner)],
-        ["Map", mapGlobal(runner)],
-        ["Set", setGlobal(runner)],
-        ["URL", urlGlobal(runner)],
-        ["URLSearchParams", urlSearchParamsGlobal(runner)],
-        ["encodeURI", uriGlobal(runner, "encodeURI")],
-        ["encodeURIComponent", uriGlobal(runner, "encodeURIComponent")],
-        ["decodeURI", uriGlobal(runner, "decodeURI")],
-        ["decodeURIComponent", uriGlobal(runner, "decodeURIComponent")],
-        ["atob", base64Global(runner, "atob")],
-        ["btoa", base64Global(runner, "btoa")],
-        ["crypto", cryptoGlobal(runner)],
-        ...errorTypes.map((type) => [type, errorGlobal(type, runner)]),
-    ];
+    generatorGlobals(host.runner, host.promises);
+    return Object.entries(table).map(([name, factory]) => [name, factory(host)]);
 };

package/dist/interpreter/objects.d.ts

@@ -104,6 +104,11 @@ export declare class ProgramURL extends ProgramObject {
     readonly searchParams: ProgramURLSearchParams;
     constructor(proto: ProgramObject, searchParamsProto: ProgramObject, url: URL);
 }
+/** An instance of an extension class: the host object lives in a field no property path reaches. */
+export declare class ProgramHandle extends ProgramObject {
+    readonly instance: object;
+    constructor(proto: ProgramObject, instance: object);
+}
 /** Built-in objects that wrap a host value; data-like, but never plain data. */
 export declare const isWrapper: (value: unknown) => value is ProgramDate | ProgramRegExp | ProgramMap | ProgramSet | ProgramURL | ProgramURLSearchParams;
 export declare const parseArrayIndex: (key: string | number) => number | undefined;
@@ -119,7 +124,7 @@ export declare const hasPrototype: (value: unknown, proto: ProgramObject) => boo
 export declare const set: (target: ProgramObject, key: PropertyKey, value: unknown) => boolean;
 /** [[DefineOwnProperty]] for a data property, ignoring the chain. */
 export declare const define: (target: ProgramObject, key: PropertyKey, value: unknown, attrs?: Attributes) => void;
-export declare const defineAccessor: (target: ProgramObject, key: PropertyKey, get: Getter, set?: Setter) => void;
+export declare const defineAccessor: (target: ProgramObject, key: PropertyKey, get: Getter | undefined, set?: Setter) => void;
 export declare const remove: (target: ProgramObject, key: PropertyKey) => boolean;
 export declare const ownKeys: (target: ProgramObject) => Array<string | symbol>;
 /** Own enumerable keys, including the iterator symbols; what spread and `Object.assign` copy. */

package/dist/interpreter/objects.js

@@ -114,6 +114,14 @@ export class ProgramURL extends ProgramObject {
         this.searchParams = new ProgramURLSearchParams(searchParamsProto, url.searchParams);
     }
 }
+/** An instance of an extension class: the host object lives in a field no property path reaches. */
+export class ProgramHandle extends ProgramObject {
+    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 ProgramDate ||
     value instanceof ProgramRegExp ||

package/dist/interpreter/references.js

@@ -1,9 +1,10 @@
 import { ToolReference } from "../tool-runtime.js";
 import { invalidData } from "./model.js";
-import { Callable, getOwn, isWrapper, ownKeys, ProgramArray, ProgramDate, ProgramGenerator, ProgramMap, ProgramObject, ProgramPromise, ProgramRegExp, ProgramSet, ProgramURL, ProgramURLSearchParams, } from "./objects.js";
+import { Callable, getOwn, isWrapper, ownKeys, ProgramArray, ProgramDate, ProgramGenerator, ProgramHandle, 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 ProgramHandle ||
     value instanceof ToolReference ||
     value instanceof ProgramPromise ||
     isWrapper(value);
@@ -65,6 +66,8 @@ export const describeValue = (value) => {
         return "a URLSearchParams";
     if (value instanceof ProgramGenerator)
         return "a generator";
+    if (value instanceof ProgramHandle)
+        return `a ${value.instance.constructor.name}`;
     if (isRuntimeReference(value))
         return "a function";
     if (typeof value === "object")

package/dist/stdlib/object.js

@@ -99,7 +99,7 @@ export const objectGlobal = (runner, toolKeys) => {
         const first = args[0];
         if (first === null || first === undefined)
             return new ProgramObject(protos.Object);
-        if (typeof first === "object")
+        if (first instanceof ProgramObject)
             return first;
         throw typeError(`Object(${typeof first}) wrapper objects are not supported; use the primitive value directly.`);
     };

package/package.json

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