@opencode/codemode 2.0.1 → 2.0.2

package/dist/data.d.ts

@@ -1,21 +1,22 @@
 export * as Data from "./data.js";
 import type { DiagnosticKind } from "./codemode.js";
+import type { Prototypes } from "./interpreter/intrinsics.js";
 export declare class ToolRuntimeError extends Error {
     readonly kind: Extract<DiagnosticKind, "UnknownTool" | "InvalidToolInput" | "InvalidToolOutput" | "InvalidDataValue" | "ToolCallLimitExceeded">;
     readonly suggestions: ReadonlyArray<string>;
     constructor(kind: Extract<DiagnosticKind, "UnknownTool" | "InvalidToolInput" | "InvalidToolOutput" | "InvalidDataValue" | "ToolCallLimitExceeded">, message: string, suggestions?: ReadonlyArray<string>);
 }
 /**
- * Brings a host-produced value into the program: program and runtime values pass through, their
- * host counterparts (Date, RegExp, Map, Set, URL, URLSearchParams) are wrapped, and host objects
- * and arrays are copied.
+ * Brings a host-produced value into the program: program values pass through, host Date, RegExp,
+ * Map, Set, URL, and URLSearchParams become their built-in wrappers, and host objects and arrays
+ * are copied.
  */
-export declare const toProgram: (value: unknown, label: string) => unknown;
+export declare const toProgram: (protos: Prototypes, value: unknown, label: string) => unknown;
 /**
  * Brings host data into the program: Date and URL become strings, other host collections become
  * empty objects, and objects become program copies. Used for tool results and parsed JSON.
  */
-export declare const fromData: (value: unknown, label: string) => unknown;
+export declare const fromData: (protos: Prototypes, value: unknown, label: string) => unknown;
 /**
  * Takes a program value out as plain JSON: runtime values serialize like `JSON.stringify` would,
  * non-finite numbers become null, and array holes become null. `undefined` object properties are

package/dist/data.js

@@ -1,6 +1,5 @@
 export * as Data from "./data.js";
-import { get, ownEntries, parseArrayIndex, ProgramArray, ProgramError, ProgramFunction, ProgramObject, set, } from "./interpreter/objects.js";
-import { Values } from "./values.js";
+import { Callable, define, entries, get, isWrapper, parseArrayIndex, ProgramArray, ProgramDate, ProgramError, ProgramGenerator, ProgramMap, ProgramObject, ProgramPromise, ProgramRegExp, ProgramSet, ProgramURL, ProgramURLSearchParams, } from "./interpreter/objects.js";
 const MAX_VALUE_DEPTH = 32;
 export class ToolRuntimeError extends Error {
     kind;
@@ -13,16 +12,16 @@ export class ToolRuntimeError extends Error {
     }
 }
 /**
- * Brings a host-produced value into the program: program and runtime values pass through, their
- * host counterparts (Date, RegExp, Map, Set, URL, URLSearchParams) are wrapped, and host objects
- * and arrays are copied.
+ * Brings a host-produced value into the program: program values pass through, host Date, RegExp,
+ * Map, Set, URL, and URLSearchParams become their built-in wrappers, and host objects and arrays
+ * are copied.
  */
-export const toProgram = (value, label) => copy(value, label, "program", 0, new Set());
+export const toProgram = (protos, value, label) => copy(value, label, "program", 0, new Set(), protos);
 /**
  * Brings host data into the program: Date and URL become strings, other host collections become
  * empty objects, and objects become program copies. Used for tool results and parsed JSON.
  */
-export const fromData = (value, label) => copy(value, label, "data", 0, new Set());
+export const fromData = (protos, value, label) => copy(value, label, "data", 0, new Set(), protos);
 /**
  * Takes a program value out as plain JSON: runtime values serialize like `JSON.stringify` would,
  * non-finite numbers become null, and array holes become null. `undefined` object properties are
@@ -30,7 +29,8 @@ export const fromData = (value, label) => copy(value, label, "data", 0, new Set(
  * undefined); a bare `undefined` follows the same rule.
  */
 export const toData = (value, label, undefinedAs = "json") => copy(value, label, undefinedAs, 0, new Set());
-const copy = (value, label, mode, depth, seen) => {
+const copy = (value, label, mode, depth, seen, protos) => {
+    const next = (item) => copy(item, label, mode, depth + 1, seen, protos);
     if (depth > MAX_VALUE_DEPTH) {
         throw new ToolRuntimeError("InvalidDataValue", `${label} exceeds the maximum value depth of ${MAX_VALUE_DEPTH}.`);
     }
@@ -43,60 +43,58 @@ const copy = (value, label, mode, depth, seen) => {
     if (typeof value !== "object") {
         throw new ToolRuntimeError("InvalidDataValue", `${label} must contain data only.`);
     }
-    if (value instanceof Values.Promise) {
+    if (value instanceof ProgramPromise) {
         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 (value instanceof ProgramFunction && mode !== "program") {
+    if ((value instanceof Callable || value instanceof ProgramGenerator) && mode !== "program") {
         throw new ToolRuntimeError("InvalidDataValue", `${label} must contain data only.`);
     }
-    const plain = mode === "program" || mode === "data";
-    if (mode === "program") {
-        if (value instanceof ProgramObject || Values.isValue(value))
+    if (protos !== undefined && mode === "program") {
+        if (value instanceof ProgramObject)
             return value;
         if (value instanceof Date)
-            return new Values.Date(value.getTime());
+            return new ProgramDate(protos.Date, value.getTime());
         if (value instanceof RegExp)
-            return new Values.RegExp(value.source, value.flags);
+            return new ProgramRegExp(protos.RegExp, value.source, value.flags);
         if (value instanceof Map) {
-            const wrapped = new Values.Map();
-            for (const [key, item] of value.entries()) {
-                wrapped.map.set(copy(key, label, mode, depth + 1, seen), copy(item, label, mode, depth + 1, seen));
-            }
+            const wrapped = new ProgramMap(protos.Map);
+            for (const [key, item] of value.entries())
+                wrapped.map.set(next(key), next(item));
             return wrapped;
         }
         if (value instanceof Set) {
-            const wrapped = new Values.Set();
+            const wrapped = new ProgramSet(protos.Set);
             for (const item of value.values())
-                wrapped.set.add(copy(item, label, mode, depth + 1, seen));
+                wrapped.set.add(next(item));
             return wrapped;
         }
         if (value instanceof URL)
-            return new Values.URL(new URL(value.href));
+            return new ProgramURL(protos.URL, protos.URLSearchParams, new URL(value.href));
         if (value instanceof URLSearchParams)
-            return new Values.URLSearchParams(new URLSearchParams(value));
+            return new ProgramURLSearchParams(protos.URLSearchParams, new URLSearchParams(value));
     }
-    if (value instanceof Values.Date)
+    if (value instanceof ProgramDate)
         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 Values.URL)
+    if (value instanceof ProgramURL)
         return value.url.href;
     if (value instanceof URL)
         return value.href;
-    // Remaining runtime values and their host counterparts serialize as empty objects, like JSON.stringify.
-    if (Values.isValue(value) ||
+    // Remaining wrappers and their host counterparts serialize as empty objects, like JSON.stringify.
+    if (isWrapper(value) ||
         value instanceof RegExp ||
         value instanceof Map ||
         value instanceof Set ||
         value instanceof URLSearchParams) {
-        return plain ? new ProgramObject() : {};
+        return protos !== undefined ? new ProgramObject(protos.Object) : {};
     }
     if (seen.has(value)) {
         throw new ToolRuntimeError("InvalidDataValue", `${label} contains a circular value.`);
     }
     seen.add(value);
     if (value instanceof ProgramArray) {
-        const copied = Array.from(value.items, (item) => copy(item, label, mode, depth + 1, seen) ?? null);
+        const copied = Array.from(value.items, (item) => next(item) ?? null);
         seen.delete(value);
         return copied;
     }
@@ -104,29 +102,29 @@ const copy = (value, label, mode, depth, seen) => {
         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));
+            defineHost(copied, "name", next(get(value, "name")));
+            defineHost(copied, "message", next(get(value, "message")));
         }
-        for (const [key, item] of ownEntries(value)) {
-            const next = copy(item, label, mode, depth + 1, seen);
-            if (next === undefined && mode === "json")
+        for (const [key, item] of entries(value)) {
+            const copiedItem = next(item);
+            if (copiedItem === undefined && mode === "json")
                 continue;
-            define(copied, key, next);
+            defineHost(copied, key, copiedItem);
         }
         seen.delete(value);
         return copied;
     }
     if (Array.isArray(value)) {
-        if (plain) {
-            const copied = new ProgramArray(value.map((item) => copy(item, label, mode, depth + 1, seen)));
+        if (protos !== undefined) {
+            const copied = new ProgramArray(protos.Array, value.map(next));
             for (const [key, item] of Object.entries(value)) {
                 if (parseArrayIndex(key) === undefined)
-                    set(copied, key, copy(item, label, mode, depth + 1, seen));
+                    define(copied, key, next(item));
             }
             seen.delete(value);
             return copied;
         }
-        const copied = Array.from(value, (item) => copy(item, label, mode, depth + 1, seen) ?? null);
+        const copied = Array.from(value, (item) => next(item) ?? null);
         seen.delete(value);
         return copied;
     }
@@ -134,25 +132,25 @@ const copy = (value, label, mode, depth, seen) => {
     if (prototype !== Object.prototype && prototype !== null) {
         throw new ToolRuntimeError("InvalidDataValue", `${label} must contain plain objects only.`);
     }
-    if (plain) {
-        const copied = new ProgramObject();
+    if (protos !== undefined) {
+        const copied = new ProgramObject(protos.Object);
         for (const [key, item] of Object.entries(value))
-            set(copied, key, copy(item, label, mode, depth + 1, seen));
+            define(copied, key, next(item));
         seen.delete(value);
         return copied;
     }
     const copied = {};
     for (const [key, item] of Object.entries(value)) {
-        const next = copy(item, label, mode, depth + 1, seen);
-        if (next === undefined && mode === "json")
+        const copiedItem = next(item);
+        if (copiedItem === undefined && mode === "json")
             continue;
-        define(copied, key, next);
+        defineHost(copied, key, copiedItem);
     }
     seen.delete(value);
     return copied;
 };
 // Own data property regardless of the target's prototype, so a "__proto__" key on a host object
 // never reaches the Object.prototype setter.
-const define = (target, key, value) => {
+const defineHost = (target, key, value) => {
     Object.defineProperty(target, key, { value, enumerable: true, writable: true, configurable: true });
 };

package/dist/index.d.ts

@@ -2,6 +2,5 @@ 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,6 +2,5 @@ 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/errors.d.ts

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

package/dist/interpreter/errors.js

@@ -3,9 +3,9 @@ import { ToolError } from "../tool-error.js";
 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 { createErrorValue, isErrorType } from "./intrinsics.js";
-import { get, hasPrototype, ProgramArray, ProgramError, ProgramObject, set } from "./objects.js";
+import { constructor, methods, prototypeFrom, receiver } from "./native.js";
+import { define, get, hidden, ProgramArray, ProgramError, ProgramObject, } from "./objects.js";
 import {} from "./runner.js";
 import { coerceToString } from "../stdlib/value.js";
 export const normalizeError = (error) => {
@@ -70,18 +70,18 @@ export const normalizeError = (error) => {
 export const caughtErrorValue = (runner, thrown) => {
     if (thrown instanceof ProgramThrow)
         return thrown.value;
-    const prototypes = runner.intrinsics.errors;
+    const prototypes = runner.prototypes;
     if (thrown instanceof InterpreterRuntimeError)
         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));
+export const createAggregateErrorValue = (runner, errors, message, proto = runner.prototypes.AggregateError) => {
+    const value = createErrorValue(proto, message);
+    define(value, "errors", new ProgramArray(runner.prototypes.Array, errors), { ...hidden });
     return value;
 };
-const constructAggregateErrorValue = (runner, args, node) => Effect.gen(function* () {
+const constructAggregateErrorValue = (runner, args, proto, 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);
@@ -90,23 +90,46 @@ const constructAggregateErrorValue = (runner, args, node) => Effect.gen(function
     while (true) {
         const step = yield* cursor.next;
         if (step.done) {
-            return createAggregateErrorValue(runner, errors, args[1] === undefined ? "" : coerceToString(args[1]));
+            return createAggregateErrorValue(runner, errors, args[1] === undefined ? "" : coerceToString(args[1]), proto);
         }
         errors.push(step.value);
     }
 });
 /** An error constructor such as `Error` or `TypeError`; callable with or without `new`, like JS. */
 export const errorGlobal = (type, runner) => {
-    const prototype = runner.intrinsics.errors[type];
-    const construct = (args, node) => type === "AggregateError"
-        ? constructAggregateErrorValue(runner, args, node)
-        : Effect.sync(() => createErrorValue(prototype, args[0] === undefined ? undefined : coerceToString(args[0])));
-    const fn = new HostFunction({
+    const protos = runner.prototypes;
+    const prototype = protos[type];
+    const construct = (args, newTarget, node) => {
+        const proto = prototypeFrom(newTarget, prototype);
+        return type === "AggregateError"
+            ? constructAggregateErrorValue(runner, args, proto, node)
+            : Effect.sync(() => createErrorValue(proto, args[0] === undefined ? undefined : coerceToString(args[0])));
+    };
+    const ctor = constructor(protos, prototype, {
         name: type,
-        call: construct,
+        length: type === "AggregateError" ? 2 : 1,
+        call: (_, args, node) => construct(args, ctor, node),
         construct,
-        instanceOf: (value) => hasPrototype(value, prototype),
     });
-    set(prototype, "constructor", fn);
-    return fn;
+    if (type === "Error") {
+        methods(protos, prototype, [
+            [
+                "toString",
+                0,
+                (thisValue, _, node) => {
+                    const self = receiver(ProgramObject, thisValue, "Error.prototype.toString", node);
+                    const name = get(self, "name");
+                    const message = get(self, "message");
+                    const shownName = name === undefined ? "Error" : coerceToString(name);
+                    const shownMessage = message === undefined ? "" : coerceToString(message);
+                    if (shownMessage === "")
+                        return shownName;
+                    if (shownName === "")
+                        return shownMessage;
+                    return `${shownName}: ${shownMessage}`;
+                },
+            ],
+        ]);
+    }
+    return ctor;
 };

package/dist/interpreter/execute.js

@@ -6,6 +6,7 @@ import { transpile } from "#transpile";
 import { toData } from "../data.js";
 import { ToolRuntime } from "../tool-runtime.js";
 import { normalizeError } from "./errors.js";
+import { createPrototypes } from "./intrinsics.js";
 import { InterpreterRuntimeError } from "./model.js";
 import { PromiseRuntime } from "./promises.js";
 import { Runtime } from "./runtime.js";
@@ -19,15 +20,16 @@ export const executeProgram = (code, prepared, limits, hooks, extraGlobals) => {
     }
     // Allocate execution state inside suspension so reused Effects never share it.
     return Effect.suspend(() => {
-        const tools = ToolRuntime.make(prepared, limits.maxToolCalls, hooks);
+        const prototypes = createPrototypes();
+        const tools = ToolRuntime.make(prepared, prototypes, limits.maxToolCalls, hooks);
         const logs = [];
         const logged = () => (logs.length > 0 ? { logs: [...logs] } : {});
         // Set only after copy-out so timeouts cannot report invalid values as completed.
         let returned;
         const base = Effect.acquireUseRelease(Scope.make("parallel"), (scope) => Effect.gen(function* () {
             const program = parseProgram(code);
-            const promises = new PromiseRuntime(scope);
-            const value = yield* new Runtime(tools.execute, tools.search, tools.keys, promises, logs, extraGlobals).run(program);
+            const promises = new PromiseRuntime(scope, prototypes.Promise);
+            const value = yield* new Runtime(tools.execute, tools.search, tools.keys, promises, prototypes, logs, extraGlobals).run(program);
             const result = toData(value, "Execution result", "result");
             returned = { value: result, promises };
             const warnings = yield* promises.interrupt();

package/dist/interpreter/generators.d.ts

@@ -0,0 +1,4 @@
+import type { PromiseRuntime } from "./promises.js";
+import type { Runner } from "./runner.js";
+/** `next`/`return`/`throw` on the generator prototypes; async generators answer with promises. */
+export declare const generatorGlobals: <R>(runner: Runner<R>, promises: PromiseRuntime<R>) => void;

package/dist/interpreter/generators.js

@@ -0,0 +1,25 @@
+import { Effect } from "effect";
+import { fn, methods, receiver } from "./native.js";
+import { AsyncIteratorSymbol, IteratorSymbol } from "./model.js";
+import { define, hidden, ProgramGenerator } from "./objects.js";
+/** `next`/`return`/`throw` on the generator prototypes; async generators answer with promises. */
+export const generatorGlobals = (runner, promises) => {
+    const protos = runner.prototypes;
+    const install = (asynchronous) => {
+        const proto = asynchronous ? protos.AsyncGenerator : protos.Generator;
+        const label = asynchronous ? "AsyncGenerator" : "Generator";
+        const request = (kind) => [
+            kind,
+            1,
+            (thisValue, args, node) => {
+                const generator = receiver(ProgramGenerator, thisValue, `${label}.prototype.${kind}`, node);
+                const requested = generator.request(kind, args[0], node);
+                return generator.asynchronous ? promises.create(requested) : requested;
+            },
+        ];
+        methods(protos, proto, [request("next"), request("return"), request("throw")]);
+        define(asynchronous ? protos.AsyncIterator : protos.Iterator, asynchronous ? AsyncIteratorSymbol : IteratorSymbol, fn(protos, asynchronous ? "[Symbol.asyncIterator]" : "[Symbol.iterator]", 0, (thisValue) => thisValue), hidden);
+    };
+    install(false);
+    install(true);
+};

package/dist/interpreter/globals.js

@@ -5,60 +5,81 @@ import { consoleGlobal } from "../stdlib/console.js";
 import { dateGlobal } from "../stdlib/date.js";
 import { jsonGlobal } from "../stdlib/json.js";
 import { mathGlobal } from "../stdlib/math.js";
-import { numberGlobal } from "../stdlib/number.js";
+import { booleanGlobal, numberGlobal } from "../stdlib/number.js";
 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 } from "../stdlib/value.js";
-import { atobGlobal, btoaGlobal, cryptoGlobal } from "../stdlib/web.js";
+import { base64Global, 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 { constants, constructor, native } from "./native.js";
 import { AsyncIteratorSymbol, InterpreterRuntimeError, IteratorSymbol } from "./model.js";
+import { generatorGlobals } from "./generators.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);
-    }),
-    callback: false,
-    members: { asyncIterator: AsyncIteratorSymbol, iterator: IteratorSymbol },
-});
+// Function.prototype.constructor exists so `fn.constructor === Function` holds; dynamic code is unsupported.
+const functionGlobal = (runner) => {
+    const reject = (_, __, node) => Effect.sync(() => {
+        throw new InterpreterRuntimeError("The Function constructor is not supported; write the function inline.", node);
+    });
+    return constructor(runner.prototypes, runner.prototypes.Function, {
+        name: "Function",
+        length: 1,
+        call: reject,
+        construct: (args, _, node) => reject(undefined, args, node),
+    });
+};
+const symbolGlobal = (runner) => {
+    const symbol = native(runner.prototypes, {
+        name: "Symbol",
+        call: (_, __, node) => Effect.sync(() => {
+            throw new InterpreterRuntimeError("Symbol is not callable; only Symbol.asyncIterator and Symbol.iterator are available.", node);
+        }),
+        callback: false,
+    });
+    constants(symbol, { asyncIterator: AsyncIteratorSymbol, iterator: IteratorSymbol });
+    return symbol;
+};
 /** The immutable global bindings of every program, in declaration order. */
-export const globals = (host) => [
-    ["tools", new ToolReference([])],
-    ["search", new HostFunction({ name: "search", call: (args) => host.search(args), callback: false })],
-    ["undefined", undefined],
-    ["NaN", NaN],
-    ["Infinity", Infinity],
-    ["Object", objectGlobal(host.runner, host.toolKeys)],
-    ["Array", arrayGlobal(host.runner)],
-    ["Math", mathGlobal(host.runner)],
-    ["JSON", jsonGlobal(host.runner)],
-    ["console", consoleGlobal(host.logs)],
-    ["Promise", promiseGlobal(host.runner, host.promises)],
-    ["Symbol", symbolGlobal],
-    ["Number", numberGlobal],
-    ["String", stringGlobal],
-    ["Boolean", coercion("Boolean", { instanceOf: () => false })],
-    ["parseInt", coercion("parseInt")],
-    ["parseFloat", coercion("parseFloat")],
-    ["isFinite", coercion("isFinite")],
-    ["isNaN", coercion("isNaN")],
-    ["Date", dateGlobal(host.runner)],
-    ["RegExp", regexpGlobal],
-    ["Map", mapGlobal(host.runner)],
-    ["Set", setGlobal(host.runner)],
-    ["URL", urlGlobal],
-    ["URLSearchParams", urlSearchParamsGlobal(host.runner)],
-    ["encodeURI", uriGlobal("encodeURI")],
-    ["encodeURIComponent", uriGlobal("encodeURIComponent")],
-    ["decodeURI", uriGlobal("decodeURI")],
-    ["decodeURIComponent", uriGlobal("decodeURIComponent")],
-    ["atob", atobGlobal],
-    ["btoa", btoaGlobal],
-    ["crypto", cryptoGlobal],
-    ...errorTypes.map((type) => [type, errorGlobal(type, host.runner)]),
-];
+export const globals = (host) => {
+    const runner = host.runner;
+    generatorGlobals(runner, host.promises);
+    return [
+        ["tools", new ToolReference([])],
+        ["search", native(runner.prototypes, { name: "search", call: (_, args) => host.search(args), callback: false })],
+        ["undefined", undefined],
+        ["NaN", NaN],
+        ["Infinity", Infinity],
+        ["Object", objectGlobal(runner, host.toolKeys)],
+        ["Function", functionGlobal(runner)],
+        ["Array", arrayGlobal(runner)],
+        ["Math", mathGlobal(runner)],
+        ["JSON", jsonGlobal(runner)],
+        ["console", consoleGlobal(runner, host.logs)],
+        ["Promise", promiseGlobal(runner, host.promises)],
+        ["Symbol", symbolGlobal(runner)],
+        ["Number", numberGlobal(runner)],
+        ["String", stringGlobal(runner)],
+        ["Boolean", booleanGlobal(runner)],
+        ["parseInt", coercion(runner, "parseInt", 2)],
+        ["parseFloat", coercion(runner, "parseFloat")],
+        ["isFinite", coercion(runner, "isFinite")],
+        ["isNaN", coercion(runner, "isNaN")],
+        ["Date", dateGlobal(runner)],
+        ["RegExp", regexpGlobal(runner)],
+        ["Map", mapGlobal(runner)],
+        ["Set", setGlobal(runner)],
+        ["URL", urlGlobal(runner)],
+        ["URLSearchParams", urlSearchParamsGlobal(runner)],
+        ["encodeURI", uriGlobal(runner, "encodeURI")],
+        ["encodeURIComponent", uriGlobal(runner, "encodeURIComponent")],
+        ["decodeURI", uriGlobal(runner, "decodeURI")],
+        ["decodeURIComponent", uriGlobal(runner, "decodeURIComponent")],
+        ["atob", base64Global(runner, "atob")],
+        ["btoa", base64Global(runner, "btoa")],
+        ["crypto", cryptoGlobal(runner)],
+        ...errorTypes.map((type) => [type, errorGlobal(type, runner)]),
+    ];
+};

package/dist/interpreter/intrinsics.d.ts

@@ -2,9 +2,12 @@ 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>>;
-};
+declare const builtins: readonly ["Object", "Function", "Array", "String", "Number", "Boolean", "Date", "RegExp", "Map", "Set", "URL", "URLSearchParams", "Promise", "Iterator", "AsyncIterator", "Generator", "AsyncGenerator"];
+/**
+ * The built-in prototype objects of one runtime, allocated empty in dependency order. The globals populate them
+ * and attach their constructors when the runtime is built.
+ */
+export type Prototypes = Readonly<Record<(typeof builtins)[number] | ErrorType, ProgramObject>>;
 export declare const createErrorValue: (prototype: ProgramObject, message: string | undefined) => ProgramError;
-export declare const createIntrinsics: () => Intrinsics;
+export declare const createPrototypes: () => Prototypes;
+export {};