@opencode/codemode 0.0.0-dev-19329 → 0.0.0-dev-19335

package/dist/interpreter/methods.d.ts

@@ -10,6 +10,13 @@ export type CallbackRunner<R> = {
 export type SupportedCallback = CodeModeFunction | CoercionFunction | UriFunction | PromiseCapabilityFunction | GlobalMethodReference | JsonMethodReference | IntrinsicReference | ErrorConstructorReference | GlobalNamespace | PromiseNamespace;
 export declare const isSupportedCallback: (value: unknown) => value is SupportedCallback;
 export declare const invokeIntrinsic: <R>(runner: CallbackRunner<R>, ref: IntrinsicReference, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
+/**
+ * ToPrimitive: tries an object's own `valueOf`/`toString` in hint order and returns the first
+ * primitive result. Runtime values behave like their JS counterparts (Date yields its time under a
+ * number hint; the rest yield their string form). An inherited `toString` yields the default
+ * string form, so plain objects become "[object Object]" and arrays join.
+ */
+export declare const toPrimitive: <R>(runner: CallbackRunner<R>, value: unknown, hint: "number" | "string", node: AstNode) => Effect.Effect<unknown, unknown, R>;
 export declare const invokeGlobalMethod: (ref: GlobalMethodReference, args: Array<unknown>, node: AstNode) => unknown;
 export declare const arrayStatics: Set<string>;
 export declare const invokeArrayFrom: <R>(runner: CallbackRunner<R> & SyncIteratorRunner<R>, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;

package/dist/interpreter/methods.js

@@ -1,7 +1,7 @@
 import { Effect } from "effect";
 import { CodeModeFunction, CodeModeGenerator, CoercionFunction, ErrorConstructorReference, GlobalMethodReference, GlobalNamespace, IntrinsicReference, InterpreterRuntimeError, JsonMethodReference, PromiseCapabilityFunction, PromiseNamespace, UriFunction, } from "./model.js";
 import { containsOpaqueReference, isRuntimeReference, rejectCircularInsertion, typeofValue } from "./references.js";
-import { isBlockedMember } from "../tool-runtime.js";
+import { compareText, isBlockedMember } from "../tool-runtime.js";
 import { Values } from "../values.js";
 import { dateSetterArgumentCount, invokeDateMethod, invokeDateStatic } from "../stdlib/date.js";
 import { invokeMathMethod } from "../stdlib/math.js";
@@ -69,32 +69,36 @@ export const invokeIntrinsic = (runner, ref, args, node) => {
     }
     throw new InterpreterRuntimeError(`Method '${ref.name}' is not available.`, node);
 };
-const coerceNumericArgument = (runner, value, node) => {
-    if (value === null || typeof value !== "object" || Array.isArray(value) || Values.isValue(value)) {
-        return Effect.succeed(coerceToNumber(value));
+/**
+ * ToPrimitive: tries an object's own `valueOf`/`toString` in hint order and returns the first
+ * primitive result. Runtime values behave like their JS counterparts (Date yields its time under a
+ * number hint; the rest yield their string form). An inherited `toString` yields the default
+ * string form, so plain objects become "[object Object]" and arrays join.
+ */
+export const toPrimitive = (runner, value, hint, node) => {
+    if (value === null || typeof value !== "object")
+        return Effect.succeed(value);
+    if (Values.isValue(value)) {
+        return Effect.succeed(value instanceof Values.Date && hint === "number" ? value.time : coerceToString(value));
     }
     const object = value;
+    const order = hint === "number" ? ["valueOf", "toString"] : ["toString", "valueOf"];
     return Effect.gen(function* () {
-        if (Object.hasOwn(object, "valueOf") && typeofValue(object.valueOf) === "function") {
-            const result = yield* runner.invokeCallable(object.valueOf, [], node);
-            if (result === null || (typeof result !== "object" && typeof result !== "function")) {
-                return coerceToNumber(result);
-            }
-        }
-        if (!Object.hasOwn(object, "toString"))
-            return coerceToNumber(value);
-        if (typeofValue(object.toString) === "function") {
-            const result = yield* runner.invokeCallable(object.toString, [], node);
-            if (result === null || (typeof result !== "object" && typeof result !== "function")) {
-                return coerceToNumber(result);
-            }
+        for (const method of order) {
+            if (method === "toString" && !Object.hasOwn(object, "toString"))
+                return coerceToString(value);
+            if (!Object.hasOwn(object, method) || typeofValue(object[method]) !== "function")
+                continue;
+            const result = yield* runner.invokeCallable(object[method], [], node);
+            if (result === null || (typeof result !== "object" && typeof result !== "function"))
+                return result;
         }
         throw new InterpreterRuntimeError("Cannot convert object to primitive value.", node).as("TypeError");
     });
 };
+const coerceNumericArgument = (runner, value, node) => Effect.map(toPrimitive(runner, value, "number", node), coerceToNumber);
+// console is intercepted by the interpreter before reaching here.
 export const invokeGlobalMethod = (ref, args, node) => {
-    if (ref.namespace === "console")
-        throw new InterpreterRuntimeError(`console.${ref.name} is not available.`, node);
     if (ref.namespace === "Object")
         return invokeObjectMethod(ref.name, args, node);
     if (ref.namespace === "Math")
@@ -111,9 +115,6 @@ export const invokeGlobalMethod = (ref, args, node) => {
         return invokeDateStatic(ref.name, args, node);
     if (ref.namespace === "RegExp")
         return invokeRegExpStatic(ref.name, args, node);
-    if (ref.namespace === "Map" || ref.namespace === "Set" || ref.namespace === "URLSearchParams") {
-        throw new InterpreterRuntimeError(`${ref.namespace}.${ref.name} is not available.`, node);
-    }
     throw new InterpreterRuntimeError(`${ref.namespace}.${ref.name} is not available.`, node);
 };
 const requireDataArgument = (name, index, arg, node) => {
@@ -384,32 +385,12 @@ export const invokeGroupBy = (runner, namespace, args, node) => {
     });
 };
 const coerceGroupByPropertyKey = (runner, value, node) => {
-    if (value === null || typeof value !== "object" || Array.isArray(value) || Values.isValue(value)) {
-        return Effect.succeed(coerceToString(value));
-    }
     if (value instanceof Values.Promise)
         return Effect.succeed("[object Promise]");
-    if (isRuntimeReference(value)) {
+    if (!Values.isValue(value) && isRuntimeReference(value)) {
         throw new InterpreterRuntimeError("Object.groupBy callback must return a data value.", node, "InvalidDataValue");
     }
-    const object = value;
-    if (!Object.hasOwn(object, "toString"))
-        return Effect.succeed(coerceToString(value));
-    return Effect.gen(function* () {
-        if (typeofValue(object.toString) === "function") {
-            const result = yield* runner.invokeCallable(object.toString, [], node);
-            if (result === null || (typeof result !== "object" && typeof result !== "function")) {
-                return coerceToString(result);
-            }
-        }
-        if (Object.hasOwn(object, "valueOf") && typeofValue(object.valueOf) === "function") {
-            const result = yield* runner.invokeCallable(object.valueOf, [], node);
-            if (result === null || (typeof result !== "object" && typeof result !== "function")) {
-                return coerceToString(result);
-            }
-        }
-        throw new InterpreterRuntimeError("Cannot convert object to primitive value.", node).as("TypeError");
-    });
+    return Effect.map(toPrimitive(runner, value, "string", node), coerceToString);
 };
 const invokeStringReplacer = (runner, value, name, args, node) => {
     const apply = applyCollectionCallback(runner, args[1], `String.${name}`, node);
@@ -992,11 +973,7 @@ const invokeArrayMethod = (runner, target, name, args, node) => {
 };
 const sortArray = (runner, target, comparator, name, node) => {
     if (comparator === undefined) {
-        return Effect.sync(() => [...target].sort((a, b) => {
-            const left = coerceToString(a);
-            const right = coerceToString(b);
-            return left < right ? -1 : left > right ? 1 : 0;
-        }));
+        return Effect.sync(() => [...target].sort((a, b) => compareText(coerceToString(a), coerceToString(b))));
     }
     const apply = applyCollectionCallback(runner, comparator, name, node);
     const mergeSort = (items) => {

package/dist/interpreter/model.d.ts

@@ -1,4 +1,5 @@
 import type { Effect } from "effect";
+import type { DiagnosticKind } from "../codemode.js";
 import type { SafeObject } from "../tool-runtime.js";
 import type { Values } from "../values.js";
 export type SourcePosition = {
@@ -125,7 +126,6 @@ export declare class ErrorConstructorReference {
     readonly name: string;
     constructor(name: string);
 }
-export type DiagnosticKind = "ParseError" | "UnsupportedSyntax" | "UnknownTool" | "InvalidToolInput" | "InvalidToolOutput" | "InvalidDataValue" | "ToolCallLimitExceeded" | "TimeoutExceeded" | "ToolFailure" | "ExecutionFailure";
 export declare const OptionalShortCircuit: unique symbol;
 export declare const supportedSyntaxMessage = "Supported orchestration syntax: tools.* calls (they return promises - resolve them with await), data literals, destructuring, optional chaining, template literals, conditionals, switch, loops (incl. for...of and for...in over object/array/tools keys), arrow functions, spread, try/catch, array methods (map/filter/find/findIndex/some/every/reduce/flatMap/forEach/sort/slice/concat/indexOf/lastIndexOf/at/flat/reverse/includes/join), string methods (incl. match/matchAll/replace/split with regular expressions), Date/RegExp/Map/Set/URL/URLSearchParams, URI encoding helpers, Object/Math/JSON helpers, captured console.log/warn/error/dir/table, Promise.all/allSettled/race/any/resolve/reject over arrays mixing promises and plain values for parallel tool calls, promise chaining with .then/.catch/.finally, and new Promise((resolve, reject) => ...) construction.";
 export declare class InterpreterRuntimeError extends Error {

package/dist/interpreter/references.js

@@ -29,9 +29,9 @@ function* childValues(value) {
         yield Reflect.get(value, key);
     }
 }
-export const containsRuntimeReference = (value) => {
+// Depth-first search over a value tree. `match` stops the walk; `skip` prunes a subtree without matching it.
+const find = (value, match, skip, seen) => {
     const pending = [[value].values()];
-    const seen = new Set();
     while (pending.length > 0) {
         const next = pending.at(-1).next();
         if (next.done) {
@@ -39,53 +39,23 @@ export const containsRuntimeReference = (value) => {
             continue;
         }
         const current = next.value;
-        if (isRuntimeReference(current))
+        if (match(current))
             return true;
-        if (current === null || typeof current !== "object" || seen.has(current))
+        if (current === null || typeof current !== "object" || skip(current) || seen.has(current))
             continue;
         seen.add(current);
         pending.push(childValues(current));
     }
     return false;
 };
+const never = () => false;
+export const containsRuntimeReference = (value) => find(value, isRuntimeReference, never, new Set());
 // CodeMode values are data here, not opaque interpreter references.
-export const containsOpaqueReference = (value) => {
-    const pending = [[value].values()];
-    const seen = new Set();
-    while (pending.length > 0) {
-        const next = pending.at(-1).next();
-        if (next.done) {
-            pending.pop();
-            continue;
-        }
-        const current = next.value;
-        if (Values.isValue(current))
-            continue;
-        if (isRuntimeReference(current))
-            return true;
-        if (current === null || typeof current !== "object" || seen.has(current))
-            continue;
-        seen.add(current);
-        pending.push(childValues(current));
-    }
-    return false;
-};
+export const containsOpaqueReference = (value) => find(value, (current) => !Values.isValue(current) && isRuntimeReference(current), Values.isValue, new Set());
 // Reject cycles before mutation so later boundary walks remain safe.
 export const rejectCircularInsertion = (container, value, label, node, seen = new Set()) => {
-    const pending = [[value].values()];
-    while (pending.length > 0) {
-        const next = pending.at(-1).next();
-        if (next.done) {
-            pending.pop();
-            continue;
-        }
-        const current = next.value;
-        if (current === container)
-            throw new InterpreterRuntimeError(`${label} contains a circular value.`, node, "InvalidDataValue");
-        if (current === null || typeof current !== "object" || isRuntimeReference(current) || seen.has(current))
-            continue;
-        seen.add(current);
-        pending.push(childValues(current));
+    if (find(value, (current) => current === container, isRuntimeReference, seen)) {
+        throw new InterpreterRuntimeError(`${label} contains a circular value.`, node, "InvalidDataValue");
     }
 };
 export const typeofValue = (value) => {

package/dist/interpreter/runtime.d.ts

@@ -55,7 +55,6 @@ export declare class Interpreter<R> {
     private constructArray;
     private constructObject;
     private constructDate;
-    private toDatePrimitive;
     private constructRegExp;
     private constructMap;
     private constructSet;

package/dist/interpreter/runtime.js

@@ -2,7 +2,7 @@ import { Cause, Deferred, Effect, Exit } from "effect";
 import { isBlockedMember, ToolReference, ToolRuntimeError } from "../tool-runtime.js";
 import { AsyncIteratorSymbol, asNode, CodeModeFunction, CodeModeGenerator, CoercionFunction, ComputedValue, ErrorConstructorReference, GlobalMethodReference, GlobalNamespace, GeneratorMethodReference, GeneratorReturn, getArray, getBoolean, getNode, getOptionalNode, getString, IntrinsicReference, InterpreterRuntimeError, isRecord, IteratorSymbol, IteratorSymbols, JsonMethodReference, OptionalShortCircuit, PromiseCapabilityFunction, PromiseInstanceMethodReference, PromiseMethodReference, PromiseNamespace, ProgramThrow, SearchFunction, SymbolNamespace, unsupportedSyntax, UriFunction, } from "./model.js";
 import { caughtErrorValue, constructAggregateErrorValue, constructErrorValue } from "./errors.js";
-import { arrayStatics, invokeArrayFrom, invokeGlobalMethod, invokeGroupBy, invokeIntrinsic, } from "./methods.js";
+import { arrayStatics, invokeArrayFrom, invokeGlobalMethod, invokeGroupBy, invokeIntrinsic, toPrimitive, } from "./methods.js";
 import { preserveConsumerError } from "./iterator.js";
 import { constructPromise, invokePromiseInstanceMethod, invokePromiseMethod, PromiseRuntime, resolvePromise, resolvePromiseValue, } from "./promises.js";
 import { containsOpaqueReference, isRuntimeReference, rejectCircularInsertion, typeofValue } from "./references.js";
@@ -1167,34 +1167,13 @@ export class Interpreter {
             const arg = args[0];
             if (arg instanceof Values.Date)
                 return Effect.succeed(new Values.Date(arg.time));
-            return Effect.map(this.toDatePrimitive(arg, node), (value) => typeof value === "string"
+            return Effect.map(toPrimitive(this.runner, arg, "number", node), (value) => typeof value === "string"
                 ? new Values.Date(Date.parse(value))
                 : new Values.Date(new Date(coerceToNumber(value)).getTime()));
         }
         const parts = args.map((arg) => coerceToNumber(arg));
         return Effect.succeed(new Values.Date(new Date(...parts).getTime()));
     }
-    toDatePrimitive(value, node) {
-        if (value === null || (typeof value !== "object" && typeof value !== "function"))
-            return Effect.succeed(value);
-        const object = value;
-        const self = this;
-        return Effect.gen(function* () {
-            if (Object.hasOwn(object, "valueOf") && typeofValue(object.valueOf) === "function") {
-                const result = yield* self.runner.invokeCallable(object.valueOf, [], node);
-                if (result === null || (typeof result !== "object" && typeof result !== "function"))
-                    return result;
-            }
-            if (!Object.hasOwn(object, "toString"))
-                return coerceToString(value);
-            if (typeofValue(object.toString) === "function") {
-                const result = yield* self.runner.invokeCallable(object.toString, [], node);
-                if (result === null || (typeof result !== "object" && typeof result !== "function"))
-                    return result;
-            }
-            throw new InterpreterRuntimeError("Cannot convert object to primitive value.", node).as("TypeError");
-        });
-    }
     constructRegExp(args, node) {
         const first = args[0];
         const pattern = first instanceof Values.RegExp ? first.regex.source : first === undefined ? "" : coerceToString(first);

package/dist/stdlib/json.js

@@ -114,11 +114,4 @@ const toJSONValue = (value) => {
         return value.url.href;
     return value;
 };
-const isPlainObject = (value) => value !== null &&
-    typeof value === "object" &&
-    !(value instanceof Values.Date) &&
-    !(value instanceof Values.RegExp) &&
-    !(value instanceof Values.Map) &&
-    !(value instanceof Values.Set) &&
-    !(value instanceof Values.URL) &&
-    !(value instanceof Values.URLSearchParams);
+const isPlainObject = (value) => value !== null && typeof value === "object" && !Values.isValue(value);

package/dist/stdlib/number.d.ts

@@ -1,6 +1,6 @@
+import { type AstNode } from "../interpreter/model.js";
 export declare const numberMethods: Set<string>;
 export declare const numberConstants: Set<string>;
 export declare const numberStatics: Set<string>;
 export declare const invokeNumberMethod: (value: number, name: string, args: Array<unknown>, node: AstNode) => unknown;
 export declare const invokeNumberStatic: (name: string, args: Array<unknown>, node: AstNode) => unknown;
-import { type AstNode } from "../interpreter/model.js";

package/dist/stdlib/number.js

@@ -1,3 +1,5 @@
+import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { boundedData, coerceToString } from "./value.js";
 export const numberMethods = new Set(["toFixed", "toPrecision", "toExponential", "toString", "valueOf"]);
 export const numberConstants = new Set([
     "MAX_SAFE_INTEGER",
@@ -72,5 +74,3 @@ export const invokeNumberStatic = (name, args, node) => {
             throw new InterpreterRuntimeError(`Number.${name} is not available.`, node);
     }
 };
-import { InterpreterRuntimeError } from "../interpreter/model.js";
-import { boundedData, coerceToString } from "./value.js";

package/dist/stdlib/string.d.ts

@@ -1,4 +1,4 @@
+import { type AstNode } from "../interpreter/model.js";
 export declare const stringMethods: Set<string>;
 export declare const stringStatics: Set<string>;
 export declare const invokeStringStatic: (name: string, args: Array<unknown>, node: AstNode) => unknown;
-import { type AstNode } from "../interpreter/model.js";

package/dist/stdlib/string.js

@@ -1,3 +1,4 @@
+import { InterpreterRuntimeError } from "../interpreter/model.js";
 export const stringMethods = new Set([
     "toLowerCase",
     "toUpperCase",
@@ -45,4 +46,3 @@ export const invokeStringStatic = (name, args, node) => {
             throw new InterpreterRuntimeError(`String.${name} is not available.`, node);
     }
 };
-import { InterpreterRuntimeError } from "../interpreter/model.js";

package/dist/stdlib/url.d.ts

@@ -1,3 +1,5 @@
+import { type AstNode, UriFunction } from "../interpreter/model.js";
+import { Values } from "../values.js";
 export declare const urlProperties: Set<string>;
 export declare const urlWritableProperties: Set<string>;
 export declare const urlMethods: Set<string>;
@@ -8,5 +10,3 @@ export declare const invokeUriFunction: (ref: UriFunction, args: Array<unknown>,
 export declare const urlArgument: (value: unknown, label: string) => string;
 export declare const invokeURLStatic: (name: string, args: Array<unknown>, node: AstNode) => unknown;
 export declare const invokeURLMethod: (value: Values.URL, name: string, node: AstNode) => string;
-import { type AstNode, UriFunction } from "../interpreter/model.js";
-import { Values } from "../values.js";

package/dist/stdlib/url.js

@@ -1,3 +1,6 @@
+import { InterpreterRuntimeError, UriFunction } from "../interpreter/model.js";
+import { Values } from "../values.js";
+import { boundedData, coerceToString } from "./value.js";
 export const urlProperties = new Set([
     "href",
     "origin",
@@ -79,6 +82,3 @@ export const invokeURLMethod = (value, name, node) => {
         return value.url.href;
     throw new InterpreterRuntimeError(`URL method '${name}' is not available.`, node);
 };
-import { InterpreterRuntimeError, UriFunction } from "../interpreter/model.js";
-import { Values } from "../values.js";
-import { boundedData, coerceToString } from "./value.js";

package/dist/stdlib/value.d.ts

@@ -1,3 +1,5 @@
+import { type AstNode, CoercionFunction } from "../interpreter/model.js";
+import { type SafeObject } from "../tool-runtime.js";
 export declare const errorConstructors: Set<string>;
 export declare const valueConstructors: Set<string>;
 export declare const compoundOperators: Set<string>;
@@ -8,5 +10,3 @@ export declare const boundedData: (value: unknown, label: string) => unknown;
 export declare const coerceToString: (value: unknown) => string;
 export declare const coerceToNumber: (value: unknown) => number;
 export declare const invokeCoercion: (ref: CoercionFunction, args: Array<unknown>, node: AstNode) => unknown;
-import { type AstNode, CoercionFunction } from "../interpreter/model.js";
-import { type SafeObject } from "../tool-runtime.js";

package/dist/stdlib/value.js

@@ -1,3 +1,6 @@
+import { CoercionFunction, InterpreterRuntimeError } from "../interpreter/model.js";
+import { copyIn } from "../tool-runtime.js";
+import { Values } from "../values.js";
 export const errorConstructors = new Set([
     "Error",
     "TypeError",
@@ -115,6 +118,3 @@ export const invokeCoercion = (ref, args, node) => {
         return parseFloat(coerceToString(value));
     return coerceToString(value);
 };
-import { CoercionFunction, InterpreterRuntimeError } from "../interpreter/model.js";
-import { copyIn } from "../tool-runtime.js";
-import { Values } from "../values.js";

package/dist/tool-runtime.d.ts

@@ -1,5 +1,7 @@
 import { Effect } from "effect";
+import type { DiagnosticKind } from "./codemode.js";
 import type { Tools } from "./tools.js";
+export declare const compareText: (left: string, right: string) => 0 | 1 | -1;
 export type Services<T> = ServicesOf<T, []>;
 type ServicesOf<T, Depth extends ReadonlyArray<unknown>> = Depth["length"] extends 8 ? never : T extends {
     readonly _tag: "CodeModeTool";
@@ -37,9 +39,9 @@ export declare class ToolReference {
     constructor(path: ReadonlyArray<string>);
 }
 export declare class ToolRuntimeError extends Error {
-    readonly kind: "UnknownTool" | "InvalidToolInput" | "InvalidToolOutput" | "InvalidDataValue" | "ToolCallLimitExceeded";
+    readonly kind: Extract<DiagnosticKind, "UnknownTool" | "InvalidToolInput" | "InvalidToolOutput" | "InvalidDataValue" | "ToolCallLimitExceeded">;
     readonly suggestions: ReadonlyArray<string>;
-    constructor(kind: "UnknownTool" | "InvalidToolInput" | "InvalidToolOutput" | "InvalidDataValue" | "ToolCallLimitExceeded", message: string, suggestions?: ReadonlyArray<string>);
+    constructor(kind: Extract<DiagnosticKind, "UnknownTool" | "InvalidToolInput" | "InvalidToolOutput" | "InvalidDataValue" | "ToolCallLimitExceeded">, message: string, suggestions?: ReadonlyArray<string>);
 }
 export declare const isBlockedMember: (name: string) => boolean;
 export declare const copyIn: (value: unknown, label: string, preserveCodeModeValues?: boolean) => unknown;

package/dist/tool-runtime.js

@@ -4,7 +4,7 @@ import { decodeInput as decodeToolInput, decodeOutput as decodeToolOutput, ident
 import { isNamespace } from "./namespace.js";
 import { isTool } from "./tool.js";
 import { Values } 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));
@@ -68,14 +68,8 @@ const copyBounded = (value, label, depth, seen, preserveCodeModeValues) => {
         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 Values.Date ||
-            value instanceof Values.RegExp ||
-            value instanceof Values.Map ||
-            value instanceof Values.Set ||
-            value instanceof Values.URL ||
-            value instanceof Values.URLSearchParams) {
+        if (Values.isValue(value))
             return value;
-        }
         if (value instanceof Date)
             return new Values.Date(value.getTime());
         if (value instanceof RegExp)
@@ -108,10 +102,8 @@ const copyBounded = (value, label, depth, seen, preserveCodeModeValues) => {
         return value.url.href;
     if (value instanceof URL)
         return value.href;
-    if (value instanceof Values.RegExp ||
-        value instanceof Values.Map ||
-        value instanceof Values.Set ||
-        value instanceof Values.URLSearchParams ||
+    // Remaining runtime values and their host counterparts serialize as empty objects, like JSON.stringify.
+    if (Values.isValue(value) ||
         value instanceof RegExp ||
         value instanceof Map ||
         value instanceof Set ||

package/package.json

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