@opencode/codemode 2.0.0 → 2.0.1

package/dist/data.js

@@ -1,5 +1,5 @@
 export * as Data from "./data.js";
-import { ownEntries, parseArrayIndex, ProgramArray, ProgramFunction, ProgramObject, set, } from "./interpreter/objects.js";
+import { get, ownEntries, parseArrayIndex, ProgramArray, ProgramError, ProgramFunction, ProgramObject, set, } from "./interpreter/objects.js";
 import { Values } from "./values.js";
 const MAX_VALUE_DEPTH = 32;
 export class ToolRuntimeError extends Error {
@@ -102,6 +102,11 @@ const copy = (value, label, mode, depth, seen) => {
     }
     if (value instanceof ProgramObject) {
         const copied = {};
+        // Errors serialize as { name, message, ...own }: both may be inherited, and neither is enumerable in JS.
+        if (value instanceof ProgramError) {
+            define(copied, "name", copy(get(value, "name"), label, mode, depth + 1, seen));
+            define(copied, "message", copy(get(value, "message"), label, mode, depth + 1, seen));
+        }
         for (const [key, item] of ownEntries(value)) {
             const next = copy(item, label, mode, depth + 1, seen);
             if (next === undefined && mode === "json")

package/dist/interpreter/errors.d.ts

@@ -1,7 +1,10 @@
 import type { Diagnostic } from "../codemode.js";
 import { HostFunction } from "./host.js";
+import { type ErrorType } from "./intrinsics.js";
+import { ProgramError } from "./objects.js";
 import { type Runner } from "./runner.js";
 export declare const normalizeError: (error: unknown) => Diagnostic;
-export declare const caughtErrorValue: (thrown: unknown) => unknown;
+export declare const caughtErrorValue: <R>(runner: Runner<R>, thrown: unknown) => unknown;
+export declare const createAggregateErrorValue: <R>(runner: Runner<R>, errors: Array<unknown>, message: string) => ProgramError;
 /** An error constructor such as `Error` or `TypeError`; callable with or without `new`, like JS. */
-export declare const errorGlobal: <R>(name: string, runner: Runner<R>) => HostFunction<R>;
+export declare const errorGlobal: <R>(type: ErrorType, runner: Runner<R>) => HostFunction<R>;

package/dist/interpreter/errors.js

@@ -4,9 +4,10 @@ import { toData, ToolRuntimeError } from "../data.js";
 import { formatLocation, InterpreterRuntimeError, ProgramThrow, sourceLocation } from "./model.js";
 import { containsRuntimeReference } from "./references.js";
 import { HostFunction } from "./host.js";
-import { get, ProgramError, ProgramObject } from "./objects.js";
+import { createErrorValue, isErrorType } from "./intrinsics.js";
+import { get, hasPrototype, ProgramArray, ProgramError, ProgramObject, set } from "./objects.js";
 import {} from "./runner.js";
-import { coerceToString, createAggregateErrorValue, createErrorValue, errorBrandName, errorConstructors, } from "../stdlib/value.js";
+import { coerceToString } from "../stdlib/value.js";
 export const normalizeError = (error) => {
     if (error instanceof InterpreterRuntimeError) {
         return {
@@ -66,41 +67,46 @@ export const normalizeError = (error) => {
         message: String(error),
     };
 };
-export const caughtErrorValue = (thrown) => {
+export const caughtErrorValue = (runner, thrown) => {
     if (thrown instanceof ProgramThrow)
         return thrown.value;
+    const prototypes = runner.intrinsics.errors;
     if (thrown instanceof InterpreterRuntimeError)
-        return createErrorValue(thrown.errorName, thrown.message);
-    const name = thrown instanceof Error && errorConstructors.has(thrown.name) ? thrown.name : "Error";
-    return createErrorValue(name, normalizeError(thrown).message);
+        return createErrorValue(prototypes[thrown.type], thrown.message);
+    const type = thrown instanceof Error && isErrorType(thrown.name) ? thrown.name : "Error";
+    return createErrorValue(prototypes[type], normalizeError(thrown).message);
+};
+export const createAggregateErrorValue = (runner, errors, message) => {
+    const value = createErrorValue(runner.intrinsics.errors.AggregateError, message);
+    set(value, "errors", new ProgramArray(errors));
+    return value;
 };
-const constructErrorValue = (name, args) => createErrorValue(name, args[0] === undefined ? "" : coerceToString(args[0]));
 const constructAggregateErrorValue = (runner, args, node) => Effect.gen(function* () {
     const cursor = yield* runner.syncIterator(args[0], node);
     if (cursor === undefined) {
-        throw new InterpreterRuntimeError("new AggregateError(...) expects a synchronous iterable of errors.", node).as("TypeError");
+        throw new InterpreterRuntimeError("new AggregateError(...) expects a synchronous iterable of errors.", node);
     }
     const errors = [];
     while (true) {
         const step = yield* cursor.next;
         if (step.done) {
-            return createAggregateErrorValue(errors, args[1] === undefined ? "" : coerceToString(args[1]));
+            return createAggregateErrorValue(runner, errors, args[1] === undefined ? "" : coerceToString(args[1]));
         }
         errors.push(step.value);
     }
 });
 /** An error constructor such as `Error` or `TypeError`; callable with or without `new`, like JS. */
-export const errorGlobal = (name, runner) => {
-    const construct = (args, node) => name === "AggregateError"
+export const errorGlobal = (type, runner) => {
+    const prototype = runner.intrinsics.errors[type];
+    const construct = (args, node) => type === "AggregateError"
         ? constructAggregateErrorValue(runner, args, node)
-        : Effect.sync(() => constructErrorValue(name, args));
-    return new HostFunction({
-        name,
+        : Effect.sync(() => createErrorValue(prototype, args[0] === undefined ? undefined : coerceToString(args[0])));
+    const fn = new HostFunction({
+        name: type,
         call: construct,
         construct,
-        instanceOf: (value) => {
-            const brand = errorBrandName(value);
-            return brand !== undefined && (name === "Error" || brand === name);
-        },
+        instanceOf: (value) => hasPrototype(value, prototype),
     });
+    set(prototype, "constructor", fn);
+    return fn;
 };

package/dist/interpreter/globals.js

@@ -10,17 +10,18 @@ import { objectGlobal } from "../stdlib/object.js";
 import { regexpGlobal } from "../stdlib/regexp.js";
 import { stringGlobal } from "../stdlib/string.js";
 import { uriGlobal, urlGlobal, urlSearchParamsGlobal } from "../stdlib/url.js";
-import { coercion, errorConstructors } from "../stdlib/value.js";
+import { coercion } from "../stdlib/value.js";
 import { atobGlobal, btoaGlobal, cryptoGlobal } from "../stdlib/web.js";
 import { ToolReference } from "../tool-runtime.js";
 import { errorGlobal } from "./errors.js";
+import { errorTypes } from "./intrinsics.js";
 import { HostFunction } from "./host.js";
 import { AsyncIteratorSymbol, InterpreterRuntimeError, IteratorSymbol } from "./model.js";
 import { promiseGlobal } from "./promises.js";
 const symbolGlobal = new HostFunction({
     name: "Symbol",
     call: (_, node) => Effect.sync(() => {
-        throw new InterpreterRuntimeError("Symbol is not callable; only Symbol.asyncIterator and Symbol.iterator are available.", node).as("TypeError");
+        throw new InterpreterRuntimeError("Symbol is not callable; only Symbol.asyncIterator and Symbol.iterator are available.", node);
     }),
     callback: false,
     members: { asyncIterator: AsyncIteratorSymbol, iterator: IteratorSymbol },
@@ -59,5 +60,5 @@ export const globals = (host) => [
     ["atob", atobGlobal],
     ["btoa", btoaGlobal],
     ["crypto", cryptoGlobal],
-    ...[...errorConstructors].map((name) => [name, errorGlobal(name, host.runner)]),
+    ...errorTypes.map((type) => [type, errorGlobal(type, host.runner)]),
 ];

package/dist/interpreter/host.js

@@ -40,5 +40,5 @@ export const syncCall = (impl) => (args, node) => Effect.sync(() => impl(args, n
 export const sync = (name, impl, options = {}) => new HostFunction({ name, call: syncCall(impl), ...options });
 /** The `call` of a constructor that JS requires to be invoked with `new`. */
 export const requiresNew = (name) => (_, node) => Effect.sync(() => {
-    throw new InterpreterRuntimeError(`Constructor ${name} requires 'new'.`, node).as("TypeError");
+    throw new InterpreterRuntimeError(`Constructor ${name} requires 'new'.`, node);
 });

package/dist/interpreter/intrinsics.d.ts

@@ -0,0 +1,10 @@
+import { ProgramError, ProgramObject } from "./objects.js";
+export declare const errorTypes: readonly ["Error", "TypeError", "RangeError", "SyntaxError", "ReferenceError", "EvalError", "URIError", "AggregateError"];
+export type ErrorType = (typeof errorTypes)[number];
+export declare const isErrorType: (name: string) => name is ErrorType;
+/** The built-in prototype objects of one runtime. Constructors attach themselves as `constructor` when created. */
+export type Intrinsics = {
+    readonly errors: Readonly<Record<ErrorType, ProgramObject>>;
+};
+export declare const createErrorValue: (prototype: ProgramObject, message: string | undefined) => ProgramError;
+export declare const createIntrinsics: () => Intrinsics;

package/dist/interpreter/intrinsics.js

@@ -0,0 +1,41 @@
+import { ProgramError, ProgramObject, set } from "./objects.js";
+export const errorTypes = [
+    "Error",
+    "TypeError",
+    "RangeError",
+    "SyntaxError",
+    "ReferenceError",
+    "EvalError",
+    "URIError",
+    "AggregateError",
+];
+export const isErrorType = (name) => errorTypes.includes(name);
+export const createErrorValue = (prototype, message) => {
+    const value = new ProgramError(prototype);
+    if (message !== undefined)
+        set(value, "message", message);
+    return value;
+};
+export const createIntrinsics = () => {
+    const error = new ProgramObject();
+    set(error, "name", "Error");
+    set(error, "message", "");
+    const derived = (type) => {
+        const proto = new ProgramObject(error);
+        set(proto, "name", type);
+        set(proto, "message", "");
+        return proto;
+    };
+    return {
+        errors: {
+            Error: error,
+            TypeError: derived("TypeError"),
+            RangeError: derived("RangeError"),
+            SyntaxError: derived("SyntaxError"),
+            ReferenceError: derived("ReferenceError"),
+            EvalError: derived("EvalError"),
+            URIError: derived("URIError"),
+            AggregateError: derived("AggregateError"),
+        },
+    };
+};

package/dist/interpreter/methods.js

@@ -7,7 +7,7 @@ import { invokeURLMethod, uriArgument } from "../stdlib/url.js";
 import { coerceToNumber, coerceToString } from "../stdlib/value.js";
 import { compareText } from "../tool-runtime.js";
 import { Values } from "../values.js";
-import { IntrinsicReference, InterpreterRuntimeError } from "./model.js";
+import { InterpreterRuntimeError, IntrinsicReference, rangeError } from "./model.js";
 import { get, ProgramArray, ProgramObject, record } from "./objects.js";
 import { containsOpaqueReference, rejectCircularInsertion, typeofValue } from "./references.js";
 import { applyCollectionCallback, isSupportedCallback, toPrimitive } from "./runner.js";
@@ -79,7 +79,7 @@ const invokeStringMethod = (value, name, args, node) => {
     const optStr = (index) => (args[index] === undefined ? undefined : str(index));
     const rejectRegex = () => {
         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");
+            throw new InterpreterRuntimeError(`String.${name} cannot take a regular expression; use regex.test(string) or String.search instead.`, node);
         }
     };
     let result;
@@ -111,7 +111,7 @@ const invokeStringMethod = (value, name, args, node) => {
                 result = value.normalize(form);
             }
             catch {
-                throw new InterpreterRuntimeError(`String.normalize expects the form "NFC", "NFD", "NFKC", or "NFKD" (got ${JSON.stringify(form)}).`, node).as("RangeError");
+                throw rangeError(`String.normalize expects the form "NFC", "NFD", "NFKC", or "NFKD" (got ${JSON.stringify(form)}).`, node);
             }
             break;
         }
@@ -194,7 +194,7 @@ const invokeStringMethod = (value, name, args, node) => {
         case "repeat": {
             const count = num(0);
             if (!Number.isFinite(count) || count < 0)
-                throw new InterpreterRuntimeError("String.repeat expects a finite non-negative count.", node).as("RangeError");
+                throw rangeError("String.repeat expects a finite non-negative count.", node);
             result = value.repeat(count);
             break;
         }
@@ -463,17 +463,17 @@ const loadSetRecord = (runner, source, name, node) => {
         });
     }
     if (!(source instanceof ProgramObject)) {
-        throw new InterpreterRuntimeError(`Set.${name} expects a Set-like object.`, node).as("TypeError");
+        throw new InterpreterRuntimeError(`Set.${name} expects a Set-like object.`, node);
     }
     return Effect.gen(function* () {
         const size = yield* coerceNumericArgument(runner, get(source, "size"), node);
         if (Number.isNaN(size)) {
-            throw new InterpreterRuntimeError(`Set.${name} received a Set-like object with an invalid size.`, node).as("TypeError");
+            throw new InterpreterRuntimeError(`Set.${name} received a Set-like object with an invalid size.`, node);
         }
         const has = get(source, "has");
         const keys = get(source, "keys");
         if (!isSupportedCallback(has) || !isSupportedCallback(keys)) {
-            throw new InterpreterRuntimeError(`Set.${name} expects callable 'has' and 'keys' methods.`, node).as("TypeError");
+            throw new InterpreterRuntimeError(`Set.${name} expects callable 'has' and 'keys' methods.`, node);
         }
         return {
             size: Math.max(Math.trunc(size), 0),
@@ -481,7 +481,7 @@ const loadSetRecord = (runner, source, name, node) => {
             keys: () => Effect.flatMap(runner.invokeCallable(keys, [], node), (result) => {
                 if (result instanceof ProgramArray)
                     return Effect.succeed(result.items);
-                throw new InterpreterRuntimeError(`Set.${name} expected 'keys' to return an iterator.`, node).as("TypeError");
+                throw new InterpreterRuntimeError(`Set.${name} expected 'keys' to return an iterator.`, node);
             }),
         };
     });
@@ -490,7 +490,7 @@ const invokeURLSearchParamsMethod = (runner, target, name, args, node) => {
     const arg = (index) => uriArgument(args[index], `URLSearchParams.${name} argument ${index + 1}`);
     const requireArgs = (count) => {
         if (args.length < count) {
-            throw new InterpreterRuntimeError(`URLSearchParams.${name} requires ${count} argument${count === 1 ? "" : "s"}.`, node).as("TypeError");
+            throw new InterpreterRuntimeError(`URLSearchParams.${name} requires ${count} argument${count === 1 ? "" : "s"}.`, node);
         }
     };
     switch (name) {
@@ -614,7 +614,7 @@ const invokeArrayMethod = (runner, receiver, name, args, node) => {
             const index = optNumber(args[0], "index") ?? 0;
             const resolved = index < 0 ? target.length + index : index;
             if (resolved < 0 || resolved >= target.length) {
-                throw new InterpreterRuntimeError("Array.with index is out of range.", node);
+                throw rangeError("Array.with index is out of range.", node);
             }
             const copied = [...target];
             copied[resolved] = args[1];
@@ -759,7 +759,7 @@ const invokeArrayMethod = (runner, receiver, name, args, node) => {
                     while (start < length && !(start in target))
                         start += 1;
                     if (start === length)
-                        throw new InterpreterRuntimeError("Array.reduce of an empty array with no initial value.", node).as("TypeError");
+                        throw new InterpreterRuntimeError("Array.reduce of an empty array with no initial value.", node);
                     accumulator = target[start];
                     start += 1;
                 }
@@ -777,7 +777,7 @@ const invokeArrayMethod = (runner, receiver, name, args, node) => {
                     while (start >= 0 && !(start in target))
                         start -= 1;
                     if (start < 0)
-                        throw new InterpreterRuntimeError("Array.reduceRight of an empty array with no initial value.", node).as("TypeError");
+                        throw new InterpreterRuntimeError("Array.reduceRight of an empty array with no initial value.", node);
                     accumulator = target[start];
                     start -= 1;
                 }

package/dist/interpreter/model.d.ts

@@ -1,4 +1,5 @@
 import type { Node } from "acorn";
+import type { ErrorType } from "./intrinsics.js";
 import type { Effect } from "effect";
 import type { DiagnosticKind } from "../codemode.js";
 import type { ProgramObject } from "./objects.js";
@@ -67,11 +68,17 @@ export declare const OptionalShortCircuit: unique symbol;
 export declare class InterpreterRuntimeError extends Error {
     readonly kind: DiagnosticKind;
     readonly suggestions?: ReadonlyArray<string> | undefined;
+    /** The JS error class a program sees when it catches this failure. */
+    readonly type: ErrorType;
     readonly node?: AstNode;
-    errorName: string;
-    constructor(message: string, node?: AstNode, kind?: DiagnosticKind, suggestions?: ReadonlyArray<string> | undefined);
-    as(errorName: string): this;
+    constructor(message: string, node?: AstNode, kind?: DiagnosticKind, suggestions?: ReadonlyArray<string> | undefined, 
+    /** The JS error class a program sees when it catches this failure. */
+    type?: ErrorType);
 }
+export declare const rangeError: (message: string, node?: AstNode) => InterpreterRuntimeError;
+export declare const referenceError: (message: string, node?: AstNode) => InterpreterRuntimeError;
+export declare const syntaxError: (message: string, node?: AstNode) => InterpreterRuntimeError;
+export declare const uriError: (message: string, node?: AstNode) => InterpreterRuntimeError;
 export declare const supportedSyntaxMessage = "This is a restricted JavaScript-like language. Supported: plain and async functions, data literals, destructuring, standard control flow, await and Promise, and built-ins such as Array, Object, Math, JSON, Date, RegExp, Map, Set, and URL. Unsupported: classes, this, getters/setters, tagged templates, BigInt, and custom Symbols. Use plain functions and data objects instead.";
 export declare const unsupportedSyntax: (kind: string, node: AstNode) => InterpreterRuntimeError;
 export declare const isRecord: (value: unknown) => value is Record<string, unknown>;

package/dist/interpreter/model.js

@@ -55,24 +55,28 @@ export const OptionalShortCircuit = Symbol("codemode.optional-short-circuit");
 export class InterpreterRuntimeError extends Error {
     kind;
     suggestions;
+    type;
     node;
-    errorName = "Error";
-    constructor(message, node, kind = "ExecutionFailure", suggestions) {
+    constructor(message, node, kind = "ExecutionFailure", suggestions, 
+    /** The JS error class a program sees when it catches this failure. */
+    type = "TypeError") {
         super(message);
         this.kind = kind;
         this.suggestions = suggestions;
+        this.type = type;
         this.name = "InterpreterRuntimeError";
         if (node)
             this.node = node;
     }
-    as(errorName) {
-        this.errorName = errorName;
-        return this;
-    }
 }
+const failure = (type) => (message, node) => new InterpreterRuntimeError(message, node, "ExecutionFailure", undefined, type);
+export const rangeError = failure("RangeError");
+export const referenceError = failure("ReferenceError");
+export const syntaxError = failure("SyntaxError");
+export const uriError = failure("URIError");
 // Orient the agent rather than enumerate JavaScript; interpreter-support.md is the full matrix.
 export const supportedSyntaxMessage = "This is a restricted JavaScript-like language. Supported: plain and async functions, data literals, destructuring, standard control flow, await and Promise, and built-ins such as Array, Object, Math, JSON, Date, RegExp, Map, Set, and URL. Unsupported: classes, this, getters/setters, tagged templates, BigInt, and custom Symbols. Use plain functions and data objects instead.";
-export const unsupportedSyntax = (kind, node) => new InterpreterRuntimeError(`Syntax '${kind}' is not supported. ${supportedSyntaxMessage}`, node, "UnsupportedSyntax", [supportedSyntaxMessage]);
+export const unsupportedSyntax = (kind, node) => new InterpreterRuntimeError(`Syntax '${kind}' is not supported. ${supportedSyntaxMessage}`, node, "UnsupportedSyntax", [supportedSyntaxMessage], "SyntaxError");
 export const isRecord = (value) => typeof value === "object" && value !== null;
 export const sourceLocation = (node) => ({
     line: Math.max(1, (node.loc?.start.line ?? 2) - 1),

package/dist/interpreter/objects.d.ts

@@ -10,9 +10,8 @@ export declare class ProgramArray extends ProgramObject {
     readonly items: Array<unknown>;
     constructor(items?: Array<unknown>);
 }
+/** An object with the [[ErrorData]] slot: what `Error.prototype.toString` and the host boundary recognize as an error. */
 export declare class ProgramError extends ProgramObject {
-    readonly errorName: string;
-    constructor(errorName: string);
 }
 export declare class ProgramFunction extends ProgramObject {
     readonly name: string;
@@ -28,6 +27,7 @@ export declare const parseArrayIndex: (key: string | number) => number | undefin
 export declare const hasOwn: (target: ProgramObject, key: PropertyKey) => boolean;
 export declare const getOwn: (target: ProgramObject, key: PropertyKey) => unknown;
 export declare const get: (target: ProgramObject, key: PropertyKey) => unknown;
+export declare const hasPrototype: (value: unknown, proto: ProgramObject) => boolean;
 export declare const has: (target: ProgramObject, key: PropertyKey) => boolean;
 export declare const set: (target: ProgramObject, key: PropertyKey, value: unknown) => boolean;
 export declare const remove: (target: ProgramObject, key: PropertyKey) => boolean;

package/dist/interpreter/objects.js

@@ -14,12 +14,8 @@ export class ProgramArray extends ProgramObject {
         this.items = items;
     }
 }
+/** An object with the [[ErrorData]] slot: what `Error.prototype.toString` and the host boundary recognize as an error. */
 export class ProgramError extends ProgramObject {
-    errorName;
-    constructor(errorName) {
-        super();
-        this.errorName = errorName;
-    }
 }
 export class ProgramFunction extends ProgramObject {
     name;
@@ -81,6 +77,13 @@ export const get = (target, key) => {
     }
     return undefined;
 };
+export const hasPrototype = (value, proto) => {
+    for (let current = value instanceof ProgramObject ? value.proto : null; current !== null; current = current.proto) {
+        if (current === proto)
+            return true;
+    }
+    return false;
+};
 export const has = (target, key) => {
     for (let current = target; current !== null; current = current.proto) {
         if (hasOwn(current, key))

package/dist/interpreter/promises.js

@@ -2,9 +2,8 @@ import { Cause, Deferred, Effect, Exit, Fiber, Scope } from "effect";
 import { InterpreterRuntimeError, ProgramThrow, PromiseInstanceMethodReference } from "./model.js";
 import { get, ProgramArray, ProgramFunction, ProgramObject, record } from "./objects.js";
 import { HostFunction, requiresNew, sync } from "./host.js";
-import { caughtErrorValue, normalizeError } from "./errors.js";
+import { caughtErrorValue, createAggregateErrorValue, normalizeError } from "./errors.js";
 import { typeofValue } from "./references.js";
-import { createAggregateErrorValue } from "../stdlib/value.js";
 import { Values } from "../values.js";
 import { applyCollectionCallback, isSupportedCallback } from "./runner.js";
 // A `resolve`/`reject` handed to an executor or thenable: calling it settles the capability.
@@ -83,7 +82,7 @@ export class PromiseRuntime {
         });
     }
 }
-export const selfResolutionError = (node) => new InterpreterRuntimeError("Chaining cycle detected: a promise cannot resolve with itself.", node).as("TypeError");
+export const selfResolutionError = (node) => new InterpreterRuntimeError("Chaining cycle detected: a promise cannot resolve with itself.", node);
 export const resolvePromiseValue = (runner, value, node, own) => {
     if (own?.promise !== undefined && value === own.promise)
         return Effect.fail(selfResolutionError(node));
@@ -125,7 +124,7 @@ const invokePromiseMethod = (runner, promises, name, args, node) => {
     return promises.create(Effect.gen(function* () {
         const cursor = yield* runner.syncIterator(args[0], node);
         if (cursor === undefined) {
-            throw new InterpreterRuntimeError(`Promise.${name} expects an array or other synchronous iterable.`, node).as("TypeError");
+            throw new InterpreterRuntimeError(`Promise.${name} expects an array or other synchronous iterable.`, node);
         }
         const items = [];
         while (true) {
@@ -149,7 +148,7 @@ const invokePromiseMethod = (runner, promises, name, args, node) => {
                 }
                 if (Cause.hasInterruptsOnly(exit.cause))
                     return yield* Effect.failCause(exit.cause);
-                outcomes.push(record({ status: "rejected", reason: caughtErrorValue(Cause.squash(exit.cause)) }));
+                outcomes.push(record({ status: "rejected", reason: caughtErrorValue(runner, Cause.squash(exit.cause)) }));
             }
             yield* Effect.yieldNow;
             return new ProgramArray(outcomes);
@@ -165,9 +164,9 @@ const invokePromiseMethod = (runner, promises, name, args, node) => {
                 return Effect.fail(new PromiseAnyFulfilled(exit.value));
             if (Cause.hasInterruptsOnly(exit.cause))
                 return Effect.failCause(exit.cause);
-            return Effect.succeed(caughtErrorValue(Cause.squash(exit.cause)));
+            return Effect.succeed(caughtErrorValue(runner, Cause.squash(exit.cause)));
         }));
-        return yield* settleAfterTurn(Effect.all(flipped, { concurrency: "unbounded" }).pipe(Effect.flatMap((reasons) => Effect.fail(new ProgramThrow(createAggregateErrorValue(reasons, "All promises were rejected")))), Effect.catch((error) => error instanceof PromiseAnyFulfilled ? Effect.succeed(error.value) : Effect.fail(error))));
+        return yield* settleAfterTurn(Effect.all(flipped, { concurrency: "unbounded" }).pipe(Effect.flatMap((reasons) => Effect.fail(new ProgramThrow(createAggregateErrorValue(runner, reasons, "All promises were rejected")))), Effect.catch((error) => error instanceof PromiseAnyFulfilled ? Effect.succeed(error.value) : Effect.fail(error))));
     }));
 };
 export const invokePromiseInstanceMethod = (runner, promises, ref, args, node) => {
@@ -182,7 +181,7 @@ export const invokePromiseInstanceMethod = (runner, promises, ref, args, node) =
 };
 const constructPromise = (runner, promises, executor, node) => {
     if (!(executor instanceof ProgramFunction)) {
-        throw new InterpreterRuntimeError("new Promise(...) expects an executor function (e.g. new Promise((resolve, reject) => { ... })).", node).as("TypeError");
+        throw new InterpreterRuntimeError("new Promise(...) expects an executor function (e.g. new Promise((resolve, reject) => { ... })).", node);
     }
     return Effect.gen(function* () {
         const deferred = Deferred.makeUnsafe();
@@ -228,7 +227,7 @@ const chainReaction = (runner, promises, source, onFulfilled, onRejected, method
         const handler = Exit.isSuccess(exit) ? onFulfilled : onRejected;
         if (handler === undefined)
             return yield* exit;
-        const input = Exit.isSuccess(exit) ? exit.value : caughtErrorValue(Cause.squash(exit.cause));
+        const input = Exit.isSuccess(exit) ? exit.value : caughtErrorValue(runner, Cause.squash(exit.cause));
         const result = yield* applyCollectionCallback(runner, handler, method, node)([input]);
         return yield* resolvePromiseValue(runner, result, node, self);
     }));

package/dist/interpreter/runner.d.ts

@@ -2,6 +2,7 @@ import { Effect } from "effect";
 import { Values } from "../values.js";
 import { HostFunction } from "./host.js";
 import { type AstNode, IntrinsicReference } from "./model.js";
+import type { Intrinsics } from "./intrinsics.js";
 import { ProgramFunction } from "./objects.js";
 export type IteratorCursor<R> = {
     readonly next: Effect.Effect<{
@@ -10,12 +11,13 @@ export type IteratorCursor<R> = {
     }, unknown, R>;
     readonly close: Effect.Effect<void, unknown, R>;
 };
-/** Everything a host function needs to call back into the program. */
+/** Everything a host function needs from the realm: calling back into the program and its intrinsic objects. */
 export type Runner<R> = {
     readonly invokeFunction: (fn: ProgramFunction, 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: Values.Promise) => Effect.Effect<unknown, unknown, never>;
     readonly syncIterator: (value: unknown, node: AstNode) => Effect.Effect<IteratorCursor<R> | undefined, unknown, R>;
+    readonly intrinsics: Intrinsics;
 };
 export declare const preserveConsumerError: <A, R>(cursor: IteratorCursor<R>, effect: Effect.Effect<A, unknown, R>) => Effect.Effect<A, unknown, R>;
 export declare const toPrimitive: <R>(runner: Runner<R>, value: unknown, hint: "number" | "string", node: AstNode) => Effect.Effect<unknown, unknown, R>;

package/dist/interpreter/runner.js

@@ -28,7 +28,7 @@ export const toPrimitive = (runner, value, hint, node) => {
             if (result === null || (typeof result !== "object" && typeof result !== "function"))
                 return result;
         }
-        throw new InterpreterRuntimeError("Cannot convert object to primitive value.", node).as("TypeError");
+        throw new InterpreterRuntimeError("Cannot convert object to primitive value.", node);
     });
 };
 export const isSupportedCallback = (value) => value instanceof ProgramFunction ||
@@ -39,7 +39,7 @@ export const applyCollectionCallback = (runner, callback, name, node) => {
         if (typeofValue(callback) === "function") {
             throw new InterpreterRuntimeError(`${name} cannot use this callable as a callback; wrap it in an arrow function, e.g. (value) => tools.ns.tool(value).`, node);
         }
-        throw new InterpreterRuntimeError(`${name} expects a function callback.`, node).as("TypeError");
+        throw new InterpreterRuntimeError(`${name} expects a function callback.`, node);
     }
     return (callbackArgs) => runner.invokeCallable(callback, callbackArgs, node);
 };

package/dist/interpreter/runtime.js

@@ -1,8 +1,9 @@
 import { Cause, Deferred, Effect, Exit } from "effect";
 import { ToolRuntimeError, toProgram } from "../data.js";
 import { ToolReference } from "../tool-runtime.js";
-import { AsyncIteratorSymbol, CodeModeGenerator, ComputedValue, GeneratorMethodReference, GeneratorReturn, IntrinsicReference, InterpreterRuntimeError, IteratorSymbol, OptionalShortCircuit, PromiseInstanceMethodReference, ProgramThrow, unsupportedSyntax, } from "./model.js";
+import { AsyncIteratorSymbol, CodeModeGenerator, ComputedValue, GeneratorMethodReference, GeneratorReturn, InterpreterRuntimeError, IntrinsicReference, IteratorSymbol, OptionalShortCircuit, ProgramThrow, PromiseInstanceMethodReference, rangeError, unsupportedSyntax, } from "./model.js";
 import { caughtErrorValue } from "./errors.js";
+import { createIntrinsics } from "./intrinsics.js";
 import { globals } from "./globals.js";
 import { HostFunction, HostNamespace } from "./host.js";
 import { invokeIntrinsic } from "./methods.js";
@@ -18,7 +19,7 @@ import { constructRegExp, regexpMethods, regexpProperties } from "../stdlib/rege
 import { stringMethods } from "../stdlib/string.js";
 import { uriArgument, urlMethods, urlProperties, urlSearchParamsMethods, urlWritableProperties } from "../stdlib/url.js";
 import { enumerableSource } from "../stdlib/object.js";
-import { coerceToNumber, coerceToString, compoundOperators, errorBrandName } from "../stdlib/value.js";
+import { coerceToNumber, coerceToString, compoundOperators } from "../stdlib/value.js";
 import { Values } from "../values.js";
 // What a loop does with its body's result: exit with a StatementResult, or undefined to keep iterating.
 // Unlabelled break ends this loop; a label the loop does not carry propagates outward.
@@ -75,7 +76,7 @@ const constructorName = (value) => {
         return "Promise";
     if (!(value instanceof ProgramObject) || value instanceof ProgramFunction)
         return undefined;
-    return errorBrandName(value) ?? "Object";
+    return "Object";
 };
 const instanceofValue = (lhs, rhs, node) => {
     if (rhs instanceof HostFunction && rhs.instanceOf !== undefined)
@@ -200,6 +201,7 @@ export class Runtime {
             invokeCallable: (callable, args, node) => this.root.invokeCallable(callable, args, node),
             settlePromise: (promise) => this.root.settlePromise(promise),
             syncIterator: (value, node) => this.root.syncIterator(value, node),
+            intrinsics: createIntrinsics(),
         };
         this.builtins = new Map([...globals(this), ...extraGlobals(this)]);
         for (const [name, value] of this.builtins)
@@ -505,7 +507,7 @@ class Frame {
             const iterator = yield* self.customIterator(right, node, awaiting);
             const cursor = iterator === undefined ? yield* self.syncIterator(right, node) : undefined;
             if (iterator === undefined && cursor === undefined) {
-                throw new InterpreterRuntimeError(`${awaiting ? "for await...of" : "for...of"} requires an array, string, Map, Set, or URLSearchParams, or custom iterator value.`, node).as("TypeError");
+                throw new InterpreterRuntimeError(`${awaiting ? "for await...of" : "for...of"} requires an array, string, Map, Set, or URLSearchParams, or custom iterator value.`, node);
             }
             const close = () => iterator
                 ? self.closeIterator(iterator, node, awaiting)
@@ -696,7 +698,7 @@ class Frame {
     requireIteratorObject(value, context, node) {
         if (value instanceof ProgramObject)
             return value;
-        throw new InterpreterRuntimeError(`${context} must be an object.`, node).as("TypeError");
+        throw new InterpreterRuntimeError(`${context} must be an object.`, node);
     }
     requireIterator(value, node) {
         return value instanceof CodeModeGenerator
@@ -706,7 +708,7 @@ class Frame {
     requireIteratorMethod(value, context, node) {
         if (typeofValue(value) === "function")
             return value;
-        throw new InterpreterRuntimeError(`${context} must be a function.`, node).as("TypeError");
+        throw new InterpreterRuntimeError(`${context} must be a function.`, node);
     }
     // for...in over null/undefined iterates nothing, like JS.
     enumerableKeys(value, node) {
@@ -802,7 +804,7 @@ class Frame {
                 if (cause.reasons.some(Cause.isInterruptReason) || Cause.squash(cause) instanceof GeneratorReturn || !handler) {
                     return Effect.failCause(cause);
                 }
-                const caught = caughtErrorValue(Cause.squash(cause));
+                const caught = caughtErrorValue(self.runtime.runner, Cause.squash(cause));
                 const parameter = handler.param;
                 self.scopes.push();
                 return Effect.gen(function* () {
@@ -935,7 +937,7 @@ class Frame {
         return Effect.gen(function* () {
             const cursor = yield* self.syncIterator(value, pattern);
             if (cursor === undefined) {
-                throw new InterpreterRuntimeError("Array destructuring requires a supported iterable value.", pattern).as("TypeError");
+                throw new InterpreterRuntimeError("Array destructuring requires a supported iterable value.", pattern);
             }
             let done = false;
             for (const element of pattern.elements) {
@@ -1069,7 +1071,7 @@ class Frame {
                     : callee instanceof HostFunction
                         ? `new ${name}(...) is not supported; call ${name}(...) without new instead.`
                         : `${name} is not a constructor.`;
-                throw new InterpreterRuntimeError(message, node).as("TypeError");
+                throw new InterpreterRuntimeError(message, node);
             }
             const args = yield* self.evaluateCallArguments(node.arguments);
             return yield* construct(args, node);
@@ -1346,7 +1348,7 @@ class Frame {
             if (callable instanceof HostFunction)
                 return yield* callable.call(args, node);
             if (callable === undefined || callable === null) {
-                throw new InterpreterRuntimeError(`${calleeDescription(callee)} is not a function.`, callee ?? node).as("TypeError");
+                throw new InterpreterRuntimeError(`${calleeDescription(callee)} is not a function.`, callee ?? node);
             }
             throw new InterpreterRuntimeError("Only tools are callable here.", callee ?? node);
         });
@@ -1360,7 +1362,7 @@ class Frame {
                     const spread = yield* self.evaluateExpression(argNode.argument);
                     const cursor = yield* self.syncIterator(spread, argNode);
                     if (cursor === undefined)
-                        throw new InterpreterRuntimeError("Spread arguments require a synchronous iterable.", argNode).as("TypeError");
+                        throw new InterpreterRuntimeError("Spread arguments require a synchronous iterable.", argNode);
                     while (true) {
                         const step = yield* cursor.next;
                         if (step.done)
@@ -1413,7 +1415,7 @@ class Frame {
         const generator = new CodeModeGenerator(asynchronous, (kind, value, node) => {
             const request = { kind, value, response: Deferred.makeUnsafe() };
             if (!asynchronous && state.active) {
-                return Effect.fail(new InterpreterRuntimeError("Generator is already running.", node).as("TypeError"));
+                return Effect.fail(new InterpreterRuntimeError("Generator is already running.", node));
             }
             if (asynchronous && (state.completed || (!state.started && kind !== "next"))) {
                 state.started = true;
@@ -1561,14 +1563,14 @@ class Frame {
                     }
                     if (error instanceof ProgramThrow) {
                         yield* cursor.close;
-                        throw new InterpreterRuntimeError("The delegated iterator does not provide a throw() method.", node).as("TypeError");
+                        throw new InterpreterRuntimeError("The delegated iterator does not provide a throw() method.", node);
                     }
                     return yield* Effect.failCause(resumed.cause);
                 }
             }
             const iterator = yield* self.customIterator(value, node, self.generatorAsync);
             if (!iterator)
-                throw new InterpreterRuntimeError("yield* requires a compatible iterable value.", node).as("TypeError");
+                throw new InterpreterRuntimeError("yield* requires a compatible iterable value.", node);
             let kind = "next";
             let input = undefined;
             while (true) {
@@ -1581,7 +1583,7 @@ class Frame {
                     if (kind === "return")
                         return yield* Effect.fail(new GeneratorReturn(input));
                     yield* self.closeIterator(iterator, node, self.generatorAsync);
-                    throw new InterpreterRuntimeError("The delegated iterator does not provide a throw() method.", node).as("TypeError");
+                    throw new InterpreterRuntimeError("The delegated iterator does not provide a throw() method.", node);
                 }
                 const called = yield* self.invokeCallable(self.requireIteratorMethod(method, `Iterator ${kind}`, node), [input], node);
                 const result = self.requireIteratorObject(iterator.asynchronous ? yield* self.awaitValue(called) : called, `Iterator ${kind}() result`, node);
@@ -1662,7 +1664,7 @@ class Frame {
                     const spread = yield* self.evaluateExpression(element.argument);
                     const cursor = yield* self.syncIterator(spread, element);
                     if (cursor === undefined)
-                        throw new InterpreterRuntimeError("Array spread requires a synchronous iterable.", element).as("TypeError");
+                        throw new InterpreterRuntimeError("Array spread requires a synchronous iterable.", element);
                     while (true) {
                         const step = yield* cursor.next;
                         if (step.done)
@@ -1904,7 +1906,7 @@ class Frame {
         if (reference.target instanceof Values.URL) {
             const property = key;
             if (!urlWritableProperties.has(property)) {
-                throw new InterpreterRuntimeError(`URL.${property} is read-only.`, node).as("TypeError");
+                throw new InterpreterRuntimeError(`URL.${property} is read-only.`, node);
             }
             try {
                 const url = reference.target.url;
@@ -1914,7 +1916,7 @@ class Frame {
             catch (error) {
                 if (error instanceof InterpreterRuntimeError || error instanceof ToolRuntimeError)
                     throw error;
-                throw new InterpreterRuntimeError(`URL.${property} received an invalid value.`, node).as("TypeError");
+                throw new InterpreterRuntimeError(`URL.${property} received an invalid value.`, node);
             }
         }
         if (reference.target instanceof Values.RegExp) {
@@ -1926,8 +1928,8 @@ class Frame {
         if (set(target, key, next))
             return;
         if (target instanceof ProgramArray)
-            throw new InterpreterRuntimeError("Invalid array length", node).as("RangeError");
-        throw new InterpreterRuntimeError(`Cannot assign to read only property '${String(key)}'.`, node).as("TypeError");
+            throw rangeError("Invalid array length", node);
+        throw new InterpreterRuntimeError(`Cannot assign to read only property '${String(key)}'.`, node);
     }
     toPropertyKey(value, node) {
         if (typeof value === "string" || typeof value === "number") {

package/dist/interpreter/scope.js

@@ -1,4 +1,4 @@
-import { InterpreterRuntimeError } from "./model.js";
+import { InterpreterRuntimeError, referenceError } from "./model.js";
 export class ScopeStack {
     scopes;
     constructor(scopes) {
@@ -29,23 +29,23 @@ export class ScopeStack {
     get(name, node) {
         const binding = this.resolve(name);
         if (!binding) {
-            throw new InterpreterRuntimeError(`Unknown identifier '${name}'.`, node).as("ReferenceError");
+            throw referenceError(`Unknown identifier '${name}'.`, node);
         }
         if (binding.initialized === false) {
-            throw new InterpreterRuntimeError(`Cannot access '${name}' before initialization.`, node).as("ReferenceError");
+            throw referenceError(`Cannot access '${name}' before initialization.`, node);
         }
         return binding.value;
     }
     set(name, value, node) {
         const binding = this.resolve(name);
         if (!binding) {
-            throw new InterpreterRuntimeError(`Unknown identifier '${name}'.`, node).as("ReferenceError");
+            throw referenceError(`Unknown identifier '${name}'.`, node);
         }
         if (binding.initialized === false) {
-            throw new InterpreterRuntimeError(`Cannot access '${name}' before initialization.`, node).as("ReferenceError");
+            throw referenceError(`Cannot access '${name}' before initialization.`, node);
         }
         if (!binding.mutable) {
-            throw new InterpreterRuntimeError(`Cannot assign to constant '${name}'.`, node).as("TypeError");
+            throw new InterpreterRuntimeError(`Cannot assign to constant '${name}'.`, node);
         }
         binding.value = value;
         return value;

package/dist/stdlib/array.js

@@ -1,6 +1,6 @@
 import { Effect } from "effect";
 import { HostFunction, sync, syncCall } from "../interpreter/host.js";
-import { CodeModeGenerator, InterpreterRuntimeError } from "../interpreter/model.js";
+import { CodeModeGenerator, InterpreterRuntimeError, rangeError } from "../interpreter/model.js";
 import { get, ProgramArray, ProgramObject } from "../interpreter/objects.js";
 import { describeValue } from "../interpreter/references.js";
 import { applyCollectionCallback, preserveConsumerError } from "../interpreter/runner.js";
@@ -11,7 +11,7 @@ const constructArray = (args, node) => {
     if (typeof first !== "number")
         return new ProgramArray([first]);
     if (!Number.isInteger(first) || first < 0 || first > 4294967295) {
-        throw new InterpreterRuntimeError("Invalid array length.", node).as("RangeError");
+        throw rangeError("Invalid array length.", node);
     }
     // Sparse like JS: Array(3) has holes, and combinator loops already skip them.
     return new ProgramArray(new Array(first));
@@ -33,7 +33,7 @@ const arrayFrom = (runner, args, node) => {
         const cursor = yield* runner.syncIterator(source, node);
         if (cursor === undefined) {
             if (source instanceof CodeModeGenerator) {
-                throw new InterpreterRuntimeError("Array.from expects a synchronous iterable or array-like value.", node).as("TypeError");
+                throw new InterpreterRuntimeError("Array.from expects a synchronous iterable or array-like value.", node);
             }
             const arrayLike = arrayLikeSource(source, node);
             const values = [];

package/dist/stdlib/collections.js

@@ -76,13 +76,13 @@ export const groupBy = (runner, namespace) => new HostFunction({
     call: (args, node) => {
         const source = args[0];
         if (source === null || source === undefined) {
-            throw new InterpreterRuntimeError(`${namespace}.groupBy expects an iterable collection.`, node).as("TypeError");
+            throw new InterpreterRuntimeError(`${namespace}.groupBy expects an iterable collection.`, node);
         }
         const apply = applyCollectionCallback(runner, args[1], `${namespace}.groupBy`, node);
         return Effect.gen(function* () {
             const cursor = yield* runner.syncIterator(source, node);
             if (cursor === undefined) {
-                throw new InterpreterRuntimeError(`${namespace}.groupBy expects an iterable collection.`, node).as("TypeError");
+                throw new InterpreterRuntimeError(`${namespace}.groupBy expects an iterable collection.`, node);
             }
             if (namespace === "Map") {
                 const result = new Values.Map();
@@ -126,7 +126,7 @@ const constructMap = (runner, init, node) => {
     return Effect.gen(function* () {
         const cursor = yield* runner.syncIterator(init, node);
         if (cursor === undefined) {
-            throw new InterpreterRuntimeError("new Map(...) expects an iterable of [key, value] pairs or no argument.", node).as("TypeError");
+            throw new InterpreterRuntimeError("new Map(...) expects an iterable of [key, value] pairs or no argument.", node);
         }
         while (true) {
             const step = yield* cursor.next;
@@ -134,7 +134,7 @@ const constructMap = (runner, init, node) => {
                 return target;
             yield* preserveConsumerError(cursor, Effect.sync(() => {
                 if (!(step.value instanceof ProgramObject)) {
-                    throw new InterpreterRuntimeError("new Map(...) expects [key, value] pairs as entry objects.", node).as("TypeError");
+                    throw new InterpreterRuntimeError("new Map(...) expects [key, value] pairs as entry objects.", node);
                 }
                 target.map.set(getOwn(step.value, 0), getOwn(step.value, 1));
             }));
@@ -148,7 +148,7 @@ const constructSet = (runner, init, node) => {
     return Effect.gen(function* () {
         const cursor = yield* runner.syncIterator(init, node);
         if (cursor === undefined) {
-            throw new InterpreterRuntimeError("new Set(...) expects a synchronous iterable or no argument.", node).as("TypeError");
+            throw new InterpreterRuntimeError("new Set(...) expects a synchronous iterable or no argument.", node);
         }
         while (true) {
             const step = yield* cursor.next;

package/dist/stdlib/date.js

@@ -1,6 +1,6 @@
 import { Effect } from "effect";
 import { HostFunction, sync } from "../interpreter/host.js";
-import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { InterpreterRuntimeError, rangeError } from "../interpreter/model.js";
 import { toPrimitive } from "../interpreter/runner.js";
 import { Values } from "../values.js";
 import { coerceToNumber, coerceToString } from "./value.js";
@@ -85,7 +85,7 @@ export const invokeDateMethod = (value, name, args, node, initialTime = value.ti
             return value.time;
         case "toISOString":
             if (!Number.isFinite(value.time))
-                throw new InterpreterRuntimeError("Invalid time value.", node).as("RangeError");
+                throw rangeError("Invalid time value.", node);
             return hosted.toISOString();
         case "toJSON":
             return Number.isFinite(value.time) ? hosted.toISOString() : null;

package/dist/stdlib/json.js

@@ -1,7 +1,7 @@
 import { Effect } from "effect";
 import { HostFunction, HostNamespace } from "../interpreter/host.js";
 import { applyCollectionCallback } from "../interpreter/runner.js";
-import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { InterpreterRuntimeError, syntaxError } from "../interpreter/model.js";
 import { typeofValue } from "../interpreter/references.js";
 import { fromData, toData, toProgram } from "../data.js";
 import { get, ownKeys, ProgramArray, ProgramObject, record, remove, set } from "../interpreter/objects.js";
@@ -19,7 +19,7 @@ const parse = (runner, args, node) => {
             return fromData(JSON.parse(text), "JSON.parse result");
         }
         catch (error) {
-            throw new InterpreterRuntimeError(`JSON.parse received invalid JSON: ${error instanceof Error ? error.message : String(error)}`, node).as("SyntaxError");
+            throw syntaxError(`JSON.parse received invalid JSON: ${error instanceof Error ? error.message : String(error)}`, node);
         }
     })();
     if (typeofValue(args[1]) !== "function")
@@ -68,7 +68,7 @@ const stringify = (runner, args, node) => {
         if (!(value instanceof ProgramObject))
             return {};
         if (stack.has(value))
-            throw new InterpreterRuntimeError("Converting circular structure to JSON.", node).as("TypeError");
+            throw new InterpreterRuntimeError("Converting circular structure to JSON.", node);
         stack.add(value);
         if (value instanceof ProgramArray) {
             const result = [];

package/dist/stdlib/math.js

@@ -24,7 +24,7 @@ const sumPrecise = (runner) => new HostFunction({
     call: (args, node) => Effect.gen(function* () {
         const cursor = yield* runner.syncIterator(args[0], node);
         if (cursor === undefined) {
-            throw new InterpreterRuntimeError("Math.sumPrecise expects a synchronous iterable.", node).as("TypeError");
+            throw new InterpreterRuntimeError("Math.sumPrecise expects a synchronous iterable.", node);
         }
         const numbers = [];
         while (true) {
@@ -33,7 +33,7 @@ const sumPrecise = (runner) => new HostFunction({
                 return Math.sumPrecise(numbers);
             yield* preserveConsumerError(cursor, Effect.sync(() => {
                 if (typeof step.value !== "number") {
-                    throw new InterpreterRuntimeError("Math.sumPrecise expects an iterable of numbers.", node).as("TypeError");
+                    throw new InterpreterRuntimeError("Math.sumPrecise expects an iterable of numbers.", node);
                 }
                 numbers.push(step.value);
             }));

package/dist/stdlib/number.js

@@ -1,6 +1,6 @@
 import { toProgram } from "../data.js";
 import { sync } from "../interpreter/host.js";
-import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { InterpreterRuntimeError, rangeError } from "../interpreter/model.js";
 import { coercion, coerceToString } from "./value.js";
 export const numberMethods = new Set(["toFixed", "toPrecision", "toExponential", "toString", "valueOf"]);
 export const invokeNumberMethod = (value, name, args, node) => {
@@ -28,7 +28,7 @@ export const invokeNumberMethod = (value, name, args, node) => {
         case "toString": {
             const radix = optNum(0);
             if (radix !== undefined && (radix < 2 || radix > 36)) {
-                throw new InterpreterRuntimeError("Number.toString radix must be between 2 and 36.", node);
+                throw rangeError("Number.toString radix must be between 2 and 36.", node);
             }
             result = value.toString(radix);
             break;

package/dist/stdlib/object.js

@@ -1,7 +1,7 @@
 import { Effect } from "effect";
 import { toProgram } from "../data.js";
 import { HostFunction, sync, syncCall } from "../interpreter/host.js";
-import { AsyncIteratorSymbol, InterpreterRuntimeError, IteratorSymbol } from "../interpreter/model.js";
+import { AsyncIteratorSymbol, InterpreterRuntimeError, IteratorSymbol, rangeError, } from "../interpreter/model.js";
 import { getOwn, hasOwn, ownEntries, ownKeys, ProgramArray, ProgramObject, set } from "../interpreter/objects.js";
 import { containsOpaqueReference, describeValue, rejectCircularInsertion, typeofValue, } from "../interpreter/references.js";
 import { preserveConsumerError } from "../interpreter/runner.js";
@@ -12,7 +12,7 @@ import { coerceToString } from "./value.js";
 // ToObject for enumeration.
 export const enumerableSource = (label, value, node) => {
     if (value === null || value === undefined) {
-        throw new InterpreterRuntimeError(`${label} cannot convert ${describeValue(value)} to an object.`, node).as("TypeError");
+        throw new InterpreterRuntimeError(`${label} cannot convert ${describeValue(value)} to an object.`, node);
     }
     if (value instanceof Values.Promise) {
         throw new InterpreterRuntimeError(`${label} received an un-awaited Promise; await it before inspecting the result.`, node, "InvalidDataValue");
@@ -30,7 +30,7 @@ export const objectAssign = (args, node) => {
     const target = args[0];
     // JS would box a primitive target; wrappers and primitives cannot hold fields here.
     if (!(target instanceof ProgramObject)) {
-        throw new InterpreterRuntimeError(`Object.assign expects a data object or array target, received ${describeValue(target)}.`, node).as("TypeError");
+        throw new InterpreterRuntimeError(`Object.assign expects a data object or array target, received ${describeValue(target)}.`, node);
     }
     const seen = new Set();
     for (const source of args.slice(1)) {
@@ -42,7 +42,7 @@ export const objectAssign = (args, node) => {
                 continue;
             rejectCircularInsertion(target, getOwn(from, key), "Object.assign result", node, seen);
             if (!set(target, key, getOwn(from, key))) {
-                throw new InterpreterRuntimeError("Invalid array length", node).as("RangeError");
+                throw rangeError("Invalid array length", node);
             }
         }
     }
@@ -53,7 +53,7 @@ const objectFromEntries = (runner, source, node) => {
     return Effect.gen(function* () {
         const cursor = yield* runner.syncIterator(source, node);
         if (cursor === undefined) {
-            throw new InterpreterRuntimeError("Object.fromEntries expects a synchronous iterable of entries.", node).as("TypeError");
+            throw new InterpreterRuntimeError("Object.fromEntries expects a synchronous iterable of entries.", node);
         }
         while (true) {
             const step = yield* cursor.next;
@@ -61,7 +61,7 @@ const objectFromEntries = (runner, source, node) => {
                 return out;
             yield* preserveConsumerError(cursor, Effect.sync(() => {
                 if (!(step.value instanceof ProgramObject) || containsOpaqueReference(step.value)) {
-                    throw new InterpreterRuntimeError("Object.fromEntries expects [key, value] entry objects.", node).as("TypeError");
+                    throw new InterpreterRuntimeError("Object.fromEntries expects [key, value] entry objects.", node);
                 }
                 set(out, coerceToString(getOwn(step.value, 0)), getOwn(step.value, 1));
             }));

package/dist/stdlib/regexp.js

@@ -1,5 +1,5 @@
 import { sync, syncCall } from "../interpreter/host.js";
-import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { InterpreterRuntimeError, syntaxError } from "../interpreter/model.js";
 import { ProgramArray, record, set } from "../interpreter/objects.js";
 import { Values } from "../values.js";
 import { coerceToNumber, coerceToString } from "./value.js";
@@ -30,7 +30,7 @@ export const toHostRegex = (arg, method, node, extraFlags = "") => {
             return new RegExp(arg, extraFlags);
         }
         catch (error) {
-            throw new InterpreterRuntimeError(`String.${method} received the string ${JSON.stringify(arg)}, which is not a valid regular expression pattern (${regexFailureReason(error)}). ${escapeRegexHint}`, node).as("SyntaxError");
+            throw syntaxError(`String.${method} received the string ${JSON.stringify(arg)}, which is not a valid regular expression pattern (${regexFailureReason(error)}). ${escapeRegexHint}`, node);
         }
     }
     throw new InterpreterRuntimeError(`String.${method} expects a regular expression (a /pattern/flags literal or new RegExp(...)) or a string pattern, not ${arg === null ? "null" : typeof arg}.`, node);
@@ -52,7 +52,7 @@ export const constructRegExp = (args, node) => {
     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");
+        throw syntaxError(`RegExp flags must be a string of flag characters (e.g. "g", "gi"), not ${flagsArg === null ? "null" : typeof flagsArg}.`, node);
     }
     const flags = flagsArg ?? (first instanceof Values.RegExp ? first.regex.flags : "");
     try {
@@ -60,9 +60,9 @@ export const constructRegExp = (args, node) => {
     }
     catch (error) {
         const reason = regexFailureReason(error);
-        throw new InterpreterRuntimeError(/flag/i.test(reason)
+        throw syntaxError(/flag/i.test(reason)
             ? `new RegExp(...) received invalid flags ${JSON.stringify(flags)} (${reason}). Valid flags are d, g, i, m, s, u, v, and y.`
-            : `new RegExp(...) received ${JSON.stringify(pattern)}, which is not a valid regular expression pattern (${reason}). ${escapeRegexHint}`, node).as("SyntaxError");
+            : `new RegExp(...) received ${JSON.stringify(pattern)}, which is not a valid regular expression pattern (${reason}). ${escapeRegexHint}`, node);
     }
 };
 // RegExp constructs identically with or without new, like JS.
@@ -72,7 +72,7 @@ export const regexpGlobal = sync("RegExp", constructRegExp, {
     members: {
         escape: sync("RegExp.escape", (args, node) => {
             if (typeof args[0] !== "string") {
-                throw new InterpreterRuntimeError("RegExp.escape expects a string.", node).as("TypeError");
+                throw new InterpreterRuntimeError("RegExp.escape expects a string.", node);
             }
             return RegExp.escape(args[0]);
         }),

package/dist/stdlib/url.js

@@ -1,7 +1,7 @@
 import { Effect } from "effect";
 import { toProgram } from "../data.js";
 import { HostFunction, requiresNew, sync, syncCall } from "../interpreter/host.js";
-import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { InterpreterRuntimeError, uriError } from "../interpreter/model.js";
 import { ownEntries, ProgramObject } from "../interpreter/objects.js";
 import { isRuntimeReference } from "../interpreter/references.js";
 import { preserveConsumerError } from "../interpreter/runner.js";
@@ -60,13 +60,13 @@ export const uriGlobal = (name) => sync(name, (args, node) => {
         return uriFunctions[name](value);
     }
     catch (error) {
-        throw new InterpreterRuntimeError(`${name} received malformed URI data: ${error instanceof Error ? error.message : String(error)}`, node).as("URIError");
+        throw uriError(`${name} received malformed URI data: ${error instanceof Error ? error.message : String(error)}`, node);
     }
 });
 export const urlArgument = (value, label) => value instanceof Values.URL ? value.url.href : uriArgument(value, label);
 const urlStatic = (name) => sync(`URL.${name}`, (args, node) => {
     if (args.length === 0) {
-        throw new InterpreterRuntimeError(`URL.${name} requires a URL argument.`, node).as("TypeError");
+        throw new InterpreterRuntimeError(`URL.${name} requires a URL argument.`, node);
     }
     const input = urlArgument(args[0], `URL.${name} input`);
     const base = args[1] === undefined ? undefined : urlArgument(args[1], `URL.${name} base`);
@@ -80,7 +80,7 @@ const urlStatic = (name) => sync(`URL.${name}`, (args, node) => {
 });
 const constructURL = (args, node) => {
     if (args.length === 0) {
-        throw new InterpreterRuntimeError("new URL(...) requires a URL string and an optional base URL.", node).as("TypeError");
+        throw new InterpreterRuntimeError("new URL(...) requires a URL string and an optional base URL.", node);
     }
     const input = urlArgument(args[0], "new URL input");
     const base = args[1] === undefined ? undefined : urlArgument(args[1], "new URL base");
@@ -88,7 +88,7 @@ const constructURL = (args, node) => {
         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");
+        throw new InterpreterRuntimeError(`new URL(...) received an invalid URL${base === undefined ? "" : " or base URL"}.`, node);
     }
 };
 export const urlGlobal = new HostFunction({
@@ -101,7 +101,7 @@ export const urlGlobal = new HostFunction({
 const readURLSearchParamsPair = (runner, value, node) => Effect.gen(function* () {
     const cursor = yield* runner.syncIterator(value, node);
     if (cursor === undefined) {
-        throw new InterpreterRuntimeError("new URLSearchParams(...) expects iterable [name, value] pairs.", node).as("TypeError");
+        throw new InterpreterRuntimeError("new URLSearchParams(...) expects iterable [name, value] pairs.", node);
     }
     const items = [];
     while (true) {
@@ -130,7 +130,7 @@ const constructURLSearchParams = (runner, init, node) => {
                 const step = yield* cursor.next;
                 if (step.done) {
                     if (entries.some((entry) => entry.length !== 2)) {
-                        throw new InterpreterRuntimeError("new URLSearchParams(...) expects iterable [name, value] pairs.", node).as("TypeError");
+                        throw new InterpreterRuntimeError("new URLSearchParams(...) expects iterable [name, value] pairs.", node);
                     }
                     return new Values.URLSearchParams(new URLSearchParams(entries.map((entry) => [entry[0] ?? "", entry[1] ?? ""])));
                 }
@@ -138,12 +138,12 @@ const constructURLSearchParams = (runner, init, node) => {
             }
         }
         if (isRuntimeReference(init)) {
-            throw new InterpreterRuntimeError("new URLSearchParams(...) expects a query string, data object, or synchronous iterable pairs.", node).as("TypeError");
+            throw new InterpreterRuntimeError("new URLSearchParams(...) expects a query string, data object, or synchronous iterable pairs.", node);
         }
         if (Values.isValue(init))
             return new Values.URLSearchParams(new URLSearchParams());
         if (!(init instanceof ProgramObject)) {
-            throw new InterpreterRuntimeError("new URLSearchParams(...) expects a query string, data object, iterable pairs, or URLSearchParams.", node).as("TypeError");
+            throw new InterpreterRuntimeError("new URLSearchParams(...) expects a query string, data object, iterable pairs, or URLSearchParams.", node);
         }
         return new Values.URLSearchParams(new URLSearchParams(Object.fromEntries(ownEntries(init).map(([key, value]) => [key, coerceToString(value)]))));
     });

package/dist/stdlib/value.d.ts

@@ -1,10 +1,5 @@
 import { type HostFunction, type SyncOptions } from "../interpreter/host.js";
-import { ProgramError } from "../interpreter/objects.js";
-export declare const errorConstructors: Set<string>;
 export declare const compoundOperators: Set<string>;
-export declare const createErrorValue: (name: string, message: string) => ProgramError;
-export declare const createAggregateErrorValue: (errors: Array<unknown>, message: string) => ProgramError;
-export declare const errorBrandName: (value: unknown) => string | undefined;
 export declare const coerceToString: (value: unknown) => string;
 export declare const coerceToNumber: (value: unknown) => number;
 type Coercion = "Number" | "String" | "Boolean" | "parseInt" | "parseFloat" | "isFinite" | "isNaN";

package/dist/stdlib/value.js

@@ -1,31 +1,9 @@
 import { sync } from "../interpreter/host.js";
 import { InterpreterRuntimeError } from "../interpreter/model.js";
 import { toProgram } from "../data.js";
-import { get, ProgramArray, ProgramError, set } from "../interpreter/objects.js";
+import { get, ProgramArray, ProgramError } from "../interpreter/objects.js";
 import { Values } from "../values.js";
-export const errorConstructors = new Set([
-    "Error",
-    "TypeError",
-    "RangeError",
-    "SyntaxError",
-    "ReferenceError",
-    "EvalError",
-    "URIError",
-    "AggregateError",
-]);
 export const compoundOperators = new Set(["+=", "-=", "*=", "/=", "%=", "**=", "&=", "|=", "^=", "<<=", ">>=", ">>>="]);
-export const createErrorValue = (name, message) => {
-    const value = new ProgramError(name);
-    set(value, "name", name);
-    set(value, "message", message);
-    return value;
-};
-export const createAggregateErrorValue = (errors, message) => {
-    const value = createErrorValue("AggregateError", message);
-    set(value, "errors", new ProgramArray(errors));
-    return value;
-};
-export const errorBrandName = (value) => value instanceof ProgramError ? value.errorName : undefined;
 export const coerceToString = (value) => {
     if (value === null)
         return "null";

package/dist/stdlib/web.js

@@ -1,16 +1,17 @@
 import { HostNamespace, sync } from "../interpreter/host.js";
 import { InterpreterRuntimeError } from "../interpreter/model.js";
 import { coerceToString } from "./value.js";
-// WebIDL DOMString conversion: a missing argument is a TypeError, anything else stringifies.
+// WebIDL DOMString conversion: a missing argument is a TypeError, anything else stringifies. Invalid input is a
+// TypeError as well; browsers throw a DOMException named InvalidCharacterError, which CodeMode does not have.
 const base64 = (name) => sync(name, (args, node) => {
     if (args.length === 0)
-        throw new InterpreterRuntimeError(`${name} requires 1 argument (a string)`, node).as("TypeError");
+        throw new InterpreterRuntimeError(`${name} requires 1 argument (a string)`, node);
     const input = coerceToString(args[0]);
     try {
         return name === "atob" ? atob(input) : btoa(input);
     }
     catch {
-        throw new InterpreterRuntimeError("The string contains invalid characters.", node).as("InvalidCharacterError");
+        throw new InterpreterRuntimeError("The string contains invalid characters.", node);
     }
 });
 export const atobGlobal = base64("atob");

package/package.json

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