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

package/README.md

@@ -91,6 +91,12 @@ runtime.execute(source) // Effect<CodeMode.Result, never, ToolServices>
 The Effect environment is inferred from the supplied tools. `onToolCallStart` observes admitted calls with decoded
 input; `onToolCallEnd` observes settled outcomes and duration. Both hooks return Effects and must not fail.
 
+### `Values`
+
+`Values` exports the runtime's non-JSON value classes: `Values.URL`, `Values.URLSearchParams`, `Values.Date`,
+`Values.RegExp`, `Values.Map`, `Values.Set`, and `Values.Promise`. The interpreter recognizes these by class; a
+program's `new URL(...)` is a `Values.URL` wrapping the host `URL`. `Values.isValue` narrows to the data-like kinds.
+
 ### OpenAPI tools
 
 `OpenAPI.fromSpec` converts an OpenAPI 3.x document into one tool per supported operation. Dotted `operationId` values

package/dist/index.d.ts

@@ -2,5 +2,6 @@ export * as CodeMode from "./codemode.js";
 export * as Namespace from "./namespace.js";
 export * as Tool from "./tool.js";
 export * as OpenAPI from "./openapi/index.js";
+export { Values } from "./values.js";
 export { searchSignature, toolExpression } from "./codemode.js";
 export { ToolError, toolError } from "./tool-error.js";

package/dist/index.js

@@ -2,5 +2,6 @@ export * as CodeMode from "./codemode.js";
 export * as Namespace from "./namespace.js";
 export * as Tool from "./tool.js";
 export * as OpenAPI from "./openapi/index.js";
+export { Values } from "./values.js";
 export { searchSignature, toolExpression } from "./codemode.js";
 export { ToolError, toolError } from "./tool-error.js";

package/dist/interpreter/methods.d.ts

@@ -1,11 +1,11 @@
 import { Effect } from "effect";
 import { type AstNode, CodeModeFunction, CoercionFunction, ErrorConstructorReference, GlobalMethodReference, GlobalNamespace, IntrinsicReference, JsonMethodReference, PromiseCapabilityFunction, PromiseNamespace, UriFunction } from "./model.js";
-import { CodeModePromise } from "../values.js";
+import { Values } from "../values.js";
 import { type SyncIteratorRunner } from "./iterator.js";
 export type CallbackRunner<R> = {
     readonly invokeFunction: (fn: CodeModeFunction, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>;
     readonly invokeCallable: (callable: unknown, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
-    readonly settlePromise: (promise: CodeModePromise) => Effect.Effect<unknown, unknown, never>;
+    readonly settlePromise: (promise: Values.Promise) => Effect.Effect<unknown, unknown, never>;
 };
 export type SupportedCallback = CodeModeFunction | CoercionFunction | UriFunction | PromiseCapabilityFunction | GlobalMethodReference | JsonMethodReference | IntrinsicReference | ErrorConstructorReference | GlobalNamespace | PromiseNamespace;
 export declare const isSupportedCallback: (value: unknown) => value is SupportedCallback;

package/dist/interpreter/methods.js

@@ -2,7 +2,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 { CodeModeDate, CodeModeMap, CodeModePromise, CodeModeRegExp, CodeModeSet, CodeModeURL, CodeModeURLSearchParams, isCodeModeValue, } from "../values.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";
@@ -41,7 +41,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,25 +52,25 @@ 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)) {
+    if (value === null || typeof value !== "object" || Array.isArray(value) || Values.isValue(value)) {
         return Effect.succeed(coerceToNumber(value));
     }
     const object = value;
@@ -129,7 +129,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 +172,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 +203,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) {
@@ -292,7 +292,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 +347,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,10 +384,10 @@ export const invokeGroupBy = (runner, namespace, args, node) => {
     });
 };
 const coerceGroupByPropertyKey = (runner, value, node) => {
-    if (value === null || typeof value !== "object" || Array.isArray(value) || isCodeModeValue(value)) {
+    if (value === null || typeof value !== "object" || Array.isArray(value) || Values.isValue(value)) {
         return Effect.succeed(coerceToString(value));
     }
-    if (value instanceof CodeModePromise)
+    if (value instanceof Values.Promise)
         return Effect.succeed("[object Promise]");
     if (isRuntimeReference(value)) {
         throw new InterpreterRuntimeError("Object.groupBy callback must return a data value.", node, "InvalidDataValue");
@@ -434,7 +434,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);
         }
@@ -456,7 +456,7 @@ const invokeStringReplacer = (runner, value, name, args, node) => {
         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
+            output.push(value.slice(end, match.offset), replacement instanceof Values.Promise
                 ? "[object Promise]"
                 : errorBrandName(replacement)
                     ? coerceToString(replacement)
@@ -562,7 +562,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 +631,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;

package/dist/interpreter/model.d.ts

@@ -1,6 +1,6 @@
 import type { Effect } from "effect";
 import type { SafeObject } from "../tool-runtime.js";
-import type { CodeModePromise, CodeModeRegExp, CodeModeURL } from "../values.js";
+import type { Values } from "../values.js";
 export type SourcePosition = {
     line: number;
     column: number;
@@ -36,7 +36,7 @@ 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 {
@@ -81,9 +81,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;

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))
@@ -59,7 +59,7 @@ export const containsOpaqueReference = (value) => {
             continue;
         }
         const current = next.value;
-        if (isCodeModeValue(current))
+        if (Values.isValue(current))
             continue;
         if (isRuntimeReference(current))
             return true;

package/dist/interpreter/runtime.js

@@ -19,7 +19,7 @@ import { escapeRegexHint, regexpMethods, regexpProperties, regexpStatics, regexF
 import { stringMethods, stringStatics } from "../stdlib/string.js";
 import { urlMethods, urlProperties, urlSearchParamsMethods, urlStatics, urlWritableProperties, invokeUriFunction, uriArgument, urlArgument, } from "../stdlib/url.js";
 import { boundedData, coerceToNumber, coerceToString, compoundOperators, errorBrandName, errorConstructors, invokeCoercion, valueConstructors, } from "../stdlib/value.js";
-import { isCodeModeValue, CodeModeDate, CodeModeMap, CodeModePromise, CodeModeRegExp, CodeModeSet, CodeModeURL, CodeModeURLSearchParams, } from "../values.js";
+import { Values } from "../values.js";
 const globalStaticMembers = {
     Object: objectStatics,
     Math: mathMethods,
@@ -62,17 +62,17 @@ const instanceofValue = (lhs, rhs, node) => {
     if (rhs instanceof GlobalNamespace) {
         switch (rhs.name) {
             case "Date":
-                return lhs instanceof CodeModeDate;
+                return lhs instanceof Values.Date;
             case "RegExp":
-                return lhs instanceof CodeModeRegExp;
+                return lhs instanceof Values.RegExp;
             case "Map":
-                return lhs instanceof CodeModeMap;
+                return lhs instanceof Values.Map;
             case "Set":
-                return lhs instanceof CodeModeSet;
+                return lhs instanceof Values.Set;
             case "URL":
-                return lhs instanceof CodeModeURL;
+                return lhs instanceof Values.URL;
             case "URLSearchParams":
-                return lhs instanceof CodeModeURLSearchParams;
+                return lhs instanceof Values.URLSearchParams;
             case "Array":
                 return Array.isArray(lhs);
             case "Object":
@@ -80,7 +80,7 @@ const instanceofValue = (lhs, rhs, node) => {
         }
     }
     if (rhs instanceof PromiseNamespace)
-        return lhs instanceof CodeModePromise;
+        return lhs instanceof Values.Promise;
     if (rhs instanceof CoercionFunction && (rhs.name === "Number" || rhs.name === "String" || rhs.name === "Boolean")) {
         return false;
     }
@@ -594,11 +594,11 @@ export class Interpreter {
             ? value[Symbol.iterator]()
             : typeof value === "string"
                 ? value[Symbol.iterator]()
-                : value instanceof CodeModeMap
+                : value instanceof Values.Map
                     ? value.map.entries()
-                    : value instanceof CodeModeSet
+                    : value instanceof Values.Set
                         ? value.set.values()
-                        : value instanceof CodeModeURLSearchParams
+                        : value instanceof Values.URLSearchParams
                             ? value.params.entries()
                             : undefined;
         if (iterator !== undefined) {
@@ -1162,17 +1162,17 @@ export class Interpreter {
     }
     constructDate(args, node) {
         if (args.length === 0)
-            return Effect.succeed(new CodeModeDate(Date.now()));
+            return Effect.succeed(new Values.Date(Date.now()));
         if (args.length === 1) {
             const arg = args[0];
-            if (arg instanceof CodeModeDate)
-                return Effect.succeed(new CodeModeDate(arg.time));
+            if (arg instanceof Values.Date)
+                return Effect.succeed(new Values.Date(arg.time));
             return Effect.map(this.toDatePrimitive(arg, node), (value) => typeof value === "string"
-                ? new CodeModeDate(Date.parse(value))
-                : new CodeModeDate(new Date(coerceToNumber(value)).getTime()));
+                ? 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 CodeModeDate(new Date(...parts).getTime()));
+        return Effect.succeed(new Values.Date(new Date(...parts).getTime()));
     }
     toDatePrimitive(value, node) {
         if (value === null || (typeof value !== "object" && typeof value !== "function"))
@@ -1197,14 +1197,14 @@ export class Interpreter {
     }
     constructRegExp(args, node) {
         const first = args[0];
-        const pattern = first instanceof CodeModeRegExp ? first.regex.source : first === undefined ? "" : coerceToString(first);
+        const pattern = first instanceof Values.RegExp ? first.regex.source : first === undefined ? "" : coerceToString(first);
         const flagsArg = args[1];
         if (flagsArg !== undefined && typeof flagsArg !== "string") {
             throw new InterpreterRuntimeError(`RegExp flags must be a string of flag characters (e.g. "g", "gi"), not ${flagsArg === null ? "null" : typeof flagsArg}.`, node).as("SyntaxError");
         }
-        const flags = flagsArg ?? (first instanceof CodeModeRegExp ? first.regex.flags : "");
+        const flags = flagsArg ?? (first instanceof Values.RegExp ? first.regex.flags : "");
         try {
-            return new CodeModeRegExp(pattern, flags);
+            return new Values.RegExp(pattern, flags);
         }
         catch (error) {
             const reason = regexFailureReason(error);
@@ -1214,7 +1214,7 @@ export class Interpreter {
         }
     }
     constructMap(init, node) {
-        const target = new CodeModeMap();
+        const target = new Values.Map();
         if (init === undefined || init === null)
             return Effect.succeed(target);
         const self = this;
@@ -1237,7 +1237,7 @@ export class Interpreter {
         });
     }
     constructSet(init, node) {
-        const target = new CodeModeSet();
+        const target = new Values.Set();
         if (init === undefined || init === null)
             return Effect.succeed(target);
         const self = this;
@@ -1261,7 +1261,7 @@ export class Interpreter {
         const input = urlArgument(args[0], "new URL input");
         const base = args[1] === undefined ? undefined : urlArgument(args[1], "new URL base");
         try {
-            return new CodeModeURL(new URL(input, base));
+            return new Values.URL(new URL(input, base));
         }
         catch {
             throw new InterpreterRuntimeError(`new URL(...) received an invalid URL${base === undefined ? "" : " or base URL"}.`, node).as("TypeError");
@@ -1269,14 +1269,14 @@ export class Interpreter {
     }
     constructURLSearchParams(init, node) {
         if (init === undefined)
-            return Effect.succeed(new CodeModeURLSearchParams(new URLSearchParams()));
-        if (init instanceof CodeModeURLSearchParams) {
-            return Effect.succeed(new CodeModeURLSearchParams(new URLSearchParams(init.params)));
+            return Effect.succeed(new Values.URLSearchParams(new URLSearchParams()));
+        if (init instanceof Values.URLSearchParams) {
+            return Effect.succeed(new Values.URLSearchParams(new URLSearchParams(init.params)));
         }
         if (typeof init === "string")
-            return Effect.succeed(new CodeModeURLSearchParams(new URLSearchParams(init)));
+            return Effect.succeed(new Values.URLSearchParams(new URLSearchParams(init)));
         if (init === null || typeof init === "number" || typeof init === "boolean") {
-            return Effect.succeed(new CodeModeURLSearchParams(new URLSearchParams(coerceToString(init))));
+            return Effect.succeed(new Values.URLSearchParams(new URLSearchParams(coerceToString(init))));
         }
         const self = this;
         return Effect.gen(function* () {
@@ -1289,7 +1289,7 @@ export class Interpreter {
                         if (entries.some((entry) => entry.length !== 2)) {
                             throw new InterpreterRuntimeError("new URLSearchParams(...) expects iterable [name, value] pairs.", node).as("TypeError");
                         }
-                        return new CodeModeURLSearchParams(new URLSearchParams(entries.map((entry) => [entry[0] ?? "", entry[1] ?? ""])));
+                        return new Values.URLSearchParams(new URLSearchParams(entries.map((entry) => [entry[0] ?? "", entry[1] ?? ""])));
                     }
                     entries.push(yield* preserveConsumerError(cursor, self.readURLSearchParamsPair(step.value, node)));
                 }
@@ -1297,13 +1297,13 @@ export class Interpreter {
             if (isRuntimeReference(init)) {
                 throw new InterpreterRuntimeError("new URLSearchParams(...) expects a query string, data object, or synchronous iterable pairs.", node).as("TypeError");
             }
-            if (isCodeModeValue(init))
-                return new CodeModeURLSearchParams(new URLSearchParams());
+            if (Values.isValue(init))
+                return new Values.URLSearchParams(new URLSearchParams());
             const data = boundedData(init, "new URLSearchParams input");
             if (data === null || typeof data !== "object") {
                 throw new InterpreterRuntimeError("new URLSearchParams(...) expects a query string, data object, iterable pairs, or URLSearchParams.", node).as("TypeError");
             }
-            return new CodeModeURLSearchParams(new URLSearchParams(Object.fromEntries(Object.entries(data).map(([key, value]) => [key, coerceToString(value)]))));
+            return new Values.URLSearchParams(new URLSearchParams(Object.fromEntries(Object.entries(data).map(([key, value]) => [key, coerceToString(value)]))));
         });
     }
     readURLSearchParamsPair(value, node) {
@@ -1344,7 +1344,7 @@ export class Interpreter {
         // Null-prototype data needs explicit primitive coercion; identity and `in` retain raw objects.
         // Dates use their default string hint for addition and loose equality, and epoch time elsewhere.
         const coerceOperand = (operand) => {
-            if (operand instanceof CodeModeDate) {
+            if (operand instanceof Values.Date) {
                 return operator === "+" || operator === "==" || operator === "!=" ? coerceToString(operand) : operand.time;
             }
             return operand !== null && typeof operand === "object" ? coerceToString(operand) : operand;
@@ -1432,7 +1432,7 @@ export class Interpreter {
             if (containsOpaqueReference(value)) {
                 throw new InterpreterRuntimeError("Unary operators require data values.", node, "InvalidDataValue");
             }
-            const operand = value instanceof CodeModeDate
+            const operand = value instanceof Values.Date
                 ? value.time
                 : value !== null && typeof value === "object"
                     ? coerceToString(value)
@@ -1870,9 +1870,9 @@ export class Interpreter {
         return Effect.gen(function* () {
             if (Array.isArray(value) ||
                 typeof value === "string" ||
-                value instanceof CodeModeMap ||
-                value instanceof CodeModeSet ||
-                value instanceof CodeModeURLSearchParams) {
+                value instanceof Values.Map ||
+                value instanceof Values.Set ||
+                value instanceof Values.URLSearchParams) {
                 const cursor = yield* self.syncIterator(value, node);
                 if (!cursor)
                     throw new InterpreterRuntimeError("Built-in iterator is unavailable.", node);
@@ -1947,7 +1947,7 @@ export class Interpreter {
                 const property = asNode(propertyValue, "properties");
                 if (property.type === "SpreadElement") {
                     const spread = yield* self.evaluateExpression(getNode(property, "argument"));
-                    if (spread === null || spread === undefined || isCodeModeValue(spread))
+                    if (spread === null || spread === undefined || Values.isValue(spread))
                         continue;
                     if (typeof spread !== "object" || Array.isArray(spread) || isRuntimeReference(spread)) {
                         throw new InterpreterRuntimeError("Object spread requires a data object.", property, "InvalidDataValue");
@@ -2139,12 +2139,12 @@ export class Interpreter {
                 }
                 return new ComputedValue(undefined);
             }
-            if (objectValue instanceof CodeModeDate) {
+            if (objectValue instanceof Values.Date) {
                 if (typeof key === "string" && dateMethods.has(key))
                     return new IntrinsicReference(objectValue, key);
                 return new ComputedValue(undefined);
             }
-            if (objectValue instanceof CodeModeRegExp) {
+            if (objectValue instanceof Values.RegExp) {
                 if (key === "lastIndex")
                     return { target: objectValue, key };
                 if (typeof key === "string" && regexpProperties.has(key)) {
@@ -2154,21 +2154,21 @@ export class Interpreter {
                     return new IntrinsicReference(objectValue, key);
                 return new ComputedValue(undefined);
             }
-            if (objectValue instanceof CodeModeMap) {
+            if (objectValue instanceof Values.Map) {
                 if (key === "size")
                     return new ComputedValue(objectValue.map.size);
                 if (typeof key === "string" && mapMethods.has(key))
                     return new IntrinsicReference(objectValue, key);
                 return new ComputedValue(undefined);
             }
-            if (objectValue instanceof CodeModeSet) {
+            if (objectValue instanceof Values.Set) {
                 if (key === "size")
                     return new ComputedValue(objectValue.set.size);
                 if (typeof key === "string" && setMethods.has(key))
                     return new IntrinsicReference(objectValue, key);
                 return new ComputedValue(undefined);
             }
-            if (objectValue instanceof CodeModeURL) {
+            if (objectValue instanceof Values.URL) {
                 if (key === "searchParams") {
                     return new ComputedValue(objectValue.searchParams);
                 }
@@ -2178,7 +2178,7 @@ export class Interpreter {
                     return { target: objectValue, key };
                 return new ComputedValue(undefined);
             }
-            if (objectValue instanceof CodeModeURLSearchParams) {
+            if (objectValue instanceof Values.URLSearchParams) {
                 if (key === "size")
                     return new ComputedValue(objectValue.params.size);
                 if (typeof key === "string" && urlSearchParamsMethods.has(key)) {
@@ -2187,7 +2187,7 @@ export class Interpreter {
                 return new ComputedValue(undefined);
             }
             // Reject unknown promise properties so a missing await cannot hide.
-            if (objectValue instanceof CodeModePromise) {
+            if (objectValue instanceof Values.Promise) {
                 if (key === "then" || key === "catch" || key === "finally") {
                     return new PromiseInstanceMethodReference(objectValue, key);
                 }
@@ -2242,9 +2242,9 @@ export class Interpreter {
                     return new IntrinsicReference(reference.target, reference.key);
                 return Reflect.get(reference.target, reference.key);
             }
-            if (reference.target instanceof CodeModeRegExp)
+            if (reference.target instanceof Values.RegExp)
                 return reference.target.lastIndex;
-            if (reference.target instanceof CodeModeURL) {
+            if (reference.target instanceof Values.URL) {
                 return Reflect.get(reference.target.url, reference.key);
             }
             return Reflect.get(reference.target, reference.key);
@@ -2264,10 +2264,10 @@ export class Interpreter {
             if (reference instanceof ComputedValue ||
                 reference === undefined ||
                 isOpaqueMemberReference(reference) ||
-                reference.target instanceof CodeModeURL) {
+                reference.target instanceof Values.URL) {
                 throw new InterpreterRuntimeError("Only data fields may be deleted.", target, "InvalidDataValue");
             }
-            if (reference.target instanceof CodeModeRegExp) {
+            if (reference.target instanceof Values.RegExp) {
                 return Reflect.deleteProperty(reference.target.regex, reference.key);
             }
             return Reflect.deleteProperty(reference.target, reference.key);
@@ -2299,10 +2299,10 @@ export class Interpreter {
         });
     }
     readReferenceValue(reference, key) {
-        if (reference.target instanceof CodeModeURL) {
+        if (reference.target instanceof Values.URL) {
             return Reflect.get(reference.target.url, key);
         }
-        if (reference.target instanceof CodeModeRegExp)
+        if (reference.target instanceof Values.RegExp)
             return reference.target.lastIndex;
         return Reflect.get(reference.target, key);
     }
@@ -2316,7 +2316,7 @@ export class Interpreter {
             target[key] = next;
             return;
         }
-        if (reference.target instanceof CodeModeURL) {
+        if (reference.target instanceof Values.URL) {
             const property = key;
             if (!urlWritableProperties.has(property)) {
                 throw new InterpreterRuntimeError(`URL.${property} is read-only.`, node).as("TypeError");
@@ -2332,7 +2332,7 @@ export class Interpreter {
                 throw new InterpreterRuntimeError(`URL.${property} received an invalid value.`, node).as("TypeError");
             }
         }
-        if (reference.target instanceof CodeModeRegExp) {
+        if (reference.target instanceof Values.RegExp) {
             reference.target.lastIndex = next;
             return;
         }

package/dist/stdlib/console.js

@@ -1,6 +1,6 @@
 import { containsOpaqueReference, containsRuntimeReference, isRuntimeReference } from "../interpreter/references.js";
 import { copyIn, copyOut } from "../tool-runtime.js";
-import { isCodeModeValue, CodeModeDate, CodeModeMap, CodeModePromise, CodeModeRegExp, CodeModeSet, CodeModeURL, CodeModeURLSearchParams, } from "../values.js";
+import { Values } from "../values.js";
 import { boundedData, coerceToString } from "./value.js";
 export const consoleMethods = new Set(["log", "info", "debug", "warn", "error", "dir", "table"]);
 const MAX_CONSOLE_DEPTH = 32;
@@ -28,21 +28,21 @@ const formatConsoleValue = (value, seen, depth) => {
         return String(value);
     if (typeof value !== "object")
         return String(value);
-    if (value instanceof CodeModePromise)
+    if (value instanceof Values.Promise)
         return "[Promise (await it to get its value)]";
-    if (value instanceof CodeModeDate)
+    if (value instanceof Values.Date)
         return coerceToString(value);
-    if (value instanceof CodeModeRegExp)
+    if (value instanceof Values.RegExp)
         return coerceToString(value);
-    if (value instanceof CodeModeURL)
+    if (value instanceof Values.URL)
         return coerceToString(value);
-    if (value instanceof CodeModeURLSearchParams)
+    if (value instanceof Values.URLSearchParams)
         return coerceToString(value);
     if (depth > MAX_CONSOLE_DEPTH)
         return "...";
     if (seen.has(value))
         return "[Circular]";
-    if (value instanceof CodeModeMap) {
+    if (value instanceof Values.Map) {
         seen.add(value);
         try {
             const entries = Array.from(value.map.entries(), ([key, item]) => [key, item]);
@@ -52,7 +52,7 @@ const formatConsoleValue = (value, seen, depth) => {
             seen.delete(value);
         }
     }
-    if (value instanceof CodeModeSet) {
+    if (value instanceof Values.Set) {
         seen.add(value);
         try {
             return `Set(${value.set.size}) ${formatConsoleValue(Array.from(value.set.values()), seen, depth + 1)}`;
@@ -103,13 +103,13 @@ const consoleTableRows = (data, columns) => {
     if (Array.isArray(data)) {
         return data.map((item, index) => ({ index: String(index), values: consoleTableValues(item, columns) }));
     }
-    if (data !== null && typeof data === "object" && !isCodeModeValue(data)) {
+    if (data !== null && typeof data === "object" && !Values.isValue(data)) {
         return Object.entries(data).map(([index, item]) => ({ index, values: consoleTableValues(item, columns) }));
     }
     return [{ index: "0", values: { Value: data } }];
 };
 const consoleTableValues = (value, columns) => {
-    if (value !== null && typeof value === "object" && !Array.isArray(value) && !isCodeModeValue(value)) {
+    if (value !== null && typeof value === "object" && !Array.isArray(value) && !Values.isValue(value)) {
         const source = value;
         if (columns !== undefined)
             return Object.fromEntries(columns.map((column) => [column, source[column]]));

package/dist/stdlib/date.d.ts

@@ -1,7 +1,7 @@
 import { type AstNode } from "../interpreter/model.js";
-import { CodeModeDate } from "../values.js";
+import { Values } from "../values.js";
 export declare const dateMethods: Set<string>;
 export declare const dateStatics: Set<string>;
 export declare const invokeDateStatic: (name: string, args: Array<unknown>, node: AstNode) => number;
 export declare const dateSetterArgumentCount: (name: string) => number | undefined;
-export declare const invokeDateMethod: (value: CodeModeDate, name: string, args: Array<number>, node: AstNode, initialTime?: number) => unknown;
+export declare const invokeDateMethod: (value: Values.Date, name: string, args: Array<number>, node: AstNode, initialTime?: number) => unknown;

package/dist/stdlib/date.js

@@ -1,5 +1,5 @@
 import { InterpreterRuntimeError } from "../interpreter/model.js";
-import { CodeModeDate } from "../values.js";
+import { Values } from "../values.js";
 import { coerceToNumber, coerceToString } from "./value.js";
 const dateSetterArguments = new Map([
     ["setTime", 1],

package/dist/stdlib/json.js

@@ -3,7 +3,7 @@ import { applyCollectionCallback } from "../interpreter/methods.js";
 import { InterpreterRuntimeError } from "../interpreter/model.js";
 import { typeofValue } from "../interpreter/references.js";
 import { copyIn, copyOut } from "../tool-runtime.js";
-import { CodeModeDate, CodeModeMap, CodeModeRegExp, CodeModeSet, CodeModeURL, CodeModeURLSearchParams, } from "../values.js";
+import { Values } from "../values.js";
 export const jsonStatics = new Set(["parse", "stringify"]);
 export const invokeJsonMethod = (runner, name, args, node) => {
     return name === "parse" ? parse(runner, args, node) : stringify(runner, args, node);
@@ -107,18 +107,18 @@ const stringify = (runner, args, node) => {
     return Effect.map(visit(root, ""), (value) => JSON.stringify(value, null, indent));
 };
 const toJSONValue = (value) => {
-    if (value instanceof CodeModeDate) {
+    if (value instanceof Values.Date) {
         return Number.isFinite(value.time) ? new Date(value.time).toISOString() : null;
     }
-    if (value instanceof CodeModeURL)
+    if (value instanceof Values.URL)
         return value.url.href;
     return value;
 };
 const isPlainObject = (value) => value !== null &&
     typeof value === "object" &&
-    !(value instanceof CodeModeDate) &&
-    !(value instanceof CodeModeRegExp) &&
-    !(value instanceof CodeModeMap) &&
-    !(value instanceof CodeModeSet) &&
-    !(value instanceof CodeModeURL) &&
-    !(value instanceof CodeModeURLSearchParams);
+    !(value instanceof Values.Date) &&
+    !(value instanceof Values.RegExp) &&
+    !(value instanceof Values.Map) &&
+    !(value instanceof Values.Set) &&
+    !(value instanceof Values.URL) &&
+    !(value instanceof Values.URLSearchParams);

package/dist/stdlib/object.js

@@ -2,7 +2,7 @@ import { Effect } from "effect";
 import { AsyncIteratorSymbol, InterpreterRuntimeError, IteratorSymbol } from "../interpreter/model.js";
 import { containsOpaqueReference, rejectCircularInsertion } from "../interpreter/references.js";
 import { isBlockedMember } from "../tool-runtime.js";
-import { isCodeModeValue, CodeModePromise } from "../values.js";
+import { Values } from "../values.js";
 import { boundedData, coerceToString } from "./value.js";
 import { preserveConsumerError } from "../interpreter/iterator.js";
 export const objectMethodsPreservingIdentity = new Set(["assign", "values", "entries", "fromEntries"]);
@@ -12,9 +12,9 @@ export const invokeObjectMethod = (name, args, node) => {
         const input = args[0];
         if (Array.isArray(input))
             return input;
-        if (isCodeModeValue(input))
+        if (Values.isValue(input))
             return {};
-        if (input instanceof CodeModePromise) {
+        if (input instanceof Values.Promise) {
             throw new InterpreterRuntimeError(`Object.${name} received an un-awaited Promise; await it before inspecting the result.`, node, "InvalidDataValue");
         }
         if (input === null || typeof input !== "object") {
@@ -42,7 +42,7 @@ export const invokeObjectMethod = (name, args, node) => {
             return Object.is(args[0], args[1]);
         case "assign": {
             const target = args[0];
-            if (target === null || typeof target !== "object" || Array.isArray(target) || isCodeModeValue(target)) {
+            if (target === null || typeof target !== "object" || Array.isArray(target) || Values.isValue(target)) {
                 throw new InterpreterRuntimeError("Object.assign expects a data object target.", node);
             }
             const out = target;
@@ -55,7 +55,7 @@ export const invokeObjectMethod = (name, args, node) => {
                     throw new InterpreterRuntimeError(`Object.assign could not assign property '${String(key)}'.`, node).as("TypeError");
             };
             for (const source of args.slice(1)) {
-                if (source === null || source === undefined || isCodeModeValue(source))
+                if (source === null || source === undefined || Values.isValue(source))
                     continue;
                 if (typeof source !== "object" || Array.isArray(source)) {
                     throw new InterpreterRuntimeError("Object.assign expects data objects.", node);
@@ -92,7 +92,7 @@ export const invokeObjectFromEntries = (runner, source, node) => {
             yield* preserveConsumerError(cursor, Effect.sync(() => {
                 if (step.value === null ||
                     typeof step.value !== "object" ||
-                    isCodeModeValue(step.value) ||
+                    Values.isValue(step.value) ||
                     containsOpaqueReference(step.value)) {
                     throw new InterpreterRuntimeError("Object.fromEntries expects [key, value] entry objects.", node).as("TypeError");
                 }

package/dist/stdlib/regexp.d.ts

@@ -1,5 +1,5 @@
 import { type AstNode } from "../interpreter/model.js";
-import { CodeModeRegExp } from "../values.js";
+import { Values } from "../values.js";
 export declare const regexpMethods: Set<string>;
 export declare const regexpStatics: Set<string>;
 export declare const regexpProperties: Set<string>;
@@ -8,4 +8,4 @@ export declare const escapeRegexHint = "To match special characters like ( ) [ ]
 export declare const toHostRegex: (arg: unknown, method: string, node: AstNode, extraFlags?: string) => RegExp;
 export declare const matchToValue: (match: RegExpMatchArray) => Array<unknown>;
 export declare const invokeRegExpStatic: (name: string, args: Array<unknown>, node: AstNode) => string;
-export declare const invokeRegExpMethod: (value: CodeModeRegExp, name: string, args: Array<unknown>, node: AstNode) => unknown;
+export declare const invokeRegExpMethod: (value: Values.RegExp, name: string, args: Array<unknown>, node: AstNode) => unknown;

package/dist/stdlib/regexp.js

@@ -1,6 +1,6 @@
 import { InterpreterRuntimeError } from "../interpreter/model.js";
 import { isBlockedMember } from "../tool-runtime.js";
-import { CodeModeRegExp } from "../values.js";
+import { Values } from "../values.js";
 import { coerceToNumber, coerceToString } from "./value.js";
 export const regexpMethods = new Set(["test", "exec", "toString"]);
 export const regexpStatics = new Set(["escape"]);
@@ -23,7 +23,7 @@ export const toHostRegex = (arg, method, node, extraFlags = "") => {
     // Native parity: an undefined pattern behaves as an empty pattern.
     if (arg === undefined)
         return new RegExp("", extraFlags);
-    if (arg instanceof CodeModeRegExp)
+    if (arg instanceof Values.RegExp)
         return arg.regex;
     if (typeof arg === "string") {
         try {

package/dist/stdlib/url.d.ts

@@ -7,6 +7,6 @@ export declare const uriArgument: (value: unknown, label: string) => string;
 export declare const invokeUriFunction: (ref: UriFunction, args: Array<unknown>, node: AstNode) => string;
 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: CodeModeURL, name: string, node: AstNode) => string;
+export declare const invokeURLMethod: (value: Values.URL, name: string, node: AstNode) => string;
 import { type AstNode, UriFunction } from "../interpreter/model.js";
-import { CodeModeURL } from "../values.js";
+import { Values } from "../values.js";

package/dist/stdlib/url.js

@@ -58,7 +58,7 @@ export const invokeUriFunction = (ref, args, node) => {
         throw new InterpreterRuntimeError(`${ref.name} received malformed URI data: ${error instanceof Error ? error.message : String(error)}`, node).as("URIError");
     }
 };
-export const urlArgument = (value, label) => value instanceof CodeModeURL ? value.url.href : uriArgument(value, label);
+export const urlArgument = (value, label) => value instanceof Values.URL ? value.url.href : uriArgument(value, label);
 export const invokeURLStatic = (name, args, node) => {
     if (!urlStatics.has(name))
         throw new InterpreterRuntimeError(`URL.${name} is not available.`, node);
@@ -68,7 +68,7 @@ export const invokeURLStatic = (name, args, node) => {
     const base = args[1] === undefined ? undefined : urlArgument(args[1], `URL.${name} base`);
     try {
         const url = new URL(input, base);
-        return name === "canParse" ? true : new CodeModeURL(url);
+        return name === "canParse" ? true : new Values.URL(url);
     }
     catch {
         return name === "canParse" ? false : null;
@@ -80,5 +80,5 @@ export const invokeURLMethod = (value, name, node) => {
     throw new InterpreterRuntimeError(`URL method '${name}' is not available.`, node);
 };
 import { InterpreterRuntimeError, UriFunction } from "../interpreter/model.js";
-import { CodeModeURL } from "../values.js";
+import { Values } from "../values.js";
 import { boundedData, coerceToString } from "./value.js";

package/dist/stdlib/value.js

@@ -26,17 +26,17 @@ export const coerceToString = (value) => {
         return "null";
     if (value === undefined)
         return "undefined";
-    if (value instanceof CodeModeDate)
+    if (value instanceof Values.Date)
         return Number.isFinite(value.time) ? new Date(value.time).toISOString() : "Invalid Date";
-    if (value instanceof CodeModeRegExp)
+    if (value instanceof Values.RegExp)
         return `/${value.regex.source}/${value.regex.flags}`;
-    if (value instanceof CodeModeMap)
+    if (value instanceof Values.Map)
         return "[object Map]";
-    if (value instanceof CodeModeSet)
+    if (value instanceof Values.Set)
         return "[object Set]";
-    if (value instanceof CodeModeURL)
+    if (value instanceof Values.URL)
         return value.url.href;
-    if (value instanceof CodeModeURLSearchParams)
+    if (value instanceof Values.URLSearchParams)
         return value.params.toString();
     if (errorBrandName(value) !== undefined) {
         // Match Error.prototype.toString: "name: message", or just one when the other is empty.
@@ -57,9 +57,9 @@ export const coerceToString = (value) => {
     return String(value);
 };
 export const coerceToNumber = (value) => {
-    if (value instanceof CodeModeDate)
+    if (value instanceof Values.Date)
         return value.time;
-    if (isCodeModeValue(value))
+    if (Values.isValue(value))
         return Number.NaN;
     // Arrays coerce through our own string coercion: host Number(array) joins with host
     // ToPrimitive, which throws on the null-prototype objects the interpreter produces.
@@ -80,7 +80,7 @@ export const invokeCoercion = (ref, args, node) => {
     // Error values are plain SafeObjects; the boundedData path below would strip their brand.
     if (ref.name === "String" && errorBrandName(raw) !== undefined)
         return coerceToString(raw);
-    if (isCodeModeValue(raw)) {
+    if (Values.isValue(raw)) {
         if (ref.name === "Boolean")
             return true;
         if (ref.name === "Number")
@@ -117,4 +117,4 @@ export const invokeCoercion = (ref, args, node) => {
 };
 import { CoercionFunction, InterpreterRuntimeError } from "../interpreter/model.js";
 import { copyIn } from "../tool-runtime.js";
-import { isCodeModeValue, CodeModeDate, CodeModeMap, CodeModeRegExp, CodeModeSet, CodeModeURL, CodeModeURLSearchParams, } from "../values.js";
+import { Values } from "../values.js";

package/dist/tool-runtime.js

@@ -3,7 +3,7 @@ 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";
+import { Values } from "./values.js";
 const compareText = (left, right) => (left < right ? -1 : left > right ? 1 : 0);
 const defaultSearchLimit = 10;
 const PositiveInt = Schema.Int.check(Schema.isGreaterThan(0));
@@ -64,54 +64,54 @@ const copyBounded = (value, label, depth, seen, preserveCodeModeValues) => {
     if (typeof value !== "object") {
         throw new ToolRuntimeError("InvalidDataValue", `${label} must contain data only.`);
     }
-    if (value instanceof CodeModePromise) {
+    if (value instanceof Values.Promise) {
         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) {
+        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) {
             return value;
         }
         if (value instanceof Date)
-            return new CodeModeDate(value.getTime());
+            return new Values.Date(value.getTime());
         if (value instanceof RegExp)
-            return new CodeModeRegExp(value.source, value.flags);
+            return new Values.RegExp(value.source, value.flags);
         if (value instanceof Map) {
-            const wrapped = new CodeModeMap();
+            const wrapped = new Values.Map();
             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();
+            const wrapped = new Values.Set();
             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));
+            return new Values.URL(new URL(value.href));
         if (value instanceof URLSearchParams)
-            return new CodeModeURLSearchParams(new URLSearchParams(value));
+            return new Values.URLSearchParams(new URLSearchParams(value));
     }
-    if (value instanceof CodeModeDate) {
+    if (value instanceof Values.Date) {
         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)
+    if (value instanceof Values.URL)
         return value.url.href;
     if (value instanceof URL)
         return value.href;
-    if (value instanceof CodeModeRegExp ||
-        value instanceof CodeModeMap ||
-        value instanceof CodeModeSet ||
-        value instanceof CodeModeURLSearchParams ||
+    if (value instanceof Values.RegExp ||
+        value instanceof Values.Map ||
+        value instanceof Values.Set ||
+        value instanceof Values.URLSearchParams ||
         value instanceof RegExp ||
         value instanceof Map ||
         value instanceof Set ||

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-dev-19326",
+  "version": "0.0.0-dev-19329",
   "description": "Effect-native confined code execution over schema-described tools",
   "type": "module",
   "license": "MIT",