@opencode/codemode 0.0.0-beta-19289 → 0.0.0-beta-19365

package/dist/interpreter/methods.js

@@ -1,8 +1,9 @@
 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 { CodeModeDate, CodeModeMap, CodeModePromise, CodeModeRegExp, CodeModeSet, CodeModeURL, CodeModeURLSearchParams, isCodeModeValue, } from "../values.js";
+import { isBlockedMember, toProgram } from "../data.js";
+import { compareText } from "../tool-runtime.js";
+import { Values } from "../values.js";
 import { dateSetterArgumentCount, invokeDateMethod, invokeDateStatic } from "../stdlib/date.js";
 import { invokeMathMethod } from "../stdlib/math.js";
 import { invokeNumberMethod, invokeNumberStatic } from "../stdlib/number.js";
@@ -10,7 +11,7 @@ import { invokeObjectMethod } from "../stdlib/object.js";
 import { invokeRegExpMethod, invokeRegExpStatic, matchToValue, toHostRegex } from "../stdlib/regexp.js";
 import { invokeStringStatic } from "../stdlib/string.js";
 import { invokeURLMethod, invokeURLStatic, uriArgument } from "../stdlib/url.js";
-import { boundedData, coerceToNumber, coerceToString, errorBrandName } from "../stdlib/value.js";
+import { coerceToNumber, coerceToString, errorBrandName } from "../stdlib/value.js";
 import { preserveConsumerError } from "./iterator.js";
 export const isSupportedCallback = (value) => value instanceof CodeModeFunction ||
     value instanceof CoercionFunction ||
@@ -41,7 +42,7 @@ export const invokeIntrinsic = (runner, ref, args, node) => {
     if (Array.isArray(ref.receiver)) {
         return invokeArrayMethod(runner, ref.receiver, ref.name, args, node);
     }
-    if (ref.receiver instanceof CodeModeDate) {
+    if (ref.receiver instanceof Values.Date) {
         const target = ref.receiver;
         const argumentCount = dateSetterArgumentCount(ref.name);
         if (argumentCount === undefined)
@@ -52,49 +53,53 @@ export const invokeIntrinsic = (runner, ref, args, node) => {
             concurrency: 1,
         }), (values) => invokeDateMethod(target, ref.name, values, node, initialTime));
     }
-    if (ref.receiver instanceof CodeModeRegExp) {
+    if (ref.receiver instanceof Values.RegExp) {
         return Effect.succeed(invokeRegExpMethod(ref.receiver, ref.name, args, node));
     }
-    if (ref.receiver instanceof CodeModeMap) {
+    if (ref.receiver instanceof Values.Map) {
         return invokeMapMethod(runner, ref.receiver, ref.name, args, node);
     }
-    if (ref.receiver instanceof CodeModeSet) {
+    if (ref.receiver instanceof Values.Set) {
         return invokeSetMethod(runner, ref.receiver, ref.name, args, node);
     }
-    if (ref.receiver instanceof CodeModeURL) {
+    if (ref.receiver instanceof Values.URL) {
         return Effect.succeed(invokeURLMethod(ref.receiver, ref.name, node));
     }
-    if (ref.receiver instanceof CodeModeURLSearchParams) {
+    if (ref.receiver instanceof Values.URLSearchParams) {
         return invokeURLSearchParamsMethod(runner, ref.receiver, ref.name, 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) || isCodeModeValue(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 +116,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) => {
@@ -129,7 +131,7 @@ const invokeStringMethod = (value, name, args, node) => {
     const optNum = (index) => (args[index] === undefined ? undefined : num(index));
     const optStr = (index) => (args[index] === undefined ? undefined : str(index));
     const rejectRegex = () => {
-        if (args[0] instanceof CodeModeRegExp) {
+        if (args[0] instanceof Values.RegExp) {
             throw new InterpreterRuntimeError(`String.${name} cannot take a regular expression; use regex.test(string) or String.search instead.`, node).as("TypeError");
         }
     };
@@ -172,7 +174,7 @@ const invokeStringMethod = (value, name, args, node) => {
                 result = requestedLimit !== undefined && requestedLimit >>> 0 === 0 ? [] : [value];
                 break;
             }
-            if (args[0] instanceof CodeModeRegExp) {
+            if (args[0] instanceof Values.RegExp) {
                 result = value.split(args[0].regex, optNum(1));
                 break;
             }
@@ -203,7 +205,7 @@ const invokeStringMethod = (value, name, args, node) => {
             break;
         case "replace":
         case "replaceAll": {
-            if (args[0] instanceof CodeModeRegExp) {
+            if (args[0] instanceof Values.RegExp) {
                 const pattern = args[0].regex;
                 const replacement = str(1);
                 if (name === "replaceAll" && !pattern.global) {
@@ -226,7 +228,7 @@ const invokeStringMethod = (value, name, args, node) => {
                 return null;
             // Preserve the own `index` and `groups` properties on non-global matches.
             if (pattern.global)
-                return boundedData(matched, "String.match result");
+                return toProgram(matched, "String.match result");
             return matchToValue(matched);
         }
         case "matchAll": {
@@ -278,7 +280,7 @@ const invokeStringMethod = (value, name, args, node) => {
         default:
             throw new InterpreterRuntimeError(`String method '${name}' is not available.`, node);
     }
-    return boundedData(result, `String.${name} result`);
+    return toProgram(result, `String.${name} result`);
 };
 export const arrayStatics = new Set(["isArray", "of", "from"]);
 const invokeArrayStatic = (name, args, node) => {
@@ -292,7 +294,7 @@ const invokeArrayStatic = (name, args, node) => {
     }
 };
 const arrayLikeSource = (source, node) => {
-    if (source instanceof CodeModePromise) {
+    if (source instanceof Values.Promise) {
         throw new InterpreterRuntimeError("Array.from received an un-awaited Promise; await it before creating the array.", node, "InvalidDataValue");
     }
     if (source !== null &&
@@ -347,7 +349,7 @@ export const invokeGroupBy = (runner, namespace, args, node) => {
             throw new InterpreterRuntimeError(`${namespace}.groupBy expects an iterable collection.`, node).as("TypeError");
         }
         if (namespace === "Map") {
-            const result = new CodeModeMap();
+            const result = new Values.Map();
             let index = 0;
             while (true) {
                 const step = yield* cursor.next;
@@ -384,32 +386,12 @@ export const invokeGroupBy = (runner, namespace, args, node) => {
     });
 };
 const coerceGroupByPropertyKey = (runner, value, node) => {
-    if (value === null || typeof value !== "object" || Array.isArray(value) || isCodeModeValue(value)) {
-        return Effect.succeed(coerceToString(value));
-    }
-    if (value instanceof CodeModePromise)
+    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);
@@ -434,7 +416,7 @@ const invokeStringReplacer = (runner, value, name, args, node) => {
         return match;
     };
     const pattern = args[0];
-    if (pattern instanceof CodeModeRegExp) {
+    if (pattern instanceof Values.RegExp) {
         if (name === "replaceAll" && !pattern.regex.global) {
             throw new InterpreterRuntimeError(`String.replaceAll requires a regular expression with the global (g) flag: write /${pattern.regex.source}/${pattern.regex.flags}g, or use String.replace to replace only the first match.`, node);
         }
@@ -455,16 +437,16 @@ const invokeStringReplacer = (runner, value, name, args, node) => {
         let end = 0;
         for (const match of matches) {
             const replacement = yield* apply(match.args);
-            // Error values are branded plain objects; boundedData would strip the brand before coercion.
-            output.push(value.slice(end, match.offset), replacement instanceof CodeModePromise
+            // Error values are branded plain objects; toProgram would strip the brand before coercion.
+            output.push(value.slice(end, match.offset), replacement instanceof Values.Promise
                 ? "[object Promise]"
                 : errorBrandName(replacement)
                     ? coerceToString(replacement)
-                    : coerceToString(boundedData(replacement, `String.${name} replacer result`)));
+                    : coerceToString(toProgram(replacement, `String.${name} replacer result`)));
             end = match.offset + match.match.length;
         }
         output.push(value.slice(end));
-        return boundedData(output.join(""), `String.${name} result`);
+        return toProgram(output.join(""), `String.${name} result`);
     });
 };
 export const applyCollectionCallback = (runner, callback, name, node) => {
@@ -562,7 +544,7 @@ const invokeSetOperation = (runner, target, name, source, node) => Effect.gen(fu
         return result;
     }
     if (name === "intersection") {
-        const result = new CodeModeSet();
+        const result = new Values.Set();
         if (target.set.size <= other.size) {
             for (const item of target.set.values()) {
                 if (yield* other.has(item))
@@ -631,27 +613,27 @@ const invokeSetOperation = (runner, target, name, source, node) => Effect.gen(fu
     return true;
 });
 const copySet = (source) => {
-    const result = new CodeModeSet();
+    const result = new Values.Set();
     for (const item of source.set.values())
         result.set.add(item);
     return result;
 };
 const loadSetRecord = (runner, source, name, node) => {
-    if (source instanceof CodeModeSet) {
+    if (source instanceof Values.Set) {
         return Effect.succeed({
             size: source.set.size,
             has: (item) => Effect.succeed(source.set.has(item)),
             keys: () => Effect.succeed(source.set.values()),
         });
     }
-    if (source instanceof CodeModeMap) {
+    if (source instanceof Values.Map) {
         return Effect.succeed({
             size: source.map.size,
             has: (item) => Effect.succeed(source.map.has(item)),
             keys: () => Effect.succeed(source.map.keys()),
         });
     }
-    if (source === null || typeof source !== "object" || isCodeModeValue(source)) {
+    if (source === null || typeof source !== "object" || Values.isValue(source)) {
         throw new InterpreterRuntimeError(`Set.${name} expects a Set-like object.`, node).as("TypeError");
     }
     const object = source;
@@ -756,7 +738,7 @@ const invokeArrayMethod = (runner, target, name, args, node) => {
             if (args.length > 1 || (args.length === 1 && typeof args[0] !== "string")) {
                 throw new InterpreterRuntimeError("Array.join expects zero arguments or one string separator.", node);
             }
-            const input = boundedData(target, "Array.join input");
+            const input = toProgram(target, "Array.join input");
             return Effect.succeed(input.map((item) => coerceToString(item ?? "")).join(args.length === 0 ? "," : args[0]));
         }
         case "includes":
@@ -992,11 +974,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,23 +1,10 @@
+import type { BlockStatement, Expression, Node, Pattern } from "acorn";
 import type { Effect } from "effect";
-import type { SafeObject } from "../tool-runtime.js";
-import type { CodeModePromise, CodeModeRegExp, CodeModeURL } from "../values.js";
-export type SourcePosition = {
-    line: number;
-    column: number;
-};
-export type SourceLocation = {
-    start: SourcePosition;
-    end: SourcePosition;
-};
-export type AstNode = {
-    type: string;
-    loc?: SourceLocation;
-    [key: string]: unknown;
-};
-export type ProgramNode = AstNode & {
-    type: "Program";
-    body: Array<AstNode>;
-};
+import type { DiagnosticKind } from "../codemode.js";
+import type { SafeObject } from "../data.js";
+import type { Values } from "../values.js";
+/** Any parsed node; the interpreter narrows on `type` and reads `loc` for diagnostics. */
+export type AstNode = Node;
 export type Binding = {
     mutable: boolean;
     value: unknown;
@@ -36,16 +23,16 @@ export type StatementResult = {
     label?: string;
 };
 export type MemberReference = {
-    target: SafeObject | Array<unknown> | CodeModeRegExp | CodeModeURL;
+    target: SafeObject | Array<unknown> | Values.RegExp | Values.URL;
     key: PropertyKey;
 };
 export declare class CodeModeFunction {
-    readonly parameters: ReadonlyArray<AstNode>;
-    readonly body: AstNode;
+    readonly parameters: ReadonlyArray<Pattern>;
+    readonly body: BlockStatement | Expression;
     readonly capturedScopes: ReadonlyArray<Map<string, Binding>>;
     readonly async: boolean;
     readonly generator: boolean;
-    constructor(parameters: ReadonlyArray<AstNode>, body: AstNode, capturedScopes: ReadonlyArray<Map<string, Binding>>, async: boolean, generator: boolean);
+    constructor(parameters: ReadonlyArray<Pattern>, body: BlockStatement | Expression, capturedScopes: ReadonlyArray<Map<string, Binding>>, async: boolean, generator: boolean);
 }
 export type GeneratorRequestKind = "next" | "return" | "throw";
 export declare class CodeModeGenerator {
@@ -81,9 +68,9 @@ export declare class PromiseMethodReference {
 }
 export type PromiseInstanceMethodName = "then" | "catch" | "finally";
 export declare class PromiseInstanceMethodReference {
-    readonly promise: CodeModePromise;
+    readonly promise: Values.Promise;
     readonly name: PromiseInstanceMethodName;
-    constructor(promise: CodeModePromise, name: PromiseInstanceMethodName);
+    constructor(promise: Values.Promise, name: PromiseInstanceMethodName);
 }
 export declare class PromiseCapabilityFunction {
     readonly settle: (value: unknown) => void;
@@ -125,7 +112,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 {
@@ -138,12 +124,6 @@ export declare class InterpreterRuntimeError extends Error {
 }
 export declare const unsupportedSyntax: (kind: string, node: AstNode) => InterpreterRuntimeError;
 export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
-export declare const asNode: (value: unknown, context: string) => AstNode;
-export declare const getArray: (node: AstNode, key: string) => Array<unknown>;
-export declare const getString: (node: AstNode, key: string) => string;
-export declare const getBoolean: (node: AstNode, key: string) => boolean;
-export declare const getOptionalNode: (node: AstNode, key: string) => AstNode | undefined;
-export declare const getNode: (node: AstNode, key: string) => AstNode;
 export declare const sourceLocation: (node: AstNode) => {
     readonly line: number;
     readonly column: number;

package/dist/interpreter/model.js

@@ -143,37 +143,6 @@ export class InterpreterRuntimeError extends Error {
 }
 export const unsupportedSyntax = (kind, node) => new InterpreterRuntimeError(`Syntax '${kind}' is not supported. ${supportedSyntaxMessage}`, node, "UnsupportedSyntax", [supportedSyntaxMessage]);
 export const isRecord = (value) => typeof value === "object" && value !== null;
-export const asNode = (value, context) => {
-    if (!isRecord(value) || typeof value.type !== "string") {
-        throw new InterpreterRuntimeError(`Invalid AST node while reading ${context}.`);
-    }
-    return value;
-};
-export const getArray = (node, key) => {
-    const value = node[key];
-    if (!Array.isArray(value))
-        throw new InterpreterRuntimeError(`Expected '${key}' to be an array.`, node);
-    return value;
-};
-export const getString = (node, key) => {
-    const value = node[key];
-    if (typeof value !== "string")
-        throw new InterpreterRuntimeError(`Expected '${key}' to be a string.`, node);
-    return value;
-};
-export const getBoolean = (node, key) => {
-    const value = node[key];
-    if (typeof value !== "boolean")
-        throw new InterpreterRuntimeError(`Expected '${key}' to be a boolean.`, node);
-    return value;
-};
-export const getOptionalNode = (node, key) => {
-    const value = node[key];
-    if (value === undefined || value === null)
-        return undefined;
-    return asNode(value, key);
-};
-export const getNode = (node, key) => asNode(node[key], key);
 export const sourceLocation = (node) => ({
     line: Math.max(1, (node.loc?.start.line ?? 2) - 1),
     column: Math.max(1, (node.loc?.start.column ?? 4) - 3),

package/dist/interpreter/promises.d.ts

@@ -2,7 +2,7 @@ import { Effect, Exit, Scope } from "effect";
 import type { Diagnostic } from "../codemode.js";
 import { type AstNode, InterpreterRuntimeError, PromiseInstanceMethodReference, PromiseMethodReference } from "./model.js";
 import { type CallbackRunner } from "./methods.js";
-import { CodeModePromise } from "../values.js";
+import { Values } from "../values.js";
 import type { SyncIteratorRunner } from "./iterator.js";
 export declare class PromiseRuntime<R> {
     private readonly scope;
@@ -12,18 +12,18 @@ export declare class PromiseRuntime<R> {
     private readonly failures;
     private nextID;
     constructor(scope: Scope.Scope);
-    create(effect: Effect.Effect<unknown, unknown, R>): Effect.Effect<CodeModePromise, never, R>;
-    markObserved(promise: CodeModePromise): void;
-    await(promise: CodeModePromise): Effect.Effect<Exit.Exit<unknown, unknown>>;
+    create(effect: Effect.Effect<unknown, unknown, R>): Effect.Effect<Values.Promise, never, R>;
+    markObserved(promise: Values.Promise): void;
+    await(promise: Values.Promise): Effect.Effect<Exit.Exit<unknown, unknown>>;
     fork(effect: Effect.Effect<unknown, unknown, R>): Effect.Effect<void, never, R>;
     diagnostics(): Array<Diagnostic>;
     interrupt(): Effect.Effect<Array<Diagnostic>>;
 }
 export declare const selfResolutionError: (node?: AstNode) => InterpreterRuntimeError;
 export declare const resolvePromiseValue: <R>(runner: CallbackRunner<R>, value: unknown, node: AstNode, own?: {
-    promise?: CodeModePromise;
+    promise?: Values.Promise;
 }) => Effect.Effect<unknown, unknown, R>;
-export declare const resolvePromise: <R>(runner: CallbackRunner<R>, promises: PromiseRuntime<R>, value: unknown, node: AstNode) => Effect.Effect<CodeModePromise, never, R>;
+export declare const resolvePromise: <R>(runner: CallbackRunner<R>, promises: PromiseRuntime<R>, value: unknown, node: AstNode) => Effect.Effect<Values.Promise, never, R>;
 export declare const invokePromiseMethod: <R>(runner: CallbackRunner<R> & SyncIteratorRunner<R>, promises: PromiseRuntime<R>, ref: PromiseMethodReference, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
-export declare const invokePromiseInstanceMethod: <R>(runner: CallbackRunner<R>, promises: PromiseRuntime<R>, ref: PromiseInstanceMethodReference, args: Array<unknown>, node: AstNode) => Effect.Effect<CodeModePromise, never, R>;
-export declare const constructPromise: <R>(runner: CallbackRunner<R>, promises: PromiseRuntime<R>, executor: unknown, node: AstNode) => Effect.Effect<CodeModePromise, unknown, R>;
+export declare const invokePromiseInstanceMethod: <R>(runner: CallbackRunner<R>, promises: PromiseRuntime<R>, ref: PromiseInstanceMethodReference, args: Array<unknown>, node: AstNode) => Effect.Effect<Values.Promise, never, R>;
+export declare const constructPromise: <R>(runner: CallbackRunner<R>, promises: PromiseRuntime<R>, executor: unknown, node: AstNode) => Effect.Effect<Values.Promise, unknown, R>;

package/dist/interpreter/promises.js

@@ -4,7 +4,7 @@ import { caughtErrorValue, normalizeError } from "./errors.js";
 import { applyCollectionCallback, isSupportedCallback } from "./methods.js";
 import { typeofValue } from "./references.js";
 import { createAggregateErrorValue } from "../stdlib/value.js";
-import { CodeModePromise } from "../values.js";
+import { Values } from "../values.js";
 // Observation only controls rejection reporting; program completion interrupts all promise work.
 export class PromiseRuntime {
     scope;
@@ -21,7 +21,7 @@ export class PromiseRuntime {
             // Allocate before forking so reruns get distinct IDs and diagnostics retain creation order.
             const id = this.nextID++;
             return Effect.map(Effect.forkIn(effect, this.scope, { startImmediately: true }), (fiber) => {
-                const promise = new CodeModePromise(fiber);
+                const promise = new Values.Promise(fiber);
                 this.active.add(promise);
                 this.ids.set(promise, id);
                 fiber.addObserver((exit) => {
@@ -72,7 +72,7 @@ export const selfResolutionError = (node) => new InterpreterRuntimeError("Chaini
 export const resolvePromiseValue = (runner, value, node, own) => {
     if (own?.promise !== undefined && value === own.promise)
         return Effect.fail(selfResolutionError(node));
-    if (value instanceof CodeModePromise)
+    if (value instanceof Values.Promise)
         return runner.settlePromise(value);
     if (value === null || typeof value !== "object" || !Object.hasOwn(value, "then"))
         return Effect.succeed(value);
@@ -99,7 +99,7 @@ export const resolvePromiseValue = (runner, value, node, own) => {
     });
 };
 export const resolvePromise = (runner, promises, value, node) => {
-    if (value instanceof CodeModePromise)
+    if (value instanceof Values.Promise)
         return Effect.succeed(value);
     const box = {};
     return Effect.map(promises.create(resolvePromiseValue(runner, value, node, box)), (promise) => {

package/dist/interpreter/references.js

@@ -1,6 +1,6 @@
 import { AsyncIteratorSymbol, CodeModeFunction, CodeModeGenerator, CoercionFunction, ErrorConstructorReference, GlobalMethodReference, GlobalNamespace, GeneratorMethodReference, InterpreterRuntimeError, IntrinsicReference, IteratorSymbol, JsonMethodReference, PromiseCapabilityFunction, PromiseInstanceMethodReference, PromiseMethodReference, PromiseNamespace, SearchFunction, SymbolNamespace, UriFunction, } from "./model.js";
 import { ToolReference } from "../tool-runtime.js";
-import { isCodeModeValue, CodeModePromise } from "../values.js";
+import { Values } from "../values.js";
 export const isRuntimeReference = (value) => value instanceof CodeModeFunction ||
     value instanceof CodeModeGenerator ||
     value instanceof GeneratorMethodReference ||
@@ -12,14 +12,14 @@ export const isRuntimeReference = (value) => value instanceof CodeModeFunction |
     value instanceof PromiseNamespace ||
     value instanceof PromiseMethodReference ||
     value instanceof PromiseInstanceMethodReference ||
-    value instanceof CodeModePromise ||
+    value instanceof Values.Promise ||
     value instanceof CoercionFunction ||
     value instanceof UriFunction ||
     value instanceof SearchFunction ||
     value instanceof PromiseCapabilityFunction ||
     value instanceof ErrorConstructorReference ||
     value instanceof SymbolNamespace ||
-    isCodeModeValue(value);
+    Values.isValue(value);
 function* childValues(value) {
     for (const key of Reflect.ownKeys(value)) {
         if (!Object.prototype.propertyIsEnumerable.call(value, key))
@@ -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 (isCodeModeValue(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

@@ -1,5 +1,5 @@
+import type { Program } from "acorn";
 import { Effect } from "effect";
-import { type ProgramNode } from "./model.js";
 import { PromiseRuntime } from "./promises.js";
 export declare class Interpreter<R> {
     private scopes;
@@ -12,7 +12,7 @@ export declare class Interpreter<R> {
     private generatorAsync;
     private readonly runner;
     constructor(executeTool: (path: ReadonlyArray<string>, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>, invokeSearch: (args: Array<unknown>) => Effect.Effect<unknown, unknown, R>, toolKeys: (path: ReadonlyArray<string>) => ReadonlyArray<string>, promises: PromiseRuntime<R>, logs?: Array<string>);
-    run(program: ProgramNode): Effect.Effect<unknown, unknown, R>;
+    run(program: Program): Effect.Effect<unknown, unknown, R>;
     private createToolCallPromise;
     private createPromise;
     private settlePromise;
@@ -55,7 +55,6 @@ export declare class Interpreter<R> {
     private constructArray;
     private constructObject;
     private constructDate;
-    private toDatePrimitive;
     private constructRegExp;
     private constructMap;
     private constructSet;