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

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/limits.d.ts

@@ -0,0 +1,8 @@
+/** Longest string a built-in or operator may produce. */
+export declare const MAX_STRING_LENGTH: number;
+/** Longest array a built-in may create or grow to. */
+export declare const MAX_ARRAY_LENGTH = 10000000;
+/** Most promises that may be pending at once. */
+export declare const MAX_PENDING_PROMISES = 10000;
+export declare const checkStringLength: (length: number) => void;
+export declare const checkArrayLength: (length: number) => void;

package/dist/interpreter/limits.js

@@ -0,0 +1,17 @@
+import { rangeError } from "./model.js";
+// The timeout only fires between interpreter steps, so a single built-in must not be able to materialize an
+// unbounded value. These bound what one call may build; programs cannot reach such sizes any other way.
+/** Longest string a built-in or operator may produce. */
+export const MAX_STRING_LENGTH = 1 << 24;
+/** Longest array a built-in may create or grow to. */
+export const MAX_ARRAY_LENGTH = 10_000_000;
+/** Most promises that may be pending at once. */
+export const MAX_PENDING_PROMISES = 10_000;
+export const checkStringLength = (length) => {
+    if (length > MAX_STRING_LENGTH)
+        throw rangeError("Invalid string length");
+};
+export const checkArrayLength = (length) => {
+    if (length > MAX_ARRAY_LENGTH)
+        throw rangeError("Invalid array length");
+};

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

@@ -1,3 +1,4 @@
+import { checkArrayLength } from "./limits.js";
 import { AsyncIteratorSymbol, IteratorSymbol, } from "./model.js";
 /** Ordinary assignment: writable, enumerable, configurable. */
 export const data = { writable: true, enumerable: true, configurable: true };
@@ -114,6 +115,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 ||
@@ -121,13 +130,13 @@ export const isWrapper = (value) => value instanceof ProgramDate ||
     value instanceof ProgramSet ||
     value instanceof ProgramURL ||
     value instanceof ProgramURLSearchParams;
-const MAX_ARRAY_LENGTH = 4_294_967_295;
+const MAX_ARRAY_INDEX = 4_294_967_295;
 export const parseArrayIndex = (key) => {
     const property = String(key);
     if (!/^(0|[1-9]\d*)$/.test(property))
         return undefined;
     const index = Number(property);
-    return index < MAX_ARRAY_LENGTH ? index : undefined;
+    return index < MAX_ARRAY_INDEX ? index : undefined;
 };
 const canonical = (key) => (typeof key === "symbol" ? key : String(key));
 const index = (target, key) => target instanceof ProgramArray && typeof key === "string" ? parseArrayIndex(key) : undefined;
@@ -182,8 +191,9 @@ const writeArray = (target, name, value) => {
     if (name !== "length")
         return undefined;
     const length = typeof value === "number" ? value : Number(value);
-    if (!Number.isInteger(length) || length < 0 || length > MAX_ARRAY_LENGTH)
+    if (!Number.isInteger(length) || length < 0)
         return false;
+    checkArrayLength(length);
     target.items.length = length;
     return true;
 };

package/dist/interpreter/promises.js

@@ -1,5 +1,6 @@
 import { Cause, Deferred, Effect, Exit, Fiber, Scope } from "effect";
-import { CallSite, ProgramThrow, typeError } from "./model.js";
+import { MAX_PENDING_PROMISES } from "./limits.js";
+import { CallSite, ProgramThrow, rangeError, typeError } from "./model.js";
 import { Callable, define, get, hidden, ProgramArray, ProgramFunction, ProgramObject, ProgramPromise, record, } from "./objects.js";
 import { constructor, fn, methods, native, receiver, requiresNew } from "./native.js";
 import { createAggregateErrorValue, locate, materialize, normalizeError } from "./errors.js";
@@ -33,6 +34,9 @@ export class PromiseRuntime {
     }
     create(effect) {
         return Effect.flatMap(CallSite, (site) => {
+            if (this.active.size >= MAX_PENDING_PROMISES) {
+                throw rangeError(`Too many pending promises (limit ${MAX_PENDING_PROMISES}); await promises before creating more.`);
+            }
             // Allocate before forking so reruns get distinct IDs and diagnostics retain creation order.
             const id = this.nextID++;
             const body = Effect.catchDefect(effect, (defect) => Effect.die(locate(defect, site.node)));

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/interpreter/runtime.js

@@ -2,6 +2,7 @@ import { Cause, Deferred, Effect, Exit } from "effect";
 import { toProgram } from "../data.js";
 import { ToolReference } from "../tool-runtime.js";
 import { AsyncIteratorSymbol, CallSite, GeneratorReturn, IteratorSymbol, OptionalShortCircuit, invalidData, ProgramThrow, rangeError, typeError, unsupportedSyntax, } from "./model.js";
+import { checkStringLength } from "./limits.js";
 import { locate, materialize } from "./errors.js";
 import { globals } from "./globals.js";
 import { assign, Callable, define, get, has, hasPrototype, keys, NativeFunction, parseArrayIndex, ProgramArray, ProgramDate, ProgramFunction, ProgramGenerator, ProgramMap, ProgramObject, ProgramPromise, ProgramSet, ProgramURLSearchParams, record, remove, set, } from "./objects.js";
@@ -1054,8 +1055,12 @@ class Frame {
         const l = coerceOperand(lhs);
         const r = coerceOperand(rhs);
         switch (operator) {
-            case "+":
-                return l + r;
+            case "+": {
+                const sum = l + r;
+                if (typeof sum === "string")
+                    checkStringLength(sum.length);
+                return sum;
+            }
             case "-":
                 return l - r;
             case "*":
@@ -1641,9 +1646,11 @@ class Frame {
                     throw typeError("Invalid template literal quasi.", quasi);
                 }
                 output += quasi.value.cooked;
+                checkStringLength(output.length);
                 if (index < expressions.length) {
                     const raw = yield* self.evaluateExpression(expressions[index]);
                     output += coerceToString(toProgram(self.runtime.prototypes, raw, "Template interpolation"));
+                    checkStringLength(output.length);
                 }
             }
             return output;

package/dist/stdlib/array.js

@@ -1,18 +1,17 @@
 import { Effect } from "effect";
 import { constructor, methods, prototypeFrom, receiver } from "../interpreter/native.js";
+import { checkArrayLength, checkStringLength, MAX_ARRAY_LENGTH } from "../interpreter/limits.js";
 import { invalidData, rangeError, typeError } from "../interpreter/model.js";
 import { get, ProgramArray, ProgramGenerator, ProgramObject } from "../interpreter/objects.js";
 import { describeValue, rejectCircularInsertion } from "../interpreter/references.js";
 import { applyCollectionCallback, preserveConsumerError } from "../interpreter/runner.js";
 import { compareText } from "../tool-runtime.js";
 import { coerceToNumber, coerceToString } from "./value.js";
-const MAX_LENGTH = 4_294_967_295;
 const arrayLikeSource = (source) => {
     if (source instanceof ProgramObject && typeof get(source, "length") === "number") {
         const length = get(source, "length");
         const normalized = Number.isNaN(length) || length <= 0 ? 0 : Math.trunc(length);
-        if (normalized > MAX_LENGTH)
-            throw new RangeError("Invalid array length");
+        checkArrayLength(normalized);
         return { length: normalized, source };
     }
     throw invalidData(`Array.from expects an array, string, Map, Set, or array-like value, received ${describeValue(source)}.`);
@@ -87,7 +86,7 @@ export const arrayGlobal = (runner) => {
         const first = args[0];
         if (typeof first !== "number")
             return new ProgramArray(into, [first]);
-        if (!Number.isInteger(first) || first < 0 || first > MAX_LENGTH)
+        if (!Number.isInteger(first) || first < 0 || first > MAX_ARRAY_LENGTH)
             throw rangeError("Invalid array length.");
         // Sparse like JS: Array(3) has holes, and combinator loops already skip them.
         return new ProgramArray(into, new Array(first));
@@ -130,7 +129,11 @@ export const arrayGlobal = (runner) => {
                 if (args.length > 1 || (args.length === 1 && typeof args[0] !== "string")) {
                     throw typeError("Array.join expects zero arguments or one string separator.");
                 }
-                return target.map((item) => coerceToString(item ?? "")).join(args.length === 0 ? "," : args[0]);
+                const joined = target
+                    .map((item) => coerceToString(item ?? ""))
+                    .join(args.length === 0 ? "," : args[0]);
+                checkStringLength(joined.length);
+                return joined;
             },
         ],
         [
@@ -175,14 +178,20 @@ export const arrayGlobal = (runner) => {
         [
             "concat",
             1,
-            (thisValue, args) => wrap(self(thisValue, "concat").items.concat(...args.map((item) => (item instanceof ProgramArray ? item.items : item)))),
+            (thisValue, args) => {
+                const joined = self(thisValue, "concat").items.concat(...args.map((item) => (item instanceof ProgramArray ? item.items : item)));
+                checkArrayLength(joined.length);
+                return wrap(joined);
+            },
         ],
         [
             "flat",
             0,
             (thisValue, args) => {
                 const flatten = (items, depth) => items.flatMap((item) => (item instanceof ProgramArray && depth > 0 ? flatten(item.items, depth - 1) : [item]));
-                return wrap(flatten(self(thisValue, "flat").items, optNumber("flat", args[0], "depth") ?? 1));
+                const flattened = flatten(self(thisValue, "flat").items, optNumber("flat", args[0], "depth") ?? 1);
+                checkArrayLength(flattened.length);
+                return wrap(flattened);
             },
         ],
         [

package/dist/stdlib/json.js

@@ -1,6 +1,7 @@
 import { Effect } from "effect";
 import { methods } from "../interpreter/native.js";
 import { applyCollectionCallback } from "../interpreter/runner.js";
+import { checkStringLength } from "../interpreter/limits.js";
 import { syntaxError, typeError } from "../interpreter/model.js";
 import { typeofValue } from "../interpreter/references.js";
 import { fromData, toData, toProgram } from "../data.js";
@@ -54,7 +55,10 @@ const stringify = (runner, args) => {
                 .map(String)
             : null;
         // A string cannot pollute, so __proto__ stays: JSON.stringify includes own __proto__ keys, like JS.
-        return Effect.succeed(JSON.stringify(toData(args[0], "JSON.stringify value", "json", false), properties, indent));
+        const text = JSON.stringify(toData(args[0], "JSON.stringify value", "json", false), properties, indent);
+        if (text !== undefined)
+            checkStringLength(text.length);
+        return Effect.succeed(text);
     }
     // Validate up front; the replacer walk below reads the original value.
     toProgram(runner.prototypes, args[0], "JSON.stringify value");

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/dist/stdlib/string.js

@@ -1,6 +1,7 @@
 import { Effect } from "effect";
 import { toProgram } from "../data.js";
 import { constructor, methods } from "../interpreter/native.js";
+import { checkArrayLength, checkStringLength } from "../interpreter/limits.js";
 import { invalidData, rangeError, typeError } from "../interpreter/model.js";
 import { ProgramArray, ProgramPromise, ProgramRegExp, record } from "../interpreter/objects.js";
 import { containsOpaqueReference, typeofValue } from "../interpreter/references.js";
@@ -156,9 +157,11 @@ export const stringGlobal = (runner) => {
             if (args[0] === undefined) {
                 return wrap(requestedLimit !== undefined && requestedLimit >>> 0 === 0 ? [] : [value]);
             }
-            if (args[0] instanceof ProgramRegExp)
-                return wrap(value.split(args[0].regex, requestedLimit));
-            return wrap(value.split(str("split", args, 0), requestedLimit === undefined ? undefined : requestedLimit >>> 0));
+            const parts = args[0] instanceof ProgramRegExp
+                ? value.split(args[0].regex, requestedLimit)
+                : value.split(str("split", args, 0), requestedLimit === undefined ? undefined : requestedLimit >>> 0);
+            checkArrayLength(parts.length);
+            return wrap(parts);
         }),
         simple("slice", 2, (value, args) => value.slice(optNum("slice", args, 0), optNum("slice", args, 1))),
         simple("includes", 1, (value, args) => {
@@ -192,7 +195,12 @@ export const stringGlobal = (runner) => {
             if (!pattern.global) {
                 throw typeError(`String.matchAll requires a regular expression with the global (g) flag: write /${pattern.source}/${pattern.flags}g, or use String.match for a single match.`);
             }
-            return new ProgramArray(protos.Array, Array.from(value.matchAll(pattern), (match) => matchToValue(protos, match)));
+            const matches = [];
+            for (const match of value.matchAll(pattern)) {
+                checkArrayLength(matches.length + 1);
+                matches.push(matchToValue(protos, match));
+            }
+            return new ProgramArray(protos.Array, matches);
         }),
         simple("search", 1, (value, args) => value.search(toHostRegex(args[0], "search"))),
         simple("repeat", 1, (value, args) => {
@@ -200,10 +208,19 @@ export const stringGlobal = (runner) => {
             if (!Number.isFinite(count) || count < 0) {
                 throw rangeError("String.repeat expects a finite non-negative count.");
             }
+            checkStringLength(value.length * count);
             return value.repeat(count);
         }),
-        simple("padStart", 1, (value, args) => value.padStart(num("padStart", args, 0), optStr("padStart", args, 1))),
-        simple("padEnd", 1, (value, args) => value.padEnd(num("padEnd", args, 0), optStr("padEnd", args, 1))),
+        simple("padStart", 1, (value, args) => {
+            const length = num("padStart", args, 0);
+            checkStringLength(length);
+            return value.padStart(length, optStr("padStart", args, 1));
+        }),
+        simple("padEnd", 1, (value, args) => {
+            const length = num("padEnd", args, 0);
+            checkStringLength(length);
+            return value.padEnd(length, optStr("padEnd", args, 1));
+        }),
         simple("charAt", 1, (value, args) => value.charAt(optNum("charAt", args, 0) ?? 0)),
         simple("at", 1, (value, args) => value.at(optNum("at", args, 0) ?? 0)),
         simple("substring", 2, (value, args) => value.substring(optNum("substring", args, 0) ?? 0, optNum("substring", args, 1))),
@@ -212,7 +229,11 @@ export const stringGlobal = (runner) => {
         simple("toWellFormed", 0, (value) => value.toWellFormed()),
         simple("charCodeAt", 1, (value, args) => value.charCodeAt(optNum("charCodeAt", args, 0) ?? 0)),
         simple("codePointAt", 1, (value, args) => value.codePointAt(optNum("codePointAt", args, 0) ?? 0)),
-        simple("concat", 1, (value, args) => value.concat(...args.map((_, index) => str("concat", args, index)))),
+        simple("concat", 1, (value, args) => {
+            const joined = value.concat(...args.map((_, index) => str("concat", args, index)));
+            checkStringLength(joined.length);
+            return joined;
+        }),
     ]);
     return string;
 };

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-19610",
   "description": "Effect-native confined code execution over schema-described tools",
   "type": "module",
   "license": "MIT",