@opencode/codemode 0.0.0-beta-19296 → 0.0.0-beta-19378

package/dist/tool-runtime.js

@@ -1,10 +1,10 @@
 import { Cause, Effect, Exit, Formatter, Schema } from "effect";
+import { fromData, toData, ToolRuntimeError } from "./data.js";
 import { toolError } from "./tool-error.js";
 import { decodeInput as decodeToolInput, decodeOutput as decodeToolOutput, identifierSegment, inputProperties, inputTypeScript, isEmptyInput, outputTypeScript, } from "./tool-schema.js";
 import { isNamespace } from "./namespace.js";
 import { isTool } from "./tool.js";
-import { CodeModeDate, CodeModeMap, CodeModePromise, CodeModeRegExp, CodeModeSet, CodeModeURL, CodeModeURLSearchParams, } from "./values.js";
-const compareText = (left, right) => (left < right ? -1 : left > right ? 1 : 0);
+export const compareText = (left, right) => (left < right ? -1 : left > right ? 1 : 0);
 const defaultSearchLimit = 10;
 const PositiveInt = Schema.Int.check(Schema.isGreaterThan(0));
 const NonNegativeInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
@@ -35,143 +35,6 @@ export class ToolReference {
         this.path = path;
     }
 }
-const MAX_VALUE_DEPTH = 32;
-export class ToolRuntimeError extends Error {
-    kind;
-    suggestions;
-    constructor(kind, message, suggestions = []) {
-        super(message);
-        this.kind = kind;
-        this.suggestions = suggestions;
-        this.name = "ToolRuntimeError";
-    }
-}
-const blockedMemberNames = new Set(["__proto__", "constructor", "prototype"]);
-export const isBlockedMember = (name) => blockedMemberNames.has(name);
-// Checkpoint mode preserves CodeMode values; boundary mode JSON-normalizes them.
-export const copyIn = (value, label, preserveCodeModeValues = false) => copyBounded(value, label, 0, new Set(), preserveCodeModeValues);
-const copyBounded = (value, label, depth, seen, preserveCodeModeValues) => {
-    if (depth > MAX_VALUE_DEPTH) {
-        throw new ToolRuntimeError("InvalidDataValue", `${label} exceeds the maximum value depth of ${MAX_VALUE_DEPTH}.`);
-    }
-    if (value === null ||
-        value === undefined ||
-        typeof value === "string" ||
-        typeof value === "boolean" ||
-        typeof value === "number") {
-        return value;
-    }
-    if (typeof value !== "object") {
-        throw new ToolRuntimeError("InvalidDataValue", `${label} must contain data only.`);
-    }
-    if (value instanceof CodeModePromise) {
-        throw new ToolRuntimeError("InvalidDataValue", `${label} contains an un-awaited Promise; await tool calls (e.g. \`const result = await tools.ns.tool(...)\`) before using their results.`);
-    }
-    if (preserveCodeModeValues) {
-        if (value instanceof CodeModeDate ||
-            value instanceof CodeModeRegExp ||
-            value instanceof CodeModeMap ||
-            value instanceof CodeModeSet ||
-            value instanceof CodeModeURL ||
-            value instanceof CodeModeURLSearchParams) {
-            return value;
-        }
-        if (value instanceof Date)
-            return new CodeModeDate(value.getTime());
-        if (value instanceof RegExp)
-            return new CodeModeRegExp(value.source, value.flags);
-        if (value instanceof Map) {
-            const wrapped = new CodeModeMap();
-            for (const [key, item] of value.entries()) {
-                wrapped.map.set(copyBounded(key, label, depth + 1, seen, true), copyBounded(item, label, depth + 1, seen, true));
-            }
-            return wrapped;
-        }
-        if (value instanceof Set) {
-            const wrapped = new CodeModeSet();
-            for (const item of value.values())
-                wrapped.set.add(copyBounded(item, label, depth + 1, seen, true));
-            return wrapped;
-        }
-        if (value instanceof URL)
-            return new CodeModeURL(new URL(value.href));
-        if (value instanceof URLSearchParams)
-            return new CodeModeURLSearchParams(new URLSearchParams(value));
-    }
-    if (value instanceof CodeModeDate) {
-        return Number.isFinite(value.time) ? new Date(value.time).toISOString() : null;
-    }
-    if (value instanceof Date) {
-        return Number.isFinite(value.getTime()) ? value.toISOString() : null;
-    }
-    if (value instanceof CodeModeURL)
-        return value.url.href;
-    if (value instanceof URL)
-        return value.href;
-    if (value instanceof CodeModeRegExp ||
-        value instanceof CodeModeMap ||
-        value instanceof CodeModeSet ||
-        value instanceof CodeModeURLSearchParams ||
-        value instanceof RegExp ||
-        value instanceof Map ||
-        value instanceof Set ||
-        value instanceof URLSearchParams) {
-        return Object.create(null);
-    }
-    if (seen.has(value)) {
-        throw new ToolRuntimeError("InvalidDataValue", `${label} contains a circular value.`);
-    }
-    seen.add(value);
-    if (Array.isArray(value)) {
-        const copied = value.map((item) => copyBounded(item, label, depth + 1, seen, preserveCodeModeValues));
-        if (preserveCodeModeValues) {
-            // Checkpoint copies retain array metadata that boundary copies omit.
-            for (const [key, item] of Object.entries(value)) {
-                if (Object.hasOwn(copied, key))
-                    continue;
-                if (isBlockedMember(key)) {
-                    throw new ToolRuntimeError("InvalidDataValue", `${label} contains blocked property '${key}'.`);
-                }
-                Reflect.set(copied, key, copyBounded(item, label, depth + 1, seen, true));
-            }
-        }
-        seen.delete(value);
-        return copied;
-    }
-    const prototype = Object.getPrototypeOf(value);
-    if (prototype !== Object.prototype && prototype !== null) {
-        throw new ToolRuntimeError("InvalidDataValue", `${label} must contain plain objects only.`);
-    }
-    const copied = Object.create(null);
-    for (const [key, item] of Object.entries(value)) {
-        if (isBlockedMember(key)) {
-            throw new ToolRuntimeError("InvalidDataValue", `${label} contains blocked property '${key}'.`);
-        }
-        copied[key] = copyBounded(item, label, depth + 1, seen, preserveCodeModeValues);
-    }
-    seen.delete(value);
-    return copied;
-};
-export const copyOut = (value, mode) => {
-    if (value === undefined && mode === "nullify")
-        return null;
-    if (typeof value === "number" && !Number.isFinite(value)) {
-        return null;
-    }
-    if (Array.isArray(value)) {
-        // Array.from densifies holes so sparse arrays normalize at the boundary like JSON does.
-        return Array.from(value, (item) => {
-            const copied = copyOut(item, mode);
-            return copied === undefined && mode === "json" ? null : copied;
-        });
-    }
-    if (value !== null && typeof value === "object" && !(value instanceof ToolReference)) {
-        return Object.fromEntries(Object.entries(value)
-            .map(([key, item]) => [key, copyOut(item, mode)])
-            .filter(([, item]) => !(item === undefined && mode === "json")));
-    }
-    return value;
-};
 const toolTrie = (tools) => {
     const root = { children: new Map() };
     const insert = (node, group) => {
@@ -212,8 +75,6 @@ const describeTool = (visible) => ({
         ? `${toolExpression(visible.path)}(): Promise<${outputTypeScript(visible.tool, true)}>`
         : `${toolExpression(visible.path)}(input: ${inputTypeScript(visible.tool, true)}): Promise<${outputTypeScript(visible.tool, true)}>`,
 });
-// Discovery bytes are durable instructions, so order only after canonical-path collisions settle.
-const visibleTools = (tools) => flattenTools(toolTrie(tools)).sort((left, right) => compareText(left.path, right.path));
 const tokenize = (query) => query
     .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
     .toLowerCase()
@@ -290,10 +151,12 @@ const toSearchEntry = (visible) => ({
         .join("\n")
         .toLowerCase(),
 });
-export const searchIndex = (tools) => visibleTools(tools).map(toSearchEntry);
 export const prepare = (tools) => {
-    const visible = visibleTools(tools);
+    const root = toolTrie(tools);
+    // Discovery bytes are durable instructions, so order only after canonical-path collisions settle.
+    const visible = flattenTools(root).sort((left, right) => compareText(left.path, right.path));
     return {
+        root,
         catalog: visible.map(describeTool),
         searchIndex: visible.map(toSearchEntry),
     };
@@ -320,10 +183,11 @@ const resolve = (root, path) => {
     }
     return node.tool;
 };
-export const make = (tools, maxToolCalls, searchIndex, hooks) => {
+/** Per-execution call state over tools prepared once for the runtime. */
+export const make = (prepared, maxToolCalls, hooks) => {
     const calls = [];
-    const root = toolTrie(tools);
-    const searchTool = makeSearchTool(searchIndex);
+    const root = prepared.root;
+    const searchTool = makeSearchTool(prepared.searchIndex);
     const observeEnd = (effect, call) => {
         const onEnd = hooks?.onToolCallEnd;
         if (onEnd === undefined)
@@ -370,19 +234,18 @@ export const make = (tools, maxToolCalls, searchIndex, hooks) => {
                     .join("\n")));
             }));
             return yield* Effect.try({
-                try: () => copyIn(decodeToolOutput(tool, raw), `Result from tool '${name}'`),
+                try: () => fromData(decodeToolOutput(tool, raw), `Result from tool '${name}'`),
                 catch: (cause) => new ToolRuntimeError("InvalidToolOutput", `Invalid output from tool '${name}': ${cause}`),
             });
         }), call);
     });
     return {
-        root: new ToolReference([]),
         calls,
         keys: (path) => namespaceKeys(root, path),
-        search: (args) => Effect.suspend(() => executeTool("search", searchTool, args.map((arg) => copyOut(copyIn(arg, "Arguments for tool 'search'"), "json")))),
+        search: (args) => Effect.suspend(() => executeTool("search", searchTool, args.map((arg) => toData(arg, "Arguments for tool 'search'")))),
         execute: (path, args) => Effect.gen(function* () {
             const name = canonicalSegments(path).join(".");
-            const externalArgs = args.map((arg) => copyOut(copyIn(arg, `Arguments for tool '${name}'`), "json"));
+            const externalArgs = args.map((arg) => toData(arg, `Arguments for tool '${name}'`));
             const tool = resolve(root, path);
             return yield* executeTool(name, tool, externalArgs);
         }),

package/dist/values.d.ts

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

package/dist/values.js

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

package/package.json

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

package/dist/interpreter/iterator.d.ts

@@ -1,13 +0,0 @@
-import { Effect } from "effect";
-import type { AstNode } from "./model.js";
-export type IteratorCursor<R> = {
-    readonly next: Effect.Effect<{
-        readonly done: boolean;
-        readonly value: unknown;
-    }, unknown, R>;
-    readonly close: Effect.Effect<void, unknown, R>;
-};
-export type SyncIteratorRunner<R> = {
-    readonly syncIterator: (value: unknown, node: AstNode) => Effect.Effect<IteratorCursor<R> | undefined, unknown, R>;
-};
-export declare const preserveConsumerError: <A, R>(cursor: IteratorCursor<R>, effect: Effect.Effect<A, unknown, R>) => Effect.Effect<A, unknown, R>;

package/dist/interpreter/iterator.js

@@ -1,4 +0,0 @@
-import { Effect, Exit } from "effect";
-export const preserveConsumerError = (cursor, effect) => Effect.flatMap(Effect.exit(effect), (exit) => Exit.isSuccess(exit)
-    ? Effect.succeed(exit.value)
-    : Effect.andThen(Effect.exit(cursor.close), Effect.failCause(exit.cause)));

package/dist/stdlib/promise.d.ts

@@ -1,2 +0,0 @@
-import type { PromiseMethodName } from "../interpreter/model.js";
-export declare const promiseStatics: Set<PromiseMethodName>;

package/dist/stdlib/promise.js

@@ -1 +0,0 @@
-export const promiseStatics = new Set(["all", "allSettled", "race", "any", "resolve", "reject"]);