@opencode/codemode 0.0.0-dev-19631 → 0.0.0-dev-19633

package/dist/interpreter/promises.d.ts

@@ -1,8 +1,8 @@
 import { Effect, Exit, Scope } from "effect";
 import type { Diagnostic } from "../codemode.js";
-import { ProgramObject, ProgramPromise } from "./objects.js";
-import { type Runner } from "./runner.js";
-export declare class PromiseRuntime<R> {
+import { Obj, PromiseObj } from "./objects.js";
+import type { Interpreter } from "./interpreter.js";
+export declare class Pending<R> {
     private readonly scope;
     private readonly proto;
     private readonly active;
@@ -10,19 +10,19 @@ export declare class PromiseRuntime<R> {
     private readonly observed;
     private readonly failures;
     private nextID;
-    constructor(scope: Scope.Scope, proto: ProgramObject);
+    constructor(scope: Scope.Scope, proto: Obj);
     createWithSelf(body: (self: {
-        promise?: ProgramPromise;
-    }) => Effect.Effect<unknown, unknown, R>): Effect.Effect<ProgramPromise, never, R>;
-    create(effect: Effect.Effect<unknown, unknown, R>): Effect.Effect<ProgramPromise, never, R>;
-    markObserved(promise: ProgramPromise): void;
-    await(promise: ProgramPromise): Effect.Effect<Exit.Exit<unknown, unknown>>;
+        promise?: PromiseObj;
+    }) => Effect.Effect<unknown, unknown, R>): Effect.Effect<PromiseObj, never, R>;
+    create(effect: Effect.Effect<unknown, unknown, R>): Effect.Effect<PromiseObj, never, R>;
+    markObserved(promise: PromiseObj): void;
+    await(promise: PromiseObj): Effect.Effect<Exit.Exit<unknown, unknown>>;
     fork(effect: Effect.Effect<unknown, unknown, R>): Effect.Effect<void, never, R>;
     diagnostics(): Array<Diagnostic>;
     interrupt(): Effect.Effect<Array<Diagnostic>>;
 }
-export declare const resolvePromiseValue: <R>(runner: Runner<R>, value: unknown, own?: {
-    promise?: ProgramPromise;
+export declare const resolvePromiseValue: <R>(ctx: Interpreter<R>, value: unknown, own?: {
+    promise?: PromiseObj;
 }) => Effect.Effect<unknown, unknown, R>;
-export declare const resolvePromise: <R>(runner: Runner<R>, promises: PromiseRuntime<R>, value: unknown) => Effect.Effect<ProgramPromise, never, R>;
-export declare const promiseGlobal: <R>(runner: Runner<R>, promises: PromiseRuntime<R>) => import("./objects.js").NativeFunction<R>;
+export declare const resolvePromise: <R>(ctx: Interpreter<R>, value: unknown) => Effect.Effect<PromiseObj, never, R>;
+export declare const promiseGlobal: <R>(ctx: Interpreter<R>) => import("./objects.js").Native<R>;

package/dist/interpreter/promises.js

@@ -1,18 +1,18 @@
 import { Cause, Deferred, Effect, Exit, Fiber, Scope } from "effect";
 import { MAX_PENDING_PROMISES } from "./limits.js";
-import { CallSite, ProgramThrow, rangeError, typeError } from "./model.js";
-import { Callable, define, get, hidden, ProgramArray, ProgramFunction, ProgramObject, ProgramPromise, record, } from "./objects.js";
+import { CallSite, Throw, rangeError, typeError } from "./model.js";
+import { Callable, define, get, hidden, Arr, Fn, Obj, PromiseObj, record } from "./objects.js";
 import { constructor, fn, methods, native, receiver, requiresNew } from "./native.js";
 import { createAggregateErrorValue, locate, materialize, normalizeError } from "./errors.js";
 import { typeofValue } from "./references.js";
-import { applyCollectionCallback, isSupportedCallback } from "./runner.js";
+import { applyCollectionCallback, isSupportedCallback } from "./callback.js";
 // A `resolve`/`reject` handed to an executor or thenable: calling it settles the capability.
-const capability = (runner, name, settle) => fn(runner.prototypes, name, 1, (_, args) => {
+const capability = (ctx, name, settle) => fn(ctx.builtins, name, 1, (_, args) => {
     settle(args[0]);
     return undefined;
 });
 // Observation only controls rejection reporting; program completion interrupts all promise work.
-export class PromiseRuntime {
+export class Pending {
     scope;
     proto;
     active = new Set();
@@ -41,7 +41,7 @@ export class PromiseRuntime {
             const id = this.nextID++;
             const body = Effect.catchDefect(effect, (defect) => Effect.die(locate(defect, site.node)));
             return Effect.map(Effect.forkIn(body, this.scope, { startImmediately: true }), (fiber) => {
-                const promise = new ProgramPromise(this.proto, fiber);
+                const promise = new PromiseObj(this.proto, fiber);
                 this.active.add(promise);
                 this.ids.set(promise, id);
                 fiber.addObserver((exit) => {
@@ -88,13 +88,13 @@ export class PromiseRuntime {
         });
     }
 }
-export const resolvePromiseValue = (runner, value, own) => {
+export const resolvePromiseValue = (ctx, value, own) => {
     if (own?.promise !== undefined && value === own.promise) {
         return Effect.die(typeError("Chaining cycle detected: a promise cannot resolve with itself."));
     }
-    if (value instanceof ProgramPromise)
-        return runner.settlePromise(value);
-    if (!(value instanceof ProgramObject))
+    if (value instanceof PromiseObj)
+        return ctx.await(value);
+    if (!(value instanceof Obj))
         return Effect.succeed(value);
     const then = get(value, "then");
     if (typeofValue(then) !== "function")
@@ -103,32 +103,32 @@ export const resolvePromiseValue = (runner, value, own) => {
         // Promise resolution invokes a thenable's method in a later job.
         yield* Effect.yieldNow;
         const deferred = Deferred.makeUnsafe();
-        const resolve = capability(runner, "resolve", (result) => Deferred.doneUnsafe(deferred, Exit.succeed(result)));
-        const reject = capability(runner, "reject", (reason) => Deferred.doneUnsafe(deferred, Exit.fail(new ProgramThrow(reason))));
-        const executed = yield* Effect.exit(runner.invokeCallable(then, value, [resolve, reject]));
+        const resolve = capability(ctx, "resolve", (result) => Deferred.doneUnsafe(deferred, Exit.succeed(result)));
+        const reject = capability(ctx, "reject", (reason) => Deferred.doneUnsafe(deferred, Exit.fail(new Throw(reason))));
+        const executed = yield* Effect.exit(ctx.call(then, value, [resolve, reject]));
         if (!Exit.isSuccess(executed)) {
             if (Cause.hasInterruptsOnly(executed.cause))
                 return yield* Effect.failCause(executed.cause);
             Deferred.doneUnsafe(deferred, Exit.fail(Cause.squash(executed.cause)));
         }
-        return yield* resolvePromiseValue(runner, yield* Deferred.await(deferred), own);
+        return yield* resolvePromiseValue(ctx, yield* Deferred.await(deferred), own);
     });
 };
-export const resolvePromise = (runner, promises, value) => {
-    if (value instanceof ProgramPromise)
+export const resolvePromise = (ctx, value) => {
+    if (value instanceof PromiseObj)
         return Effect.succeed(value);
-    return promises.createWithSelf((self) => resolvePromiseValue(runner, value, self));
+    return ctx.pending.createWithSelf((self) => resolvePromiseValue(ctx, value, self));
 };
 const promiseStatics = ["all", "allSettled", "race", "any", "resolve", "reject"];
-const invokePromiseMethod = (runner, promises, name, args) => {
+const invokePromiseMethod = (ctx, name, args) => {
     if (name === "resolve") {
-        return resolvePromise(runner, promises, args[0]);
+        return resolvePromise(ctx, args[0]);
     }
     if (name === "reject") {
-        return promises.create(Effect.fail(new ProgramThrow(args[0])));
+        return ctx.pending.create(Effect.fail(new Throw(args[0])));
     }
-    return promises.create(Effect.gen(function* () {
-        const cursor = yield* runner.syncIterator(args[0]);
+    return ctx.pending.create(Effect.gen(function* () {
+        const cursor = yield* ctx.iterate(args[0]);
         if (cursor === undefined)
             throw typeError(`Promise.${name} expects an array or other synchronous iterable.`);
         const items = [];
@@ -136,68 +136,68 @@ const invokePromiseMethod = (runner, promises, name, args) => {
             const step = yield* cursor.next;
             if (step.done)
                 break;
-            const item = yield* resolvePromise(runner, promises, step.value);
-            promises.markObserved(item);
+            const item = yield* resolvePromise(ctx, step.value);
+            ctx.pending.markObserved(item);
             items.push(item);
         }
         if (name === "all") {
-            return new ProgramArray(runner.prototypes.Array, yield* settleAfterTurn(Effect.all(items.map((item) => Effect.flatten(promises.await(item))), { concurrency: "unbounded" })));
+            return new Arr(ctx.builtins.Array, yield* settleAfterTurn(Effect.all(items.map((item) => Effect.flatten(ctx.pending.await(item))), { concurrency: "unbounded" })));
         }
         if (name === "allSettled") {
             const outcomes = [];
             for (const item of items) {
-                const exit = yield* promises.await(item);
+                const exit = yield* ctx.pending.await(item);
                 if (Exit.isSuccess(exit)) {
-                    outcomes.push(record(runner.prototypes.Object, { status: "fulfilled", value: exit.value }));
+                    outcomes.push(record(ctx.builtins.Object, { status: "fulfilled", value: exit.value }));
                     continue;
                 }
                 if (Cause.hasInterruptsOnly(exit.cause))
                     return yield* Effect.failCause(exit.cause);
-                outcomes.push(record(runner.prototypes.Object, {
+                outcomes.push(record(ctx.builtins.Object, {
                     status: "rejected",
-                    reason: materialize(runner, Cause.squash(exit.cause)),
+                    reason: materialize(ctx, Cause.squash(exit.cause)),
                 }));
             }
             yield* Effect.yieldNow;
-            return new ProgramArray(runner.prototypes.Array, outcomes);
+            return new Arr(ctx.builtins.Array, outcomes);
         }
         if (name === "race") {
             if (items.length === 0) {
                 throw typeError("Promise.race([]) would never settle; provide at least one promise or value.");
             }
-            return yield* settleAfterTurn(Effect.flatten(Effect.raceAll(items.map((item) => promises.await(item)))));
+            return yield* settleAfterTurn(Effect.flatten(Effect.raceAll(items.map((item) => ctx.pending.await(item)))));
         }
-        const flipped = items.map((item) => Effect.flatMap(promises.await(item), (exit) => {
+        const flipped = items.map((item) => Effect.flatMap(ctx.pending.await(item), (exit) => {
             if (Exit.isSuccess(exit))
                 return Effect.fail(new PromiseAnyFulfilled(exit.value));
             if (Cause.hasInterruptsOnly(exit.cause))
                 return Effect.failCause(exit.cause);
-            return Effect.succeed(materialize(runner, Cause.squash(exit.cause)));
+            return Effect.succeed(materialize(ctx, Cause.squash(exit.cause)));
         }));
-        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))));
+        return yield* settleAfterTurn(Effect.all(flipped, { concurrency: "unbounded" }).pipe(Effect.flatMap((reasons) => Effect.fail(new Throw(createAggregateErrorValue(ctx, reasons, "All promises were rejected")))), Effect.catch((error) => error instanceof PromiseAnyFulfilled ? Effect.succeed(error.value) : Effect.fail(error))));
     }));
 };
-const instanceMethod = (runner, promises, name, thisValue, args) => {
+const instanceMethod = (ctx, name, thisValue, args) => {
     const method = `Promise.prototype.${name}`;
-    const promise = receiver(ProgramPromise, thisValue, method);
-    promises.markObserved(promise);
+    const promise = receiver(PromiseObj, thisValue, method);
+    ctx.pending.markObserved(promise);
     if (name === "finally") {
-        return chainFinally(runner, promises, promise, reactionHandler(args[0], method), method);
+        return chainFinally(ctx, promise, reactionHandler(args[0], method), method);
     }
     const onFulfilled = name === "then" ? reactionHandler(args[0], method) : undefined;
     const onRejected = reactionHandler(name === "then" ? args[1] : args[0], method);
-    return chainReaction(runner, promises, promise, onFulfilled, onRejected, method);
+    return chainReaction(ctx, promise, onFulfilled, onRejected, method);
 };
-const constructPromise = (runner, promises, executor) => {
-    if (!(executor instanceof ProgramFunction)) {
+const constructPromise = (ctx, executor) => {
+    if (!(executor instanceof Fn)) {
         throw typeError("new Promise(...) expects an executor function (e.g. new Promise((resolve, reject) => { ... })).");
     }
     return Effect.gen(function* () {
         const deferred = Deferred.makeUnsafe();
-        const promise = yield* promises.createWithSelf((self) => Effect.flatMap(Deferred.await(deferred), (value) => resolvePromiseValue(runner, value, self)));
-        const resolve = capability(runner, "resolve", (value) => Deferred.doneUnsafe(deferred, Exit.succeed(value)));
-        const reject = capability(runner, "reject", (value) => Deferred.doneUnsafe(deferred, Exit.fail(new ProgramThrow(value))));
-        const executed = yield* Effect.exit(runner.invokeCallable(executor, undefined, [resolve, reject]));
+        const promise = yield* ctx.pending.createWithSelf((self) => Effect.flatMap(Deferred.await(deferred), (value) => resolvePromiseValue(ctx, value, self)));
+        const resolve = capability(ctx, "resolve", (value) => Deferred.doneUnsafe(deferred, Exit.succeed(value)));
+        const reject = capability(ctx, "reject", (value) => Deferred.doneUnsafe(deferred, Exit.fail(new Throw(value))));
+        const executed = yield* Effect.exit(ctx.call(executor, undefined, [resolve, reject]));
         if (!Exit.isSuccess(executed)) {
             if (Cause.hasInterruptsOnly(executed.cause))
                 return yield* Effect.failCause(executed.cause);
@@ -223,58 +223,58 @@ const reactionHandler = (value, method) => {
     return undefined;
 };
 // Teardown bypasses handlers; settled reactions yield once so handlers never run inline.
-const reactionExit = (promises, source) => Effect.gen(function* () {
-    const exit = yield* promises.await(source);
+const reactionExit = (ctx, source) => Effect.gen(function* () {
+    const exit = yield* ctx.pending.await(source);
     if (!Exit.isSuccess(exit) && Cause.hasInterruptsOnly(exit.cause))
         return yield* Effect.failCause(exit.cause);
     yield* Effect.yieldNow;
     return exit;
 });
-const chainReaction = (runner, promises, source, onFulfilled, onRejected, method) => {
-    return promises.createWithSelf((self) => Effect.gen(function* () {
-        const exit = yield* reactionExit(promises, source);
+const chainReaction = (ctx, source, onFulfilled, onRejected, method) => {
+    return ctx.pending.createWithSelf((self) => Effect.gen(function* () {
+        const exit = yield* reactionExit(ctx, source);
         const handler = Exit.isSuccess(exit) ? onFulfilled : onRejected;
         if (handler === undefined)
             return yield* exit;
-        const input = Exit.isSuccess(exit) ? exit.value : materialize(runner, Cause.squash(exit.cause));
-        const result = yield* applyCollectionCallback(runner, handler, method)([input]);
-        return yield* resolvePromiseValue(runner, result, self);
+        const input = Exit.isSuccess(exit) ? exit.value : materialize(ctx, Cause.squash(exit.cause));
+        const result = yield* applyCollectionCallback(ctx, handler, method)([input]);
+        return yield* resolvePromiseValue(ctx, result, self);
     }));
 };
-const chainFinally = (runner, promises, source, cleanup, method) => promises.create(Effect.gen(function* () {
-    const exit = yield* reactionExit(promises, source);
+const chainFinally = (ctx, source, cleanup, method) => ctx.pending.create(Effect.gen(function* () {
+    const exit = yield* reactionExit(ctx, source);
     if (cleanup !== undefined) {
-        const result = yield* applyCollectionCallback(runner, cleanup, method)([]);
-        const intermediate = yield* promises.create(Effect.gen(function* () {
-            yield* runner.settlePromise(yield* resolvePromise(runner, promises, result));
+        const result = yield* applyCollectionCallback(ctx, cleanup, method)([]);
+        const intermediate = yield* ctx.pending.create(Effect.gen(function* () {
+            yield* ctx.await(yield* resolvePromise(ctx, result));
             return yield* exit;
         }));
-        return yield* runner.settlePromise(intermediate);
+        return yield* ctx.await(intermediate);
     }
     return yield* exit;
 }));
-export const promiseGlobal = (runner, promises) => {
-    const protos = runner.prototypes;
-    const proto = protos.Promise;
-    const promise = constructor(protos, proto, {
+export const promiseGlobal = (ctx) => {
+    const builtins = ctx.builtins;
+    const proto = builtins.Promise;
+    const promise = constructor(builtins, proto, {
         name: "Promise",
         length: 1,
         call: requiresNew("Promise"),
-        construct: (args) => constructPromise(runner, promises, args[0]),
+        construct: (args) => constructPromise(ctx, args[0]),
     });
     // Combinators are not callbacks: `[p].map(Promise.resolve)` must ask for an arrow function.
     for (const name of promiseStatics) {
-        define(promise, name, native(protos, {
+        define(promise, name, native(builtins, {
             name,
             length: 1,
-            call: (_, args) => invokePromiseMethod(runner, promises, name, args),
+            call: (_, args) => invokePromiseMethod(ctx, name, args),
             callback: false,
         }), hidden);
     }
-    methods(protos, proto, [
-        ["then", 2, (thisValue, args) => instanceMethod(runner, promises, "then", thisValue, args)],
-        ["catch", 1, (thisValue, args) => instanceMethod(runner, promises, "catch", thisValue, args)],
-        ["finally", 1, (thisValue, args) => instanceMethod(runner, promises, "finally", thisValue, args)],
+    methods(builtins, proto, [
+        ["then", 2, (thisValue, args) => instanceMethod(ctx, "then", thisValue, args)],
+        ["catch", 1, (thisValue, args) => instanceMethod(ctx, "catch", thisValue, args)],
+        ["finally", 1, (thisValue, args) => instanceMethod(ctx, "finally", thisValue, args)],
     ]);
     return promise;
 };

package/dist/interpreter/references.js

@@ -1,15 +1,15 @@
 import { ToolReference } from "../tool-runtime.js";
 import { invalidData } from "./model.js";
-import { Callable, getOwn, isWrapper, ownKeys, ProgramArray, ProgramDate, ProgramGenerator, ProgramHandle, ProgramMap, ProgramObject, ProgramPromise, ProgramRegExp, ProgramSet, ProgramURL, ProgramURLSearchParams, } from "./objects.js";
+import { Callable, getOwn, isWrapper, ownKeys, Arr, Bytes, DateObj, GeneratorObj, Handle, MapObj, Obj, PromiseObj, RegExpObj, SetObj, URLObj, URLSearchParamsObj, } from "./objects.js";
 /** Values that cannot cross the data boundary. */
 export const isRuntimeReference = (value) => value instanceof Callable ||
-    value instanceof ProgramGenerator ||
-    value instanceof ProgramHandle ||
+    value instanceof GeneratorObj ||
+    value instanceof Handle ||
     value instanceof ToolReference ||
-    value instanceof ProgramPromise ||
+    value instanceof PromiseObj ||
     isWrapper(value);
 function* childValues(value) {
-    if (!(value instanceof ProgramObject))
+    if (!(value instanceof Obj))
         return;
     for (const key of ownKeys(value))
         yield getOwn(value, key);
@@ -46,27 +46,29 @@ export const rejectCircularInsertion = (container, value, label, seen = new Set(
 export const describeValue = (value) => {
     if (value === null || value === undefined)
         return String(value);
-    if (value instanceof ProgramArray)
+    if (value instanceof Arr)
         return "an array";
-    if (value instanceof ProgramPromise)
+    if (value instanceof PromiseObj)
         return "an un-awaited Promise";
     if (value instanceof ToolReference)
         return "a tool reference";
-    if (value instanceof ProgramDate)
+    if (value instanceof DateObj)
         return "a Date";
-    if (value instanceof ProgramRegExp)
+    if (value instanceof RegExpObj)
         return "a RegExp";
-    if (value instanceof ProgramMap)
+    if (value instanceof MapObj)
         return "a Map";
-    if (value instanceof ProgramSet)
+    if (value instanceof SetObj)
         return "a Set";
-    if (value instanceof ProgramURL)
+    if (value instanceof URLObj)
         return "a URL";
-    if (value instanceof ProgramURLSearchParams)
+    if (value instanceof URLSearchParamsObj)
         return "a URLSearchParams";
-    if (value instanceof ProgramGenerator)
+    if (value instanceof Bytes)
+        return "a Uint8Array";
+    if (value instanceof GeneratorObj)
         return "a generator";
-    if (value instanceof ProgramHandle)
+    if (value instanceof Handle)
         return `a ${value.instance.constructor.name}`;
     if (isRuntimeReference(value))
         return "a function";

package/dist/openapi/types.d.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect";
 import { HttpClient } from "effect/unstable/http";
 import type { Tool, JsonSchema } from "../tool.js";
-/** A parsed OpenAPI 3.x document. YAML must be parsed by the host. */
+/** A parsed OpenAPI 3.x document. YAML must be parsed by the ctx. */
 export type Document = Record<string, unknown>;
 /** The operation identity handed to auth resolution and errors. */
 export type Operation = {

package/dist/stdlib/array.d.ts

@@ -1,4 +1,4 @@
 import { Effect } from "effect";
-import { type Runner } from "../interpreter/runner.js";
-export declare const sortArray: <R>(runner: Runner<R>, target: Array<unknown>, comparator: unknown, name: string) => Effect.Effect<Array<unknown>, unknown, R>;
-export declare const arrayGlobal: <R>(runner: Runner<R>) => import("../interpreter/objects.js").NativeFunction<R>;
+import type { Interpreter } from "../interpreter/interpreter.js";
+export declare const sortArray: <R>(ctx: Interpreter<R>, target: Array<unknown>, comparator: unknown, name: string) => Effect.Effect<Array<unknown>, unknown, R>;
+export declare const arrayGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;

package/dist/stdlib/array.js

@@ -2,13 +2,13 @@ import { Effect } from "effect";
 import { constructor, methods, prototypeFrom, receiver } from "../interpreter/native.js";
 import { checkArrayLength, checkStringLength, MAX_ARRAY_LENGTH } from "../interpreter/limits.js";
 import { invalidData, rangeError, typeError } from "../interpreter/model.js";
-import { get, ProgramArray, ProgramGenerator, ProgramObject } from "../interpreter/objects.js";
+import { get, Arr, GeneratorObj, Obj } from "../interpreter/objects.js";
 import { describeValue, rejectCircularInsertion } from "../interpreter/references.js";
-import { applyCollectionCallback, preserveConsumerError } from "../interpreter/runner.js";
+import { applyCollectionCallback, preserveConsumerError } from "../interpreter/callback.js";
 import { compareText } from "../tool-runtime.js";
 import { coerceToNumber, coerceToString } from "./value.js";
 const arrayLikeSource = (source) => {
-    if (source instanceof ProgramObject && typeof get(source, "length") === "number") {
+    if (source instanceof Obj && typeof get(source, "length") === "number") {
         const length = get(source, "length");
         const normalized = Number.isNaN(length) || length <= 0 ? 0 : Math.trunc(length);
         checkArrayLength(normalized);
@@ -16,14 +16,14 @@ const arrayLikeSource = (source) => {
     }
     throw invalidData(`Array.from expects an array, string, Map, Set, or array-like value, received ${describeValue(source)}.`);
 };
-const arrayFrom = (runner, args) => {
+const arrayFrom = (ctx, args) => {
     const source = args[0];
-    const proto = runner.prototypes.Array;
-    const apply = args.length < 2 || args[1] === undefined ? undefined : applyCollectionCallback(runner, args[1], "Array.from");
+    const proto = ctx.builtins.Array;
+    const apply = args.length < 2 || args[1] === undefined ? undefined : applyCollectionCallback(ctx, args[1], "Array.from");
     return Effect.gen(function* () {
-        const cursor = yield* runner.syncIterator(source);
+        const cursor = yield* ctx.iterate(source);
         if (cursor === undefined) {
-            if (source instanceof ProgramGenerator) {
+            if (source instanceof GeneratorObj) {
                 throw typeError("Array.from expects a synchronous iterable or array-like value.");
             }
             const arrayLike = arrayLikeSource(source);
@@ -32,24 +32,24 @@ const arrayFrom = (runner, args) => {
                 const item = get(arrayLike.source, index);
                 values.push(apply === undefined ? item : yield* apply([item, index]));
             }
-            return new ProgramArray(proto, values);
+            return new Arr(proto, values);
         }
         const values = [];
         let index = 0;
         while (true) {
             const step = yield* cursor.next;
             if (step.done)
-                return new ProgramArray(proto, values);
+                return new Arr(proto, values);
             values.push(apply === undefined ? step.value : yield* preserveConsumerError(cursor, apply([step.value, index])));
             index += 1;
         }
     });
 };
-export const sortArray = (runner, target, comparator, name) => {
+export const sortArray = (ctx, target, comparator, name) => {
     if (comparator === undefined) {
         return Effect.sync(() => [...target].sort((a, b) => compareText(coerceToString(a), coerceToString(b))));
     }
-    const apply = applyCollectionCallback(runner, comparator, name);
+    const apply = applyCollectionCallback(ctx, comparator, name);
     const mergeSort = (items) => {
         if (items.length <= 1)
             return Effect.succeed(items);
@@ -76,33 +76,33 @@ export const sortArray = (runner, target, comparator, name) => {
     return Effect.map(mergeSort(defined), (items) => [...items, ...Array(undefinedCount).fill(undefined)]);
 };
 // Array constructs identically with or without new, like JS.
-export const arrayGlobal = (runner) => {
-    const protos = runner.prototypes;
-    const proto = protos.Array;
-    const wrap = (items) => new ProgramArray(proto, items);
+export const arrayGlobal = (ctx) => {
+    const builtins = ctx.builtins;
+    const proto = builtins.Array;
+    const wrap = (items) => new Arr(proto, items);
     const construct = (args, into) => {
         if (args.length !== 1)
-            return new ProgramArray(into, [...args]);
+            return new Arr(into, [...args]);
         const first = args[0];
         if (typeof first !== "number")
-            return new ProgramArray(into, [first]);
+            return new Arr(into, [first]);
         if (!Number.isInteger(first) || first < 0 || first > MAX_ARRAY_LENGTH)
             throw rangeError("Invalid array length.");
         // Sparse like JS: Array(3) has holes, and combinator loops already skip them.
-        return new ProgramArray(into, new Array(first));
+        return new Arr(into, new Array(first));
     };
-    const array = constructor(protos, proto, {
+    const array = constructor(builtins, proto, {
         name: "Array",
         length: 1,
         call: (_, args) => Effect.sync(() => construct(args, proto)),
         construct: (args, newTarget) => Effect.sync(() => construct(args, prototypeFrom(newTarget, proto))),
     });
-    methods(protos, array, [
-        ["isArray", 1, (_, args) => args[0] instanceof ProgramArray],
+    methods(builtins, array, [
+        ["isArray", 1, (_, args) => args[0] instanceof Arr],
         ["of", 0, (_, args) => wrap([...args])],
-        ["from", 1, (_, args) => arrayFrom(runner, args)],
+        ["from", 1, (_, args) => arrayFrom(ctx, args)],
     ]);
-    const self = (thisValue, name) => receiver(ProgramArray, thisValue, `Array.prototype.${name}`);
+    const self = (thisValue, name) => receiver(Arr, thisValue, `Array.prototype.${name}`);
     const optNumber = (name, value, label) => {
         if (value === undefined)
             return undefined;
@@ -117,10 +117,10 @@ export const arrayGlobal = (runner) => {
         length,
         (thisValue, args) => {
             const target = self(thisValue, name);
-            return body(target.items, target, applyCollectionCallback(runner, args[0], `Array.${name}`), args);
+            return body(target.items, target, applyCollectionCallback(ctx, args[0], `Array.${name}`), args);
         },
     ];
-    methods(protos, proto, [
+    methods(builtins, proto, [
         [
             "join",
             1,
@@ -179,7 +179,7 @@ export const arrayGlobal = (runner) => {
             "concat",
             1,
             (thisValue, args) => {
-                const joined = self(thisValue, "concat").items.concat(...args.map((item) => (item instanceof ProgramArray ? item.items : item)));
+                const joined = self(thisValue, "concat").items.concat(...args.map((item) => (item instanceof Arr ? item.items : item)));
                 checkArrayLength(joined.length);
                 return wrap(joined);
             },
@@ -188,7 +188,7 @@ export const arrayGlobal = (runner) => {
             "flat",
             0,
             (thisValue, args) => {
-                const flatten = (items, depth) => items.flatMap((item) => (item instanceof ProgramArray && depth > 0 ? flatten(item.items, depth - 1) : [item]));
+                const flatten = (items, depth) => items.flatMap((item) => (item instanceof Arr && depth > 0 ? flatten(item.items, depth - 1) : [item]));
                 const flattened = flatten(self(thisValue, "flat").items, optNumber("flat", args[0], "depth") ?? 1);
                 checkArrayLength(flattened.length);
                 return wrap(flattened);
@@ -212,7 +212,7 @@ export const arrayGlobal = (runner) => {
                 const length = items.length;
                 const holeCount = Array.from({ length }, (_, index) => Object.hasOwn(items, index)).filter((o) => !o).length;
                 const itemCount = length - holeCount;
-                return Effect.map(sortArray(runner, items, args[0], "Array.sort"), (sorted) => {
+                return Effect.map(sortArray(ctx, items, args[0], "Array.sort"), (sorted) => {
                     sorted.slice(0, itemCount).forEach((item, index) => {
                         items[index] = item;
                     });
@@ -226,7 +226,7 @@ export const arrayGlobal = (runner) => {
         [
             "toSorted",
             1,
-            (thisValue, args) => Effect.map(sortArray(runner, self(thisValue, "toSorted").items, args[0], "Array.toSorted"), wrap),
+            (thisValue, args) => Effect.map(sortArray(ctx, self(thisValue, "toSorted").items, args[0], "Array.toSorted"), wrap),
         ],
         ["toReversed", 0, (thisValue) => wrap([...self(thisValue, "toReversed").items].reverse())],
         [
@@ -342,7 +342,7 @@ export const arrayGlobal = (runner) => {
                 if (!(index in target))
                     continue;
                 const mapped = yield* apply([target[index], index, receiver]);
-                if (mapped instanceof ProgramArray)
+                if (mapped instanceof Arr)
                     values.push(...mapped.items);
                 else
                     values.push(mapped);

package/dist/stdlib/bytes.d.ts

@@ -0,0 +1,10 @@
+import { Obj } from "../interpreter/objects.js";
+import type { Interpreter } from "../interpreter/interpreter.js";
+export declare const uint8ArrayGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;
+export declare const textEncoderGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;
+/** A `TextDecoder` holding the host decoder its label and options configured. */
+export declare class TextDecoderObj extends Obj {
+    readonly decoder: TextDecoder;
+    constructor(proto: Obj, decoder: TextDecoder);
+}
+export declare const textDecoderGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;